2009-11-05 11:08:32 -07:00
/* Copyright (C) 2004 Bart
2012-01-25 16:55:51 -07:00
* Copyright ( C ) 2008 , 2009 , 2010 , 2011 , 2012 Curtis Gedak
2004-09-19 14:24:53 -06:00
*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 2 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU Library General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place - Suite 330 , Boston , MA 02111 - 1307 , USA .
*/
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
# include "../include/Win_GParted.h"
2006-01-24 05:31:58 -07:00
# include "../include/Dialog_Progress.h"
2009-01-06 15:22:09 -07:00
# include "../include/DialogFeatures.h"
2006-01-26 13:58:55 -07:00
# include "../include/Dialog_Disklabel.h"
2011-01-28 11:09:21 -07:00
# include "../include/Dialog_Rescue_Data.h"
2006-01-26 13:58:55 -07:00
# include "../include/Dialog_Partition_Resize_Move.h"
# include "../include/Dialog_Partition_Copy.h"
# include "../include/Dialog_Partition_New.h"
# include "../include/Dialog_Partition_Info.h"
2008-04-07 13:41:18 -06:00
# include "../include/Dialog_Partition_Label.h"
2006-03-31 03:49:27 -07:00
# include "../include/DialogManageFlags.h"
2006-03-24 12:08:41 -07:00
# include "../include/OperationCopy.h"
2006-11-26 07:27:16 -07:00
# include "../include/OperationCheck.h"
2006-03-24 12:08:41 -07:00
# include "../include/OperationCreate.h"
# include "../include/OperationDelete.h"
# include "../include/OperationFormat.h"
# include "../include/OperationResizeMove.h"
2012-01-22 13:49:52 -07:00
# include "../include/OperationChangeUUID.h"
2008-04-07 13:41:18 -06:00
# include "../include/OperationLabelPartition.h"
2010-01-02 04:13:31 -07:00
# include "../config.h"
2004-09-19 14:24:53 -06:00
2005-11-25 15:41:49 -07:00
# include <gtkmm/aboutdialog.h>
2006-01-19 12:15:15 -07:00
# include <gtkmm/messagedialog.h>
2006-02-02 03:59:44 -07:00
# include <gtkmm/radiobuttongroup.h>
2006-02-10 15:16:31 -07:00
# include <gtkmm/main.h>
2005-11-25 15:41:49 -07:00
2004-09-19 14:24:53 -06:00
namespace GParted
{
2009-01-06 15:22:09 -07:00
2006-02-02 06:50:37 -07:00
Win_GParted : : Win_GParted ( const std : : vector < Glib : : ustring > & user_devices )
2004-09-19 14:24:53 -06:00
{
2006-02-22 15:05:15 -07:00
copied_partition . Reset ( ) ;
selected_partition . Reset ( ) ;
2004-09-19 14:24:53 -06:00
new_count = 1 ;
2004-11-17 06:00:25 -07:00
current_device = 0 ;
2009-01-06 15:22:09 -07:00
pulse = false ;
2006-02-22 15:05:15 -07:00
OPERATIONSLIST_OPEN = true ;
2006-02-02 06:50:37 -07:00
gparted_core . set_user_devices ( user_devices ) ;
2009-01-06 15:22:09 -07:00
2006-08-20 10:51:18 -06:00
MENU_NEW = TOOLBAR_NEW =
MENU_DEL = TOOLBAR_DEL =
MENU_RESIZE_MOVE = TOOLBAR_RESIZE_MOVE =
MENU_COPY = TOOLBAR_COPY =
MENU_PASTE = TOOLBAR_PASTE =
MENU_FORMAT =
MENU_TOGGLE_MOUNT_SWAP =
MENU_MOUNT =
MENU_FLAGS =
MENU_INFO =
2008-04-07 13:41:18 -06:00
MENU_LABEL_PARTITION =
2012-01-22 13:49:52 -07:00
MENU_CHANGE_UUID =
2006-08-20 10:51:18 -06:00
TOOLBAR_UNDO =
TOOLBAR_APPLY = - 1 ;
2004-09-19 14:24:53 -06:00
//==== GUI =========================
2004-12-17 12:45:04 -07:00
this - > set_title ( _ ( " GParted " ) ) ;
this - > set_default_size ( 775 , 500 ) ;
2009-01-06 15:22:09 -07:00
2005-12-24 16:55:54 -07:00
try
{
2008-09-22 16:41:49 -06:00
this - > set_default_icon_name ( " gparted " ) ;
2005-12-24 16:55:54 -07:00
}
catch ( Glib : : Exception & e )
2009-01-06 15:22:09 -07:00
{
2005-12-24 16:55:54 -07:00
std : : cout < < e . what ( ) < < std : : endl ;
2009-01-06 15:22:09 -07:00
}
2004-09-19 14:24:53 -06:00
//Pack the main box
2009-01-06 15:22:09 -07:00
this - > add ( vbox_main ) ;
2004-09-19 14:24:53 -06:00
//menubar....
2006-02-22 15:05:15 -07:00
init_menubar ( ) ;
2004-09-19 14:24:53 -06:00
vbox_main . pack_start ( menubar_main , Gtk : : PACK_SHRINK ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//toolbar....
2006-02-22 15:05:15 -07:00
init_toolbar ( ) ;
2004-09-19 14:24:53 -06:00
vbox_main . pack_start ( hbox_toolbar , Gtk : : PACK_SHRINK ) ;
2009-01-06 15:22:09 -07:00
2006-03-09 06:12:44 -07:00
//drawingarea_visualdisk... ( contains the visual represenation of the disks )
2009-01-06 15:22:09 -07:00
drawingarea_visualdisk . signal_partition_selected . connect (
2006-03-07 04:55:27 -07:00
sigc : : mem_fun ( this , & Win_GParted : : on_partition_selected ) ) ;
2009-01-06 15:22:09 -07:00
drawingarea_visualdisk . signal_partition_activated . connect (
2006-03-07 04:55:27 -07:00
sigc : : mem_fun ( this , & Win_GParted : : on_partition_activated ) ) ;
2009-01-06 15:22:09 -07:00
drawingarea_visualdisk . signal_popup_menu . connect (
2006-03-07 04:55:27 -07:00
sigc : : mem_fun ( this , & Win_GParted : : on_partition_popup_menu ) ) ;
2006-03-09 06:12:44 -07:00
vbox_main . pack_start ( drawingarea_visualdisk , Gtk : : PACK_SHRINK ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//hpaned_main (NOTE: added to vpaned_main)
2006-02-22 15:05:15 -07:00
init_hpaned_main ( ) ;
2004-09-19 14:24:53 -06:00
vpaned_main . pack1 ( hpaned_main , true , true ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//vpaned_main....
2004-12-17 12:45:04 -07:00
vbox_main . pack_start ( vpaned_main ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//device info...
2006-02-22 15:05:15 -07:00
init_device_info ( ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//operationslist...
2006-09-17 07:23:47 -06:00
hbox_operations . signal_undo . connect ( sigc : : mem_fun ( this , & Win_GParted : : activate_undo ) ) ;
hbox_operations . signal_clear . connect ( sigc : : mem_fun ( this , & Win_GParted : : clear_operationslist ) ) ;
hbox_operations . signal_apply . connect ( sigc : : mem_fun ( this , & Win_GParted : : activate_apply ) ) ;
hbox_operations . signal_close . connect ( sigc : : mem_fun ( this , & Win_GParted : : close_operationslist ) ) ;
2004-09-19 14:24:53 -06:00
vpaned_main . pack2 ( hbox_operations , true , true ) ;
2006-09-17 07:23:47 -06:00
2009-01-06 15:22:09 -07:00
//statusbar...
2006-01-07 14:23:09 -07:00
pulsebar . set_pulse_step ( 0.01 ) ;
statusbar . add ( pulsebar ) ;
2004-10-11 08:19:56 -06:00
vbox_main . pack_start ( statusbar , Gtk : : PACK_SHRINK ) ;
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
this - > show_all_children ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
//make sure harddisk information is closed..
hpaned_main . get_child1 ( ) - > hide ( ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : init_menubar ( )
2004-09-19 14:24:53 -06:00
{
2009-01-06 15:22:09 -07:00
//fill menubar_main and connect callbacks
2004-09-19 14:24:53 -06:00
//gparted
2006-02-22 15:05:15 -07:00
menu = manage ( new Gtk : : Menu ( ) ) ;
2004-09-19 14:24:53 -06:00
image = manage ( new Gtk : : Image ( Gtk : : Stock : : REFRESH , Gtk : : ICON_SIZE_MENU ) ) ;
2006-09-17 07:23:47 -06:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : ImageMenuElem (
_ ( " _Refresh Devices " ) ,
Gtk : : AccelKey ( " <control>r " ) ,
2009-01-06 15:22:09 -07:00
* image ,
2006-09-17 07:23:47 -06:00
sigc : : mem_fun ( * this , & Win_GParted : : menu_gparted_refresh_devices ) ) ) ;
2009-01-06 15:22:09 -07:00
2006-02-02 03:59:44 -07:00
image = manage ( new Gtk : : Image ( Gtk : : Stock : : HARDDISK , Gtk : : ICON_SIZE_MENU ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : ImageMenuElem ( _ ( " _Devices " ) , * image ) ) ;
2006-02-22 15:05:15 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : StockMenuElem (
2006-09-17 07:23:47 -06:00
Gtk : : Stock : : QUIT , sigc : : mem_fun ( * this , & Win_GParted : : menu_gparted_quit ) ) ) ;
2006-02-22 15:05:15 -07:00
menubar_main . items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( _ ( " _GParted " ) , * menu ) ) ;
2009-01-06 15:22:09 -07:00
2005-11-27 12:48:00 -07:00
//edit
2006-02-22 15:05:15 -07:00
menu = manage ( new Gtk : : Menu ( ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : ImageMenuElem (
_ ( " _Undo Last Operation " ) ,
2006-09-17 07:23:47 -06:00
Gtk : : AccelKey ( " <control>z " ) ,
2009-01-06 15:22:09 -07:00
* manage ( new Gtk : : Image ( Gtk : : Stock : : UNDO , Gtk : : ICON_SIZE_MENU ) ) ,
2006-09-17 07:23:47 -06:00
sigc : : mem_fun ( * this , & Win_GParted : : activate_undo ) ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : ImageMenuElem (
_ ( " _Clear All Operations " ) ,
* manage ( new Gtk : : Image ( Gtk : : Stock : : CLEAR , Gtk : : ICON_SIZE_MENU ) ) ,
2006-09-17 07:23:47 -06:00
sigc : : mem_fun ( * this , & Win_GParted : : clear_operationslist ) ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : ImageMenuElem (
_ ( " _Apply All Operations " ) ,
* manage ( new Gtk : : Image ( Gtk : : Stock : : APPLY , Gtk : : ICON_SIZE_MENU ) ) ,
2006-09-17 07:23:47 -06:00
sigc : : mem_fun ( * this , & Win_GParted : : activate_apply ) ) ) ;
2006-02-22 15:05:15 -07:00
menubar_main . items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( _ ( " _Edit " ) , * menu ) ) ;
2008-08-05 09:34:10 -06:00
2004-09-27 14:12:47 -06:00
//view
2006-04-05 03:33:04 -06:00
menu = manage ( new Gtk : : Menu ( ) ) ;
2006-09-17 07:23:47 -06:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : CheckMenuElem (
_ ( " Device _Information " ) , sigc : : mem_fun ( * this , & Win_GParted : : menu_view_harddisk_info ) ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : CheckMenuElem (
2006-09-17 07:23:47 -06:00
_ ( " Pending _Operations " ) , sigc : : mem_fun ( * this , & Win_GParted : : menu_view_operations ) ) ) ;
2006-02-22 15:05:15 -07:00
menubar_main . items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( _ ( " _View " ) , * menu ) ) ;
2008-08-05 09:34:10 -06:00
2008-11-14 12:41:14 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem (
_ ( " _File System Support " ) , sigc : : mem_fun ( * this , & Win_GParted : : menu_gparted_features ) ) ) ;
2005-01-30 07:31:29 -07:00
//device
2006-02-22 15:05:15 -07:00
menu = manage ( new Gtk : : Menu ( ) ) ;
2009-01-13 11:14:20 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( Glib : : ustring ( _ ( " _Create Partition Table " ) ) + " ... " ,
2006-08-28 14:11:58 -06:00
sigc : : mem_fun ( * this , & Win_GParted : : activate_disklabel ) ) ) ;
2011-01-28 11:09:21 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( Glib : : ustring ( _ ( " _Attempt Data Rescue " ) ) + " ... " ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_attempt_rescue_data ) ) ) ;
2006-02-22 15:05:15 -07:00
menubar_main . items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( _ ( " _Device " ) , * menu ) ) ;
2008-08-05 09:34:10 -06:00
2005-01-30 07:31:29 -07:00
//partition
2006-02-22 15:05:15 -07:00
init_partition_menu ( ) ;
menubar_main . items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( _ ( " _Partition " ) , menu_partition ) ) ;
2008-08-05 09:34:10 -06:00
2004-09-19 14:24:53 -06:00
//help
menu = manage ( new Gtk : : Menu ( ) ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : ImageMenuElem (
_ ( " _Contents " ) ,
2008-08-05 09:34:10 -06:00
Gtk : : AccelKey ( " F1 " ) ,
2009-01-06 15:22:09 -07:00
* manage ( new Gtk : : Image ( Gtk : : Stock : : HELP , Gtk : : ICON_SIZE_MENU ) ) ,
2008-08-05 09:34:10 -06:00
sigc : : mem_fun ( * this , & Win_GParted : : menu_help_contents ) ) ) ;
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2006-09-17 07:23:47 -06:00
menu - > items ( ) . push_back ( Gtk : : Menu_Helpers : : StockMenuElem (
Gtk : : Stock : : ABOUT , sigc : : mem_fun ( * this , & Win_GParted : : menu_help_about ) ) ) ;
2005-11-25 15:41:49 -07:00
2006-02-22 15:05:15 -07:00
menubar_main . items ( ) . push_back ( Gtk : : Menu_Helpers : : MenuElem ( _ ( " _Help " ) , * menu ) ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : init_toolbar ( )
2004-09-19 14:24:53 -06:00
{
2006-08-20 10:51:18 -06:00
int index = 0 ;
2009-01-06 15:22:09 -07:00
//initialize and pack toolbar_main
2004-09-19 14:24:53 -06:00
hbox_toolbar . pack_start ( toolbar_main ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//NEW and DELETE
2010-02-22 10:30:14 -07:00
image = manage ( new Gtk : : Image ( Gtk : : Stock : : NEW , Gtk : : ICON_SIZE_BUTTON ) ) ;
/*TO TRANSLATORS: "New" is a tool bar item for partition actions. */
Glib : : ustring str_temp = _ ( " New " ) ;
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( * image , str_temp ) ) ;
2006-08-20 10:51:18 -06:00
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_new ) ) ;
toolbar_main . append ( * toolbutton ) ;
TOOLBAR_NEW = index + + ;
2009-01-06 15:22:09 -07:00
toolbutton - > set_tooltip ( tooltips , _ ( " Create a new partition in the selected unallocated space " ) ) ;
2004-09-19 14:24:53 -06:00
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( Gtk : : Stock : : DELETE ) ) ;
2006-02-02 03:59:44 -07:00
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_delete ) ) ;
toolbar_main . append ( * toolbutton ) ;
2006-08-20 10:51:18 -06:00
TOOLBAR_DEL = index + + ;
2009-01-06 15:22:09 -07:00
toolbutton - > set_tooltip ( tooltips , _ ( " Delete the selected partition " ) ) ;
2004-09-19 14:24:53 -06:00
toolbar_main . append ( * ( Gtk : : manage ( new Gtk : : SeparatorToolItem ) ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//RESIZE/MOVE
image = manage ( new Gtk : : Image ( Gtk : : Stock : : GOTO_LAST , Gtk : : ICON_SIZE_BUTTON ) ) ;
2010-02-22 10:30:14 -07:00
str_temp = _ ( " Resize/Move " ) ;
2008-11-19 13:17:32 -07:00
//Condition string split and Undo button.
// for longer translated string, split string in two and skip the Undo button to permit full toolbar to display
// FIXME: Is there a better way to do this, perhaps without the conditional? At the moment this seems to be the best compromise.
bool display_undo = true ;
if ( str_temp . length ( ) > 14 ) {
2009-02-09 10:58:42 -07:00
size_t index = str_temp . find ( " / " ) ;
if ( index ! = Glib : : ustring : : npos ) {
str_temp . replace ( index , 1 , " \n / " ) ;
display_undo = false ;
}
2008-11-19 13:17:32 -07:00
}
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( * image , str_temp ) ) ;
2006-02-02 03:59:44 -07:00
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_resize ) ) ;
toolbar_main . append ( * toolbutton ) ;
2006-08-20 10:51:18 -06:00
TOOLBAR_RESIZE_MOVE = index + + ;
2009-01-06 15:22:09 -07:00
toolbutton - > set_tooltip ( tooltips , _ ( " Resize/Move the selected partition " ) ) ;
2004-09-19 14:24:53 -06:00
toolbar_main . append ( * ( Gtk : : manage ( new Gtk : : SeparatorToolItem ) ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2004-09-19 14:24:53 -06:00
//COPY and PASTE
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( Gtk : : Stock : : COPY ) ) ;
2006-02-02 03:59:44 -07:00
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_copy ) ) ;
toolbar_main . append ( * toolbutton ) ;
2006-08-20 10:51:18 -06:00
TOOLBAR_COPY = index + + ;
2009-01-06 15:22:09 -07:00
toolbutton - > set_tooltip ( tooltips , _ ( " Copy the selected partition to the clipboard " ) ) ;
2004-09-19 14:24:53 -06:00
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( Gtk : : Stock : : PASTE ) ) ;
2006-02-02 03:59:44 -07:00
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_paste ) ) ;
toolbar_main . append ( * toolbutton ) ;
2006-08-20 10:51:18 -06:00
TOOLBAR_PASTE = index + + ;
2009-01-06 15:22:09 -07:00
toolbutton - > set_tooltip ( tooltips , _ ( " Paste the partition from the clipboard " ) ) ;
2004-09-19 14:24:53 -06:00
toolbar_main . append ( * ( Gtk : : manage ( new Gtk : : SeparatorToolItem ) ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//UNDO and APPLY
2008-11-19 13:17:32 -07:00
if ( display_undo ) {
//Undo button is displayed only if translated language "Resize/Move" is not too long. See above setting of this condition.
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( Gtk : : Stock : : UNDO ) ) ;
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_undo ) ) ;
toolbar_main . append ( * toolbutton ) ;
TOOLBAR_UNDO = index + + ;
toolbutton - > set_sensitive ( false ) ;
toolbutton - > set_tooltip ( tooltips , _ ( " Undo Last Operation " ) ) ;
}
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
toolbutton = Gtk : : manage ( new Gtk : : ToolButton ( Gtk : : Stock : : APPLY ) ) ;
2006-02-02 03:59:44 -07:00
toolbutton - > signal_clicked ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : activate_apply ) ) ;
toolbar_main . append ( * toolbutton ) ;
2006-08-20 10:51:18 -06:00
TOOLBAR_APPLY = index + + ;
2006-02-02 03:59:44 -07:00
toolbutton - > set_sensitive ( false ) ;
2009-01-06 15:22:09 -07:00
toolbutton - > set_tooltip ( tooltips , _ ( " Apply All Operations " ) ) ;
2005-12-29 16:35:37 -07:00
//initialize and pack combo_devices
liststore_devices = Gtk : : ListStore : : create ( treeview_devices_columns ) ;
combo_devices . set_model ( liststore_devices ) ;
2005-12-30 11:11:03 -07:00
combo_devices . pack_start ( treeview_devices_columns . icon , false ) ;
2005-12-29 16:35:37 -07:00
combo_devices . pack_start ( treeview_devices_columns . device ) ;
2005-12-30 11:11:03 -07:00
combo_devices . pack_start ( treeview_devices_columns . size , false ) ;
2009-01-06 15:22:09 -07:00
2005-12-29 16:35:37 -07:00
combo_devices . signal_changed ( ) . connect ( sigc : : mem_fun ( * this , & Win_GParted : : combo_devices_changed ) ) ;
hbox_toolbar . pack_start ( combo_devices , Gtk : : PACK_SHRINK ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : init_partition_menu ( )
2004-09-19 14:24:53 -06:00
{
2006-08-20 10:51:18 -06:00
int index = 0 ;
2005-01-30 07:31:29 -07:00
//fill menu_partition
2010-02-22 10:30:14 -07:00
image = manage ( new Gtk : : Image ( Gtk : : Stock : : NEW , Gtk : : ICON_SIZE_MENU ) ) ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) . push_back (
2010-02-22 10:30:14 -07:00
/*TO TRANSLATORS: "_New" is a sub menu item for the partition menu. */
Gtk : : Menu_Helpers : : ImageMenuElem ( _ ( " _New " ) ,
* image ,
2006-01-02 08:18:29 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : activate_new ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_NEW = index + + ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) . push_back (
Gtk : : Menu_Helpers : : StockMenuElem ( Gtk : : Stock : : DELETE ,
2006-01-02 08:18:29 -07:00
Gtk : : AccelKey ( GDK_Delete , Gdk : : BUTTON1_MASK ) ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_delete ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_DEL = index + + ;
2006-01-02 08:18:29 -07:00
menu_partition . items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
image = manage ( new Gtk : : Image ( Gtk : : Stock : : GOTO_LAST , Gtk : : ICON_SIZE_MENU ) ) ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) . push_back (
Gtk : : Menu_Helpers : : ImageMenuElem ( _ ( " _Resize/Move " ) ,
* image ,
2006-01-02 08:18:29 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : activate_resize ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_RESIZE_MOVE = index + + ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
menu_partition . items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) . push_back (
2006-01-02 08:18:29 -07:00
Gtk : : Menu_Helpers : : StockMenuElem ( Gtk : : Stock : : COPY ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_copy ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_COPY = index + + ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) . push_back (
2006-01-02 08:18:29 -07:00
Gtk : : Menu_Helpers : : StockMenuElem ( Gtk : : Stock : : PASTE ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_paste ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_PASTE = index + + ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
menu_partition . items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
image = manage ( new Gtk : : Image ( Gtk : : Stock : : CONVERT , Gtk : : ICON_SIZE_MENU ) ) ;
2008-11-18 16:58:17 -07:00
/*TO TRANSLATORS: menuitem which holds a submenu with file systems.. */
2006-01-02 08:18:29 -07:00
menu_partition . items ( ) . push_back (
Gtk : : Menu_Helpers : : ImageMenuElem ( _ ( " _Format to " ) ,
* image ,
* create_format_menu ( ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_FORMAT = index + + ;
2009-01-06 15:22:09 -07:00
2006-08-20 10:51:18 -06:00
menu_partition . items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
index + + ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
menu_partition . items ( ) . push_back (
2006-08-28 14:11:58 -06:00
Gtk : : Menu_Helpers : : MenuElem ( _ ( " Unmount " ) ,
2006-03-09 12:37:50 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : toggle_swap_mount_state ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_TOGGLE_MOUNT_SWAP = index + + ;
2009-01-06 15:22:09 -07:00
2008-11-18 16:58:17 -07:00
/*TO TRANSLATORS: menuitem which holds a submenu with mount points.. */
2006-03-16 10:09:17 -07:00
menu_partition . items ( ) . push_back (
2006-08-28 14:11:58 -06:00
Gtk : : Menu_Helpers : : MenuElem ( _ ( " _Mount on " ) , * manage ( new Gtk : : Menu ( ) ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_MOUNT = index + + ;
2006-03-16 10:09:17 -07:00
2006-03-31 03:49:27 -07:00
menu_partition . items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2006-03-31 03:49:27 -07:00
menu_partition . items ( ) . push_back (
2006-08-28 14:11:58 -06:00
Gtk : : Menu_Helpers : : MenuElem ( _ ( " M_anage Flags " ) ,
2006-03-31 03:49:27 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : activate_manage_flags ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_FLAGS = index + + ;
2006-03-31 03:49:27 -07:00
2006-11-26 07:27:16 -07:00
menu_partition . items ( ) . push_back (
Gtk : : Menu_Helpers : : MenuElem ( _ ( " C_heck " ) ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_check ) ) ) ;
MENU_CHECK = index + + ;
2008-04-07 13:41:18 -06:00
menu_partition . items ( ) . push_back (
Gtk : : Menu_Helpers : : MenuElem ( _ ( " _Label " ) ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_label_partition ) ) ) ;
MENU_LABEL_PARTITION = index + + ;
2012-01-22 13:49:52 -07:00
menu_partition . items ( ) . push_back (
Gtk : : Menu_Helpers : : MenuElem ( _ ( " New UU_ID " ) ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_change_uuid ) ) ) ;
MENU_CHANGE_UUID = index + + ;
2006-03-31 03:49:27 -07:00
menu_partition . items ( ) . push_back ( Gtk : : Menu_Helpers : : SeparatorElem ( ) ) ;
2006-08-20 10:51:18 -06:00
index + + ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) . push_back (
2006-01-02 08:18:29 -07:00
Gtk : : Menu_Helpers : : StockMenuElem ( Gtk : : Stock : : DIALOG_INFO ,
sigc : : mem_fun ( * this , & Win_GParted : : activate_info ) ) ) ;
2006-08-20 10:51:18 -06:00
MENU_INFO = index + + ;
2009-01-06 15:22:09 -07:00
menu_partition . accelerate ( * this ) ;
2004-09-19 14:24:53 -06:00
}
2006-01-02 08:18:29 -07:00
Gtk : : Menu * Win_GParted : : create_format_menu ( )
2004-09-19 14:24:53 -06:00
{
2006-01-02 08:18:29 -07:00
menu = manage ( new Gtk : : Menu ( ) ) ;
2008-12-07 11:43:35 -07:00
for ( unsigned int t = 0 ; t < gparted_core . get_filesystems ( ) . size ( ) ; t + + )
2004-09-19 14:24:53 -06:00
{
2010-10-18 15:26:07 -06:00
//Skip luks, lvm2, and unknown because these are not file systems
2010-01-02 04:13:31 -07:00
if (
2012-01-28 04:23:21 -07:00
gparted_core . get_filesystems ( ) [ t ] . filesystem = = GParted : : FS_LUKS | |
gparted_core . get_filesystems ( ) [ t ] . filesystem = = GParted : : FS_LVM2_PV | |
2009-02-18 09:19:49 -07:00
gparted_core . get_filesystems ( ) [ t ] . filesystem = = GParted : : FS_UNKNOWN
)
2008-12-07 11:43:35 -07:00
continue ;
2006-01-02 08:18:29 -07:00
hbox = manage ( new Gtk : : HBox ( ) ) ;
2009-01-06 15:22:09 -07:00
2004-10-06 09:32:40 -06:00
//the colored square
2006-01-02 08:18:29 -07:00
hbox - > pack_start ( * manage ( new Gtk : : Image (
2009-01-06 15:22:09 -07:00
Utils : : get_color_as_pixbuf (
2006-01-02 08:18:29 -07:00
gparted_core . get_filesystems ( ) [ t ] . filesystem , 16 , 16 ) ) ) ,
2009-01-06 15:22:09 -07:00
Gtk : : PACK_SHRINK ) ;
2004-10-06 09:32:40 -06:00
//the label...
2006-01-02 08:18:29 -07:00
hbox - > pack_start ( * Utils : : mk_label (
2009-01-06 15:22:09 -07:00
" " +
2006-03-28 05:40:29 -07:00
Utils : : get_filesystem_string ( gparted_core . get_filesystems ( ) [ t ] . filesystem ) ) ,
2009-01-06 15:22:09 -07:00
Gtk : : PACK_SHRINK ) ;
2006-01-02 08:18:29 -07:00
menu - > items ( ) . push_back ( * manage ( new Gtk : : MenuItem ( * hbox ) ) ) ;
if ( gparted_core . get_filesystems ( ) [ t ] . create )
2009-01-06 15:22:09 -07:00
menu - > items ( ) . back ( ) . signal_activate ( ) . connect (
2006-01-02 08:18:29 -07:00
sigc : : bind < GParted : : FILESYSTEM > ( sigc : : mem_fun ( * this , & Win_GParted : : activate_format ) ,
gparted_core . get_filesystems ( ) [ t ] . filesystem ) ) ;
else
menu - > items ( ) . back ( ) . set_sensitive ( false ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
return menu ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
void Win_GParted : : init_device_info ( )
{
2004-09-25 15:59:53 -06:00
vbox_info . set_spacing ( 5 ) ;
2006-03-28 05:40:29 -07:00
int top = 0 , bottom = 1 ;
2009-01-06 15:22:09 -07:00
2004-09-25 15:59:53 -06:00
//title
2009-01-06 15:22:09 -07:00
vbox_info . pack_start (
2009-12-06 14:36:39 -07:00
* Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Device Information " ) ) + " </b> " ) ,
2006-03-28 05:40:29 -07:00
Gtk : : PACK_SHRINK ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//GENERAL DEVICE INFO
2004-09-19 14:24:53 -06:00
table = manage ( new Gtk : : Table ( ) ) ;
2004-09-29 06:33:40 -06:00
table - > set_col_spacings ( 10 ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//model
2006-03-28 05:40:29 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Model: " ) ) + " </b> " ) ,
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//size
2006-03-28 05:40:29 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Size: " ) ) + " </b> " ) ,
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//path
2006-03-28 05:40:29 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Path: " ) ) + " </b> " ,
true ,
Gtk : : ALIGN_LEFT ,
Gtk : : ALIGN_TOP ) ,
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-25 15:59:53 -06:00
vbox_info . pack_start ( * table , Gtk : : PACK_SHRINK ) ;
2009-01-06 15:22:09 -07:00
//DETAILED DEVICE INFO
2006-03-28 05:40:29 -07:00
top = 0 ; bottom = 1 ;
table = manage ( new Gtk : : Table ( ) ) ;
2004-12-27 05:08:01 -07:00
table - > set_col_spacings ( 10 ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//one blank line
2005-12-13 14:30:13 -07:00
table - > attach ( * Utils : : mk_label ( " " ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//disktype
2009-12-06 14:32:12 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Partition table: " ) ) + " </b> " ) ,
2006-03-28 05:40:29 -07:00
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//heads
2006-03-28 05:40:29 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Heads: " ) ) + " </b> " ) ,
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//sectors/track
2009-12-06 14:36:39 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Sectors/track: " ) ) + " </b> " ) ,
2006-03-28 05:40:29 -07:00
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//cylinders
2006-03-28 05:40:29 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Cylinders: " ) ) + " </b> " ) ,
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2009-01-06 15:22:09 -07:00
2004-09-29 06:33:40 -06:00
//total sectors
2009-12-06 14:36:39 -07:00
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Total sectors: " ) ) + " </b> " ) ,
2006-03-28 05:40:29 -07:00
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
2008-12-03 11:52:20 -07:00
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
2006-03-28 05:40:29 -07:00
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2010-02-20 15:12:26 -07:00
//sector size
table - > attach ( * Utils : : mk_label ( " <b> " + static_cast < Glib : : ustring > ( _ ( " Sector size: " ) ) + " </b> " ) ,
0 , 1 ,
top , bottom ,
Gtk : : FILL ) ;
device_info . push_back ( Utils : : mk_label ( " " , true , Gtk : : ALIGN_LEFT , Gtk : : ALIGN_CENTER , false , true ) ) ;
table - > attach ( * device_info . back ( ) , 1 , 2 , top + + , bottom + + , Gtk : : FILL ) ;
2004-09-25 15:59:53 -06:00
vbox_info . pack_start ( * table , Gtk : : PACK_SHRINK ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : init_hpaned_main ( )
2004-09-19 14:24:53 -06:00
{
//left scrollwindow (holds device info)
2006-09-17 07:23:47 -06:00
scrollwindow = manage ( new Gtk : : ScrolledWindow ( ) ) ;
2004-12-27 05:08:01 -07:00
scrollwindow - > set_shadow_type ( Gtk : : SHADOW_ETCHED_IN ) ;
scrollwindow - > set_policy ( Gtk : : POLICY_AUTOMATIC , Gtk : : POLICY_AUTOMATIC ) ;
2004-09-19 14:24:53 -06:00
2006-09-17 07:23:47 -06:00
hpaned_main . pack1 ( * scrollwindow , true , true ) ;
2004-09-19 14:24:53 -06:00
scrollwindow - > add ( vbox_info ) ;
//right scrollwindow (holds treeview with partitions)
2006-09-17 07:23:47 -06:00
scrollwindow = manage ( new Gtk : : ScrolledWindow ( ) ) ;
2004-12-27 05:08:01 -07:00
scrollwindow - > set_shadow_type ( Gtk : : SHADOW_ETCHED_IN ) ;
scrollwindow - > set_policy ( Gtk : : POLICY_AUTOMATIC , Gtk : : POLICY_AUTOMATIC ) ;
2009-01-06 15:22:09 -07:00
2005-12-23 17:06:05 -07:00
//connect signals and add treeview_detail
treeview_detail . signal_partition_selected . connect ( sigc : : mem_fun ( this , & Win_GParted : : on_partition_selected ) ) ;
treeview_detail . signal_partition_activated . connect ( sigc : : mem_fun ( this , & Win_GParted : : on_partition_activated ) ) ;
treeview_detail . signal_popup_menu . connect ( sigc : : mem_fun ( this , & Win_GParted : : on_partition_popup_menu ) ) ;
2004-12-27 05:08:01 -07:00
scrollwindow - > add ( treeview_detail ) ;
2006-09-17 07:23:47 -06:00
hpaned_main . pack2 ( * scrollwindow , true , true ) ;
2004-09-19 14:24:53 -06:00
}
2005-12-29 16:35:37 -07:00
void Win_GParted : : refresh_combo_devices ( )
2004-10-11 04:23:24 -06:00
{
2005-12-29 16:35:37 -07:00
liststore_devices - > clear ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-02 03:59:44 -07:00
menu = manage ( new Gtk : : Menu ( ) ) ;
Gtk : : RadioButtonGroup radio_group ;
2009-01-06 15:22:09 -07:00
2004-12-27 05:08:01 -07:00
for ( unsigned int i = 0 ; i < devices . size ( ) ; i + + )
2006-02-02 03:59:44 -07:00
{
//combo...
2005-12-29 16:35:37 -07:00
treerow = * ( liststore_devices - > append ( ) ) ;
treerow [ treeview_devices_columns . icon ] =
render_icon ( Gtk : : Stock : : HARDDISK , Gtk : : ICON_SIZE_LARGE_TOOLBAR ) ;
2006-03-14 14:37:47 -07:00
treerow [ treeview_devices_columns . device ] = devices [ i ] . get_path ( ) ;
2010-04-26 11:42:23 -06:00
treerow [ treeview_devices_columns . size ] = " ( " + Utils : : format_size ( devices [ i ] . length , devices [ i ] . sector_size ) + " ) " ;
2009-01-06 15:22:09 -07:00
2006-02-02 03:59:44 -07:00
//devices submenu....
2006-03-20 03:12:55 -07:00
hbox = manage ( new Gtk : : HBox ( ) ) ;
hbox - > pack_start ( * Utils : : mk_label ( devices [ i ] . get_path ( ) ) , Gtk : : PACK_SHRINK ) ;
2010-04-26 11:42:23 -06:00
hbox - > pack_start ( * Utils : : mk_label ( " ( " + Utils : : format_size ( devices [ i ] . length , devices [ i ] . sector_size ) + " ) " ,
2006-03-20 03:12:55 -07:00
true ,
Gtk : : ALIGN_RIGHT ) ,
Gtk : : PACK_EXPAND_WIDGET ) ;
2009-01-06 15:22:09 -07:00
2006-03-20 03:12:55 -07:00
menu - > items ( ) . push_back ( * manage ( new Gtk : : RadioMenuItem ( radio_group ) ) ) ;
menu - > items ( ) . back ( ) . add ( * hbox ) ;
2009-01-06 15:22:09 -07:00
menu - > items ( ) . back ( ) . signal_activate ( ) . connect (
2006-03-20 03:12:55 -07:00
sigc : : bind < unsigned int > ( sigc : : mem_fun ( * this , & Win_GParted : : radio_devices_changed ) , i ) ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
2006-02-02 03:59:44 -07:00
menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . remove_submenu ( ) ;
if ( menu - > items ( ) . size ( ) )
2006-03-20 03:12:55 -07:00
{
menu - > show_all ( ) ;
2006-02-02 03:59:44 -07:00
menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . set_submenu ( * menu ) ;
2006-03-20 03:12:55 -07:00
}
2009-01-06 15:22:09 -07:00
2005-12-29 16:35:37 -07:00
combo_devices . set_active ( current_device ) ;
2004-10-11 04:23:24 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : show_pulsebar ( const Glib : : ustring & status_message )
2004-10-11 04:23:24 -06:00
{
2006-01-07 14:23:09 -07:00
pulsebar . show ( ) ;
2006-01-08 08:20:14 -07:00
statusbar . push ( status_message ) ;
2009-01-06 15:22:09 -07:00
2004-10-11 04:23:24 -06:00
//disable all input stuff
toolbar_main . set_sensitive ( false ) ;
menubar_main . set_sensitive ( false ) ;
2005-12-29 16:35:37 -07:00
combo_devices . set_sensitive ( false ) ;
2005-01-30 07:31:29 -07:00
menu_partition . set_sensitive ( false ) ;
2005-12-29 07:21:45 -07:00
treeview_detail . set_sensitive ( false ) ;
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . set_sensitive ( false ) ;
2009-01-06 15:22:09 -07:00
2004-10-11 04:23:24 -06:00
//the actual 'pulsing'
while ( pulse )
{
2006-01-07 14:23:09 -07:00
pulsebar . pulse ( ) ;
2005-12-29 07:21:45 -07:00
while ( Gtk : : Main : : events_pending ( ) )
Gtk : : Main : : iteration ( ) ;
2012-01-04 17:30:28 -07:00
gdk_threads_leave ( ) ;
2012-01-09 19:22:48 -07:00
usleep ( 100000 ) ;
2012-01-04 17:30:28 -07:00
gdk_threads_enter ( ) ;
2008-10-30 12:51:14 -06:00
Glib : : ustring tmp_msg = gparted_core . get_thread_status_message ( ) ;
if ( tmp_msg ! = " " )
statusbar . push ( tmp_msg ) ;
2004-10-11 04:23:24 -06:00
}
2009-01-06 15:22:09 -07:00
2005-12-29 07:21:45 -07:00
thread - > join ( ) ;
2009-01-06 15:22:09 -07:00
2006-01-07 14:23:09 -07:00
pulsebar . hide ( ) ;
2005-12-29 07:21:45 -07:00
statusbar . pop ( ) ;
2009-01-06 15:22:09 -07:00
2004-10-11 04:23:24 -06:00
//enable all disabled stuff
toolbar_main . set_sensitive ( true ) ;
menubar_main . set_sensitive ( true ) ;
2005-12-29 16:35:37 -07:00
combo_devices . set_sensitive ( true ) ;
2005-01-30 07:31:29 -07:00
menu_partition . set_sensitive ( true ) ;
2005-12-29 07:21:45 -07:00
treeview_detail . set_sensitive ( true ) ;
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . set_sensitive ( true ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : Fill_Label_Device_Info ( bool clear )
2004-09-19 14:24:53 -06:00
{
2005-02-01 10:04:03 -07:00
if ( clear )
for ( unsigned int t = 0 ; t < device_info . size ( ) ; t + + )
device_info [ t ] - > set_text ( " " ) ;
2009-01-06 15:22:09 -07:00
2005-02-01 10:04:03 -07:00
else
2009-01-06 15:22:09 -07:00
{
2005-02-01 10:04:03 -07:00
short t = 0 ;
2009-01-06 15:22:09 -07:00
2005-02-01 10:04:03 -07:00
//global info...
device_info [ t + + ] - > set_text ( devices [ current_device ] . model ) ;
2010-04-26 11:42:23 -06:00
device_info [ t + + ] - > set_text ( Utils : : format_size ( devices [ current_device ] . length , devices [ current_device ] . sector_size ) ) ;
2006-03-14 14:37:47 -07:00
device_info [ t + + ] - > set_text ( Glib : : build_path ( " \n " , devices [ current_device ] . get_paths ( ) ) ) ;
2009-01-06 15:22:09 -07:00
2005-02-01 10:04:03 -07:00
//detailed info
device_info [ t + + ] - > set_text ( devices [ current_device ] . disktype ) ;
2005-12-13 14:30:13 -07:00
device_info [ t + + ] - > set_text ( Utils : : num_to_str ( devices [ current_device ] . heads ) ) ;
device_info [ t + + ] - > set_text ( Utils : : num_to_str ( devices [ current_device ] . sectors ) ) ;
device_info [ t + + ] - > set_text ( Utils : : num_to_str ( devices [ current_device ] . cylinders ) ) ;
device_info [ t + + ] - > set_text ( Utils : : num_to_str ( devices [ current_device ] . length ) ) ;
2010-02-20 15:12:26 -07:00
device_info [ t + + ] - > set_text ( Utils : : num_to_str ( devices [ current_device ] . sector_size ) ) ;
2005-02-01 10:04:03 -07:00
}
2004-09-19 14:24:53 -06:00
}
2004-12-27 05:08:01 -07:00
bool Win_GParted : : on_delete_event ( GdkEventAny * event )
2004-09-19 14:24:53 -06:00
{
2006-03-24 12:08:41 -07:00
return ! Quit_Check_Operations ( ) ;
2009-01-06 15:22:09 -07:00
}
2004-09-19 14:24:53 -06:00
2006-08-01 14:19:17 -06:00
void Win_GParted : : Add_Operation ( Operation * operation , int index )
2004-09-19 14:24:53 -06:00
{
2006-07-20 13:14:44 -06:00
if ( operation )
2009-01-06 15:22:09 -07:00
{
2006-07-20 13:14:44 -06:00
Glib : : ustring error ;
2006-11-26 07:27:16 -07:00
//FIXME: this is becoming a mess.. maybe it's better to check if partition_new > 0
2010-05-20 10:00:14 -06:00
if ( operation - > type = = OPERATION_DELETE | |
operation - > type = = OPERATION_FORMAT | |
2006-11-26 07:27:16 -07:00
operation - > type = = OPERATION_CHECK | |
2012-01-22 13:49:52 -07:00
operation - > type = = OPERATION_CHANGE_UUID | |
2010-05-20 10:00:14 -06:00
operation - > type = = OPERATION_LABEL_PARTITION | |
gparted_core . snap_to_alignment ( operation - > device , operation - > partition_new , error )
)
2006-07-20 13:14:44 -06:00
{
operation - > create_description ( ) ;
if ( index > = 0 & & index < static_cast < int > ( operations . size ( ) ) )
operations . insert ( operations . begin ( ) + index , operation ) ;
else
operations . push_back ( operation ) ;
2006-07-11 12:13:27 -06:00
2006-09-16 05:27:05 -06:00
allow_undo_clear_apply ( true ) ;
2006-07-20 13:14:44 -06:00
Refresh_Visual ( ) ;
2009-01-06 15:22:09 -07:00
2006-07-20 13:14:44 -06:00
if ( operations . size ( ) = = 1 ) //first operation, open operationslist
open_operationslist ( ) ;
2011-01-19 15:32:56 -07:00
//FIXME: A slight flicker may be introduced by this extra display refresh.
//An extra display refresh seems to prevent the disk area visual disk from
// disappearing when enough operations are added to require a scrollbar
// (about 4 operations with default window size).
// Note that commenting out the code to
// "//make scrollwindow focus on the last operation in the list"
// in HBoxOperations::load_operations() prevents this problem from occurring as well.
// See also Win_GParted::activate_undo().
drawingarea_visualdisk . queue_draw ( ) ;
2006-07-20 13:14:44 -06:00
}
2006-03-24 12:08:41 -07:00
else
2006-07-20 13:14:44 -06:00
{
Gtk : : MessageDialog dialog ( * this ,
_ ( " Could not add this operation to the list. " ) ,
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
dialog . set_secondary_text ( error ) ;
2006-03-24 12:08:41 -07:00
2006-07-20 13:14:44 -06:00
dialog . run ( ) ;
}
2006-03-24 12:08:41 -07:00
}
2004-09-19 14:24:53 -06:00
}
2011-10-13 11:26:16 -06:00
bool Win_GParted : : Merge_Operations ( unsigned int first , unsigned int second )
2011-10-05 12:15:16 -06:00
{
2011-10-13 11:26:16 -06:00
if ( first > = operations . size ( ) | | second > = operations . size ( ) )
return false ;
2011-10-05 12:15:16 -06:00
// Two resize operations of the same partition
if ( operations [ first ] - > type = = OPERATION_RESIZE_MOVE & &
operations [ second ] - > type = = OPERATION_RESIZE_MOVE & &
operations [ first ] - > partition_new = = operations [ second ] - > partition_original
)
{
operations [ first ] - > partition_new = operations [ second ] - > partition_new ;
operations [ first ] - > create_description ( ) ;
remove_operation ( second ) ;
Refresh_Visual ( ) ;
return true ;
}
// Two label change operations on the same partition
else if ( operations [ first ] - > type = = OPERATION_LABEL_PARTITION & &
operations [ second ] - > type = = OPERATION_LABEL_PARTITION & &
operations [ first ] - > partition_new = = operations [ second ] - > partition_original
)
{
operations [ first ] - > partition_new . label = operations [ second ] - > partition_new . label ;
operations [ first ] - > create_description ( ) ;
remove_operation ( second ) ;
Refresh_Visual ( ) ;
return true ;
}
2012-01-22 13:49:52 -07:00
// Two change-uuid change operations on the same partition
else if ( operations [ first ] - > type = = OPERATION_CHANGE_UUID & &
operations [ second ] - > type = = OPERATION_CHANGE_UUID & &
operations [ first ] - > partition_new = = operations [ second ] - > partition_original
)
{
operations [ first ] - > partition_new . uuid = operations [ second ] - > partition_new . uuid ;
operations [ first ] - > create_description ( ) ;
remove_operation ( second ) ;
Refresh_Visual ( ) ;
return true ;
}
2011-10-05 12:15:16 -06:00
// Two check operations of the same partition
else if ( operations [ first ] - > type = = OPERATION_CHECK & &
operations [ second ] - > type = = OPERATION_CHECK & &
operations [ first ] - > partition_original = = operations [ second ] - > partition_original
)
{
remove_operation ( second ) ;
Refresh_Visual ( ) ;
return true ;
}
// Two format operations of the same partition
else if ( operations [ first ] - > type = = OPERATION_FORMAT & &
operations [ second ] - > type = = OPERATION_FORMAT & &
operations [ first ] - > partition_new = = operations [ second ] - > partition_original
2011-10-13 11:26:16 -06:00
)
2011-10-05 12:15:16 -06:00
{
operations [ first ] - > partition_new = operations [ second ] - > partition_new ;
operations [ first ] - > create_description ( ) ;
remove_operation ( second ) ;
Refresh_Visual ( ) ;
return true ;
}
return false ;
}
2006-03-01 14:50:52 -07:00
void Win_GParted : : Refresh_Visual ( )
2004-09-19 14:24:53 -06:00
{
2009-01-06 15:22:09 -07:00
std : : vector < Partition > partitions = devices [ current_device ] . partitions ;
2004-09-19 14:24:53 -06:00
//make all operations visible
2005-12-22 15:20:55 -07:00
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
2006-03-24 12:08:41 -07:00
if ( operations [ t ] - > device = = devices [ current_device ] )
operations [ t ] - > apply_to_visual ( partitions ) ;
2009-01-06 15:22:09 -07:00
2006-09-17 07:23:47 -06:00
hbox_operations . load_operations ( operations ) ;
2004-09-19 14:24:53 -06:00
//set new statusbartext
2005-12-22 15:20:55 -07:00
statusbar . pop ( ) ;
2008-06-10 13:16:26 -06:00
statusbar . push ( String : : ucompose ( ngettext ( " %1 operation pending "
, " %1 operations pending "
, operations . size ( )
)
, operations . size ( )
)
) ;
2009-01-06 15:22:09 -07:00
if ( ! operations . size ( ) )
2006-09-16 05:27:05 -06:00
allow_undo_clear_apply ( false ) ;
2009-01-06 15:22:09 -07:00
2006-02-09 10:02:40 -07:00
//count primary's and check for extended
2006-03-24 12:08:41 -07:00
index_extended = - 1 ;
2004-11-06 04:55:03 -07:00
primary_count = 0 ;
2005-12-22 15:20:55 -07:00
for ( unsigned int t = 0 ; t < partitions . size ( ) ; t + + )
2004-09-19 14:24:53 -06:00
{
2006-03-14 14:37:47 -07:00
if ( partitions [ t ] . get_path ( ) = = copied_partition . get_path ( ) )
2004-09-19 14:24:53 -06:00
copied_partition = partitions [ t ] ;
2009-01-06 15:22:09 -07:00
2004-11-06 04:55:03 -07:00
switch ( partitions [ t ] . type )
2004-09-19 14:24:53 -06:00
{
2005-12-07 04:21:27 -07:00
case GParted : : TYPE_PRIMARY :
primary_count + + ;
break ;
2009-01-06 15:22:09 -07:00
2005-12-07 04:21:27 -07:00
case GParted : : TYPE_EXTENDED :
2006-03-24 12:08:41 -07:00
index_extended = t ;
2005-12-07 04:21:27 -07:00
primary_count + + ;
break ;
2009-01-06 15:22:09 -07:00
2005-12-07 04:21:27 -07:00
default :
break ;
2004-09-19 14:24:53 -06:00
}
}
2009-01-06 15:22:09 -07:00
2006-02-10 16:47:02 -07:00
//frame visualdisk
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . load_partitions ( partitions , devices [ current_device ] . length ) ;
2004-09-19 14:24:53 -06:00
//treeview details
2005-12-23 17:06:05 -07:00
treeview_detail . load_partitions ( partitions ) ;
2009-01-06 15:22:09 -07:00
2005-01-09 12:33:48 -07:00
//no partition can be selected after a refresh..
2005-12-22 15:20:55 -07:00
selected_partition . Reset ( ) ;
2009-01-06 15:22:09 -07:00
set_valid_operations ( ) ;
while ( Gtk : : Main : : events_pending ( ) )
2006-03-01 14:50:52 -07:00
Gtk : : Main : : iteration ( ) ;
2004-09-19 14:24:53 -06:00
}
2006-02-17 14:18:07 -07:00
bool Win_GParted : : Quit_Check_Operations ( )
2004-09-19 14:24:53 -06:00
{
2005-12-22 15:20:55 -07:00
if ( operations . size ( ) )
2004-09-19 14:24:53 -06:00
{
2006-02-08 13:36:18 -07:00
Gtk : : MessageDialog dialog ( * this ,
_ ( " Quit GParted? " ) ,
false ,
Gtk : : MESSAGE_QUESTION ,
Gtk : : BUTTONS_NONE ,
true ) ;
2008-06-10 13:16:26 -06:00
dialog . set_secondary_text ( String : : ucompose ( ngettext ( " %1 operation is currently pending. "
, " %1 operations are currently pending. "
, operations . size ( )
)
, operations . size ( )
)
) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
dialog . add_button ( Gtk : : Stock : : QUIT , Gtk : : RESPONSE_CLOSE ) ;
dialog . add_button ( Gtk : : Stock : : CANCEL , Gtk : : RESPONSE_CANCEL ) ;
2009-01-06 15:22:09 -07:00
2005-12-22 15:20:55 -07:00
if ( dialog . run ( ) = = Gtk : : RESPONSE_CANCEL )
2004-11-23 12:03:39 -07:00
return false ; //don't close GParted
2004-09-19 14:24:53 -06:00
}
return true ; //close GParted
}
2006-02-17 14:18:07 -07:00
void Win_GParted : : set_valid_operations ( )
2004-09-19 14:24:53 -06:00
{
2004-11-06 12:48:24 -07:00
allow_new ( false ) ; allow_delete ( false ) ; allow_resize ( false ) ; allow_copy ( false ) ;
2006-03-09 13:03:12 -07:00
allow_paste ( false ) ; allow_format ( false ) ; allow_toggle_swap_mount_state ( false ) ;
2008-04-07 13:41:18 -06:00
allow_manage_flags ( false ) ; allow_check ( false ) ; allow_label_partition ( false ) ;
2012-01-22 13:49:52 -07:00
allow_change_uuid ( false ) ; allow_info ( false ) ;
2009-01-06 15:22:09 -07:00
2006-08-20 10:51:18 -06:00
dynamic_cast < Gtk : : Label * > ( menu_partition . items ( ) [ MENU_TOGGLE_MOUNT_SWAP ] . get_child ( ) )
2006-08-28 14:11:58 -06:00
- > set_label ( _ ( " _Unmount " ) ) ;
2006-08-20 10:51:18 -06:00
menu_partition . items ( ) [ MENU_TOGGLE_MOUNT_SWAP ] . show ( ) ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) [ MENU_MOUNT ] . hide ( ) ;
2006-03-16 10:09:17 -07:00
2009-01-06 15:22:09 -07:00
//no partition selected...
2006-03-14 14:37:47 -07:00
if ( ! selected_partition . get_paths ( ) . size ( ) )
2005-01-09 12:33:48 -07:00
return ;
2009-01-06 15:22:09 -07:00
2005-01-09 12:33:48 -07:00
//if there's something, there's some info ;)
2006-02-08 13:36:18 -07:00
allow_info ( true ) ;
2009-01-06 15:22:09 -07:00
2006-03-31 03:49:27 -07:00
//flag managing..
if ( selected_partition . type ! = GParted : : TYPE_UNALLOCATED & & selected_partition . status = = GParted : : STAT_REAL )
2009-01-06 15:22:09 -07:00
allow_manage_flags ( true ) ;
2006-02-08 13:36:18 -07:00
//deal with swap...
if ( selected_partition . filesystem = = GParted : : FS_LINUX_SWAP )
{
2006-03-09 13:03:12 -07:00
if ( selected_partition . status = = GParted : : STAT_REAL )
allow_toggle_swap_mount_state ( true ) ;
2006-02-08 13:36:18 -07:00
if ( selected_partition . busy )
2006-03-09 12:37:50 -07:00
{
2009-01-06 15:22:09 -07:00
dynamic_cast < Gtk : : Label * > ( menu_partition . items ( ) [ MENU_TOGGLE_MOUNT_SWAP ] . get_child ( ) )
2006-08-28 14:11:58 -06:00
- > set_label ( _ ( " _Swapoff " ) ) ;
2006-03-09 12:37:50 -07:00
2006-02-08 13:36:18 -07:00
return ;
2006-03-09 12:37:50 -07:00
}
2006-02-08 13:36:18 -07:00
else
2009-01-06 15:22:09 -07:00
dynamic_cast < Gtk : : Label * > ( menu_partition . items ( ) [ MENU_TOGGLE_MOUNT_SWAP ] . get_child ( ) )
2006-08-28 14:11:58 -06:00
- > set_label ( _ ( " _Swapon " ) ) ;
2006-02-08 13:36:18 -07:00
}
2006-03-31 03:49:27 -07:00
2006-03-09 12:37:50 -07:00
//only unmount is allowed (if ! extended)
2009-01-06 15:22:09 -07:00
if ( selected_partition . busy )
2004-11-06 12:48:24 -07:00
{
2012-01-05 15:57:27 -07:00
if ( selected_partition . type ! = GParted : : TYPE_EXTENDED & &
selected_partition . filesystem ! = GParted : : FS_LVM2_PV )
2006-03-09 12:37:50 -07:00
allow_toggle_swap_mount_state ( true ) ;
2006-02-08 13:36:18 -07:00
return ;
2004-11-06 12:48:24 -07:00
}
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//UNALLOCATED
2005-12-07 04:21:27 -07:00
if ( selected_partition . type = = GParted : : TYPE_UNALLOCATED )
2004-09-19 14:24:53 -06:00
{
allow_new ( true ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//find out if there is a copied partition and if it fits inside this unallocated space
2006-03-14 14:37:47 -07:00
if ( ! copied_partition . get_path ( ) . empty ( ) & & ! devices [ current_device ] . readonly )
2004-11-25 12:21:42 -07:00
{
2010-04-27 11:41:43 -06:00
Byte_Value required_size ;
2006-02-25 03:09:30 -07:00
if ( copied_partition . filesystem = = GParted : : FS_XFS )
2010-04-27 11:41:43 -06:00
required_size = copied_partition . sectors_used * copied_partition . sector_size ;
2006-02-25 03:09:30 -07:00
else
2010-04-27 11:41:43 -06:00
required_size = copied_partition . get_byte_length ( ) ;
2006-02-25 03:09:30 -07:00
2010-05-20 10:00:14 -06:00
//Determine if space is needed for the Master Boot Record or
// the Extended Boot Record. Generally an an additional track or MEBIBYTE
// is required so for our purposes reserve a MEBIBYTE in front of the partition.
// NOTE: This logic also contained in Dialog_Base_Partition::MB_Needed_for_Boot_Record
if ( ( selected_partition . inside_extended
& & selected_partition . type = = TYPE_UNALLOCATED
)
| | ( selected_partition . type = = TYPE_LOGICAL )
/* Beginning of disk device */
| | ( selected_partition . sector_start < = ( MEBIBYTE / selected_partition . sector_size ) )
)
required_size + = MEBIBYTE ;
//Determine if space is needed for the Extended Boot Record for a logical partition
// after this partition. Generally an an additional track or MEBIBYTE
// is required so for our purposes reserve a MEBIBYTE in front of the partition.
if ( ( ( selected_partition . inside_extended
& & selected_partition . type = = TYPE_UNALLOCATED
)
| | ( selected_partition . type = = TYPE_LOGICAL )
)
& & ( selected_partition . sector_end
< ( devices [ current_device ] . length
- ( 2 * MEBIBYTE / devices [ current_device ] . sector_size )
)
)
2009-01-24 10:16:57 -07:00
)
2010-05-20 10:00:14 -06:00
required_size + = MEBIBYTE ;
2009-01-24 10:16:57 -07:00
2010-05-20 15:12:14 -06:00
//Determine if space is needed for the backup partition on a GPT partition table
if ( ( devices [ current_device ] . disktype = = " gpt " )
& & ( ( devices [ current_device ] . length - selected_partition . sector_end )
< ( MEBIBYTE / devices [ current_device ] . sector_size )
)
)
required_size + = MEBIBYTE ;
2010-04-27 11:41:43 -06:00
if ( required_size < = selected_partition . get_byte_length ( ) )
2004-11-25 12:21:42 -07:00
allow_paste ( true ) ;
2009-01-24 10:16:57 -07:00
}
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
return ;
}
2009-01-06 15:22:09 -07:00
2004-12-14 15:49:44 -07:00
//EXTENDED
2005-12-07 04:21:27 -07:00
if ( selected_partition . type = = GParted : : TYPE_EXTENDED )
2004-12-14 15:49:44 -07:00
{
2006-02-09 10:02:40 -07:00
//deletion is only allowed when there are no logical partitions inside.
if ( selected_partition . logicals . size ( ) = = 1 & &
2009-01-06 15:22:09 -07:00
selected_partition . logicals . back ( ) . type = = GParted : : TYPE_UNALLOCATED )
2004-12-14 15:49:44 -07:00
allow_delete ( true ) ;
2009-01-06 15:22:09 -07:00
2004-12-14 15:49:44 -07:00
if ( ! devices [ current_device ] . readonly )
2009-01-06 15:22:09 -07:00
allow_resize ( true ) ;
2006-03-31 03:49:27 -07:00
2004-12-14 15:49:44 -07:00
return ;
2009-01-06 15:22:09 -07:00
}
2004-09-19 14:24:53 -06:00
//PRIMARY and LOGICAL
2005-12-07 04:21:27 -07:00
if ( selected_partition . type = = GParted : : TYPE_PRIMARY | | selected_partition . type = = GParted : : TYPE_LOGICAL )
2004-09-19 14:24:53 -06:00
{
2004-12-25 14:40:18 -07:00
fs = gparted_core . get_fs ( selected_partition . filesystem ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
allow_delete ( true ) ;
2006-01-02 08:18:29 -07:00
allow_format ( true ) ;
2009-01-06 15:22:09 -07:00
2004-12-17 09:26:49 -07:00
//find out if resizing/moving is possible
2009-01-06 15:22:09 -07:00
if ( ( fs . grow | | fs . shrink | | fs . move ) & & ! devices [ current_device ] . readonly )
2004-09-19 14:24:53 -06:00
allow_resize ( true ) ;
2009-01-06 15:22:09 -07:00
2004-12-17 09:26:49 -07:00
//only allow copying of real partitions
2005-11-28 10:04:13 -07:00
if ( selected_partition . status = = GParted : : STAT_REAL & & fs . copy )
2008-04-07 13:41:18 -06:00
allow_copy ( true ) ;
2009-01-06 15:22:09 -07:00
2008-04-07 13:41:18 -06:00
//only allow labelling of real partitions that support labelling
2008-11-08 16:55:17 -07:00
if ( selected_partition . status = = GParted : : STAT_REAL & & fs . write_label )
2008-04-07 13:41:18 -06:00
allow_label_partition ( true ) ;
2012-01-22 13:49:52 -07:00
//only allow changing UUID of real partitions that support it
if ( selected_partition . status = = GParted : : STAT_REAL & & fs . write_uuid )
allow_change_uuid ( true ) ;
2011-12-16 14:32:54 -07:00
//Generate Mount on submenu, except for LVM2 PVs
// borrowing mount point to display the VGNAME
if ( selected_partition . filesystem ! = GParted : : FS_LVM2_PV
& & selected_partition . get_mountpoints ( ) . size ( )
)
2006-03-09 12:37:50 -07:00
{
allow_toggle_swap_mount_state ( true ) ;
2009-01-06 15:22:09 -07:00
2006-08-20 10:51:18 -06:00
menu = menu_partition . items ( ) [ MENU_MOUNT ] . get_submenu ( ) ;
2006-03-16 10:09:17 -07:00
menu - > items ( ) . clear ( ) ;
for ( unsigned int t = 0 ; t < selected_partition . get_mountpoints ( ) . size ( ) ; t + + )
2006-03-17 03:07:49 -07:00
{
2009-01-06 15:22:09 -07:00
menu - > items ( ) . push_back (
Gtk : : Menu_Helpers : : MenuElem (
selected_partition . get_mountpoints ( ) [ t ] ,
2006-03-16 10:09:17 -07:00
sigc : : bind < unsigned int > ( sigc : : mem_fun ( * this , & Win_GParted : : activate_mount_partition ) , t ) ) ) ;
2006-03-09 12:37:50 -07:00
2006-03-17 03:07:49 -07:00
dynamic_cast < Gtk : : Label * > ( menu - > items ( ) . back ( ) . get_child ( ) ) - > set_use_underline ( false ) ;
}
2009-01-06 15:22:09 -07:00
2006-08-20 10:51:18 -06:00
menu_partition . items ( ) [ MENU_TOGGLE_MOUNT_SWAP ] . hide ( ) ;
2009-01-06 15:22:09 -07:00
menu_partition . items ( ) [ MENU_MOUNT ] . show ( ) ;
2006-03-09 12:37:50 -07:00
}
2006-03-29 12:21:42 -07:00
//see if there is an copied partition and if it passes all tests
if ( ! copied_partition . get_path ( ) . empty ( ) & &
2010-04-27 11:41:43 -06:00
copied_partition . get_byte_length ( ) < = selected_partition . get_byte_length ( ) & &
2006-03-29 12:21:42 -07:00
selected_partition . status = = GParted : : STAT_REAL & &
2009-11-25 12:36:43 -07:00
copied_partition ! = selected_partition )
2006-03-29 12:21:42 -07:00
allow_paste ( true ) ;
2006-11-26 07:27:16 -07:00
2008-11-18 16:58:17 -07:00
//see if we can somehow check/repair this file system....
2006-11-26 07:27:16 -07:00
if ( fs . check & & selected_partition . status = = GParted : : STAT_REAL )
allow_check ( true ) ;
2004-09-19 14:24:53 -06:00
}
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : open_operationslist ( )
2004-10-11 08:19:56 -06:00
{
2006-02-22 15:05:15 -07:00
if ( ! OPERATIONSLIST_OPEN )
2004-10-11 08:19:56 -06:00
{
2006-02-22 15:05:15 -07:00
OPERATIONSLIST_OPEN = true ;
hbox_operations . show ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
for ( int t = vpaned_main . get_height ( ) ; t > ( vpaned_main . get_height ( ) - 100 ) ; t - = 5 )
{
vpaned_main . set_position ( t ) ;
2009-01-06 15:22:09 -07:00
while ( Gtk : : Main : : events_pending ( ) )
2006-02-22 15:05:15 -07:00
Gtk : : Main : : iteration ( ) ;
}
2005-11-27 12:48:00 -07:00
2006-02-22 15:05:15 -07:00
static_cast < Gtk : : CheckMenuItem * > ( & menubar_main . items ( ) [ 2 ] . get_submenu ( ) - > items ( ) [ 1 ] )
- > set_active ( true ) ;
}
2004-10-11 08:19:56 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : close_operationslist ( )
2004-09-19 14:24:53 -06:00
{
2006-02-22 15:05:15 -07:00
if ( OPERATIONSLIST_OPEN )
2004-09-19 14:24:53 -06:00
{
2006-02-22 15:05:15 -07:00
OPERATIONSLIST_OPEN = false ;
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
for ( int t = vpaned_main . get_position ( ) ; t < vpaned_main . get_height ( ) ; t + = 5 )
{
vpaned_main . set_position ( t ) ;
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
while ( Gtk : : Main : : events_pending ( ) )
Gtk : : Main : : iteration ( ) ;
}
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
hbox_operations . hide ( ) ;
static_cast < Gtk : : CheckMenuItem * > ( & menubar_main . items ( ) [ 2 ] . get_submenu ( ) - > items ( ) [ 1 ] )
- > set_active ( false ) ;
2004-09-19 14:24:53 -06:00
}
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : clear_operationslist ( )
2004-09-19 14:24:53 -06:00
{
2006-03-24 12:08:41 -07:00
remove_operation ( - 1 , true ) ;
2006-09-16 05:27:05 -06:00
close_operationslist ( ) ;
2006-03-24 12:08:41 -07:00
2006-02-02 03:59:44 -07:00
Refresh_Visual ( ) ;
2004-09-19 14:24:53 -06:00
}
2006-02-02 03:59:44 -07:00
void Win_GParted : : combo_devices_changed ( )
{
2008-04-07 09:26:19 -06:00
unsigned int old_current_device = current_device ;
2004-09-19 14:24:53 -06:00
//set new current device
2005-12-29 16:35:37 -07:00
current_device = combo_devices . get_active_row_number ( ) ;
2008-04-07 09:26:19 -06:00
if ( current_device = = ( unsigned int ) - 1 )
current_device = old_current_device ;
if ( current_device > = devices . size ( ) )
current_device = 0 ;
2006-03-14 14:37:47 -07:00
set_title ( String : : ucompose ( _ ( " %1 - GParted " ) , devices [ current_device ] . get_path ( ) ) ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//refresh label_device_info
2006-02-02 03:59:44 -07:00
Fill_Label_Device_Info ( ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//rebuild visualdisk and treeview
2006-02-02 03:59:44 -07:00
Refresh_Visual ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-02 03:59:44 -07:00
//uodate radiobuttons..
if ( menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . get_submenu ( ) )
2009-01-06 15:22:09 -07:00
static_cast < Gtk : : RadioMenuItem * > (
2006-02-02 03:59:44 -07:00
& menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . get_submenu ( ) - >
items ( ) [ current_device ] ) - > set_active ( true ) ;
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : radio_devices_changed ( unsigned int item )
2006-02-02 03:59:44 -07:00
{
2009-01-06 15:22:09 -07:00
if ( static_cast < Gtk : : RadioMenuItem * > (
2006-02-02 03:59:44 -07:00
& menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . get_submenu ( ) - >
items ( ) [ item ] ) - > get_active ( ) )
{
combo_devices . set_active ( item ) ;
}
2004-09-19 14:24:53 -06:00
}
2006-04-02 08:04:44 -06:00
void Win_GParted : : on_show ( )
{
Gtk : : Window : : on_show ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-22 15:05:15 -07:00
vpaned_main . set_position ( vpaned_main . get_height ( ) ) ;
close_operationslist ( ) ;
menu_gparted_refresh_devices ( ) ;
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : thread_refresh_devices ( )
2006-01-08 08:20:14 -07:00
{
2006-06-18 02:50:17 -06:00
gparted_core . set_devices ( devices ) ;
2006-01-08 08:20:14 -07:00
pulse = false ;
}
2006-03-15 14:44:24 -07:00
void Win_GParted : : menu_gparted_refresh_devices ( )
2004-09-19 14:24:53 -06:00
{
2009-01-06 15:22:09 -07:00
pulse = true ;
2006-01-08 08:20:14 -07:00
thread = Glib : : Thread : : create ( sigc : : mem_fun ( * this , & Win_GParted : : thread_refresh_devices ) , true ) ;
show_pulsebar ( _ ( " Scanning all devices... " ) ) ;
2009-01-06 15:22:09 -07:00
2006-01-08 08:20:14 -07:00
//check if current_device is still available (think about hotpluggable stuff like usbdevices)
2005-12-22 15:20:55 -07:00
if ( current_device > = devices . size ( ) )
2004-12-03 03:53:01 -07:00
current_device = 0 ;
2005-12-22 15:20:55 -07:00
2005-02-01 10:04:03 -07:00
//see if there are any pending operations on non-existent devices
//NOTE that this isn't 100% foolproof since some stuff (e.g. sourcedevice of copy) may slip through.
//but anyone who removes the sourcedevice before applying the operations gets what he/she deserves :-)
2006-03-15 14:44:24 -07:00
//FIXME: this actually sucks ;) see if we can use STL predicates here..
2005-02-01 10:04:03 -07:00
unsigned int i ;
2006-02-17 14:18:07 -07:00
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
2006-03-15 14:44:24 -07:00
{
2006-03-24 12:08:41 -07:00
for ( i = 0 ; i < devices . size ( ) & & devices [ i ] ! = operations [ t ] - > device ; i + + ) { }
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
if ( i > = devices . size ( ) )
2006-03-24 12:08:41 -07:00
remove_operation ( t - - ) ;
2005-02-01 10:04:03 -07:00
}
2009-01-06 15:22:09 -07:00
2005-02-01 10:04:03 -07:00
//if no devices were detected we disable some stuff and show a message in the statusbar
2005-12-22 15:20:55 -07:00
if ( devices . empty ( ) )
2006-02-15 09:05:26 -07:00
{
2006-01-24 05:31:58 -07:00
this - > set_title ( _ ( " GParted " ) ) ;
2005-12-29 16:35:37 -07:00
combo_devices . hide ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-02 06:50:37 -07:00
menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . set_sensitive ( false ) ;
2005-12-22 15:20:55 -07:00
menubar_main . items ( ) [ 1 ] . set_sensitive ( false ) ;
menubar_main . items ( ) [ 2 ] . set_sensitive ( false ) ;
menubar_main . items ( ) [ 3 ] . set_sensitive ( false ) ;
menubar_main . items ( ) [ 4 ] . set_sensitive ( false ) ;
2005-02-01 10:04:03 -07:00
toolbar_main . set_sensitive ( false ) ;
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . set_sensitive ( false ) ;
2005-12-29 16:35:37 -07:00
treeview_detail . set_sensitive ( false ) ;
2005-02-01 10:04:03 -07:00
Fill_Label_Device_Info ( true ) ;
2009-01-06 15:22:09 -07:00
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . clear ( ) ;
2005-12-23 17:06:05 -07:00
treeview_detail . clear ( ) ;
2009-01-06 15:22:09 -07:00
2005-02-01 10:04:03 -07:00
//hmzz, this is really paranoid, but i think it's the right thing to do ;)
2006-09-17 07:23:47 -06:00
hbox_operations . clear ( ) ;
2005-12-22 15:20:55 -07:00
close_operationslist ( ) ;
2006-03-24 12:08:41 -07:00
remove_operation ( - 1 , true ) ;
2009-01-06 15:22:09 -07:00
2005-12-22 15:20:55 -07:00
statusbar . pop ( ) ;
2005-02-01 10:04:03 -07:00
statusbar . push ( _ ( " No devices detected " ) ) ;
}
else //at least one device detected
{
2005-12-29 16:35:37 -07:00
combo_devices . show ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-02 06:50:37 -07:00
menubar_main . items ( ) [ 0 ] . get_submenu ( ) - > items ( ) [ 1 ] . set_sensitive ( true ) ;
2005-12-29 16:35:37 -07:00
menubar_main . items ( ) [ 1 ] . set_sensitive ( true ) ;
menubar_main . items ( ) [ 2 ] . set_sensitive ( true ) ;
menubar_main . items ( ) [ 3 ] . set_sensitive ( true ) ;
menubar_main . items ( ) [ 4 ] . set_sensitive ( true ) ;
toolbar_main . set_sensitive ( true ) ;
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . set_sensitive ( true ) ;
2005-12-29 16:35:37 -07:00
treeview_detail . set_sensitive ( true ) ;
2009-01-06 15:22:09 -07:00
refresh_combo_devices ( ) ;
2005-02-01 10:04:03 -07:00
}
2004-09-19 14:24:53 -06:00
}
2006-04-05 03:33:04 -06:00
void Win_GParted : : menu_gparted_features ( )
2004-12-15 09:38:37 -07:00
{
2006-04-05 03:33:04 -06:00
DialogFeatures dialog ;
2004-12-15 09:38:37 -07:00
dialog . set_transient_for ( * this ) ;
2009-01-06 15:22:09 -07:00
2006-04-05 03:33:04 -06:00
dialog . load_filesystems ( gparted_core . get_filesystems ( ) ) ;
2006-01-02 08:18:29 -07:00
while ( dialog . run ( ) = = Gtk : : RESPONSE_OK )
2004-12-15 09:38:37 -07:00
{
2006-01-02 08:18:29 -07:00
gparted_core . find_supported_filesystems ( ) ;
2006-04-05 03:33:04 -06:00
dialog . load_filesystems ( gparted_core . get_filesystems ( ) ) ;
2006-01-02 08:18:29 -07:00
//recreate format menu...
2006-08-20 10:51:18 -06:00
menu_partition . items ( ) [ MENU_FORMAT ] . remove_submenu ( ) ;
menu_partition . items ( ) [ MENU_FORMAT ] . set_submenu ( * create_format_menu ( ) ) ;
2006-08-28 14:11:58 -06:00
menu_partition . items ( ) [ MENU_FORMAT ] . get_submenu ( ) - > show_all_children ( ) ;
2004-12-15 09:38:37 -07:00
}
}
2006-02-17 14:18:07 -07:00
void Win_GParted : : menu_gparted_quit ( )
2004-09-19 14:24:53 -06:00
{
2006-02-17 14:18:07 -07:00
if ( Quit_Check_Operations ( ) )
this - > hide ( ) ;
2004-09-19 14:24:53 -06:00
}
2006-03-16 10:09:17 -07:00
void Win_GParted : : menu_view_harddisk_info ( )
2009-01-06 15:22:09 -07:00
{
2006-02-17 14:18:07 -07:00
if ( static_cast < Gtk : : CheckMenuItem * > ( & menubar_main . items ( ) [ 2 ] . get_submenu ( ) - > items ( ) [ 0 ] ) - > get_active ( ) )
{ //open harddisk information
2009-01-06 15:22:09 -07:00
hpaned_main . get_child1 ( ) - > show ( ) ;
2006-02-17 14:18:07 -07:00
for ( int t = hpaned_main . get_position ( ) ; t < 250 ; t + = 15 )
2004-09-27 14:12:47 -06:00
{
2004-11-23 12:03:39 -07:00
hpaned_main . set_position ( t ) ;
2006-02-17 14:18:07 -07:00
while ( Gtk : : Main : : events_pending ( ) )
Gtk : : Main : : iteration ( ) ;
2004-09-27 14:12:47 -06:00
}
}
2009-01-06 15:22:09 -07:00
else
2004-09-27 14:12:47 -06:00
{ //close harddisk information
2006-02-17 14:18:07 -07:00
for ( int t = hpaned_main . get_position ( ) ; t > 0 ; t - = 15 )
2004-09-27 14:12:47 -06:00
{
2004-11-23 12:03:39 -07:00
hpaned_main . set_position ( t ) ;
2006-02-17 14:18:07 -07:00
while ( Gtk : : Main : : events_pending ( ) )
Gtk : : Main : : iteration ( ) ;
2004-09-27 14:12:47 -06:00
}
2006-02-17 14:18:07 -07:00
hpaned_main . get_child1 ( ) - > hide ( ) ;
2004-09-27 14:12:47 -06:00
}
}
2006-02-17 14:18:07 -07:00
void Win_GParted : : menu_view_operations ( )
2004-10-11 08:19:56 -06:00
{
2006-02-17 14:18:07 -07:00
if ( static_cast < Gtk : : CheckMenuItem * > ( & menubar_main . items ( ) [ 2 ] . get_submenu ( ) - > items ( ) [ 1 ] ) - > get_active ( ) )
open_operationslist ( ) ;
2009-01-06 15:22:09 -07:00
else
2006-02-17 14:18:07 -07:00
close_operationslist ( ) ;
2004-10-11 08:19:56 -06:00
}
2009-10-24 14:16:40 -06:00
void Win_GParted : : show_disklabel_unrecognized ( Glib : : ustring device_name )
{
//Display dialog box indicating that no partition table was found on the device
Gtk : : MessageDialog dialog ( * this ,
/*TO TRANSLATORS: looks like No partition table found on device /dev/sda */
String : : ucompose ( _ ( " No partition table found on device %1 " ) , device_name ) ,
false ,
Gtk : : MESSAGE_INFO ,
Gtk : : BUTTONS_OK ,
true ) ;
Glib : : ustring tmp_msg = _ ( " A partition table is required before partitions can be added. " ) ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " To create a new partition table choose the menu item: " ) ;
tmp_msg + = " \n " ;
/*TO TRANSLATORS: this message represents the menu item Create Partition Table under the Device menu. */
tmp_msg + = _ ( " Device --> Create Partition Table. " ) ;
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
}
2009-11-03 10:27:35 -07:00
void Win_GParted : : show_help_dialog ( const Glib : : ustring & filename /* E.g., gparted */
, const Glib : : ustring & link_id /* For context sensitive help */
)
2004-09-19 14:24:53 -06:00
{
2009-11-03 10:27:35 -07:00
GError * error = NULL ;
GdkScreen * gscreen = NULL ;
2006-02-17 14:18:07 -07:00
2009-11-03 10:27:35 -07:00
Glib : : ustring uri = " ghelp: " + filename ;
if ( link_id . size ( ) > 0 ) {
uri = uri + " ? " + link_id ;
2008-08-05 09:34:10 -06:00
}
2006-02-17 14:18:07 -07:00
2009-11-03 10:27:35 -07:00
gscreen = gdk_screen_get_default ( ) ;
# ifdef HAVE_GTK_SHOW_URI
gtk_show_uri ( gscreen , uri . c_str ( ) , gtk_get_current_event_time ( ) , & error ) ;
# else
Glib : : ustring command = " gnome-open " + uri ;
gdk_spawn_command_line_on_screen ( gscreen , command . c_str ( ) , & error ) ;
# endif
2011-01-17 09:26:28 -07:00
if ( error ! = NULL )
{
//Try opening yelp application directly
g_clear_error ( & error ) ; //Clear error from trying to open gparted help manual above (gtk_show_uri or gnome-open).
Glib : : ustring command = " yelp " + uri ;
gdk_spawn_command_line_on_screen ( gscreen , command . c_str ( ) , & error ) ;
}
2009-11-03 10:27:35 -07:00
if ( error ! = NULL )
{
Gtk : : MessageDialog dialog ( * this
, _ ( " Unable to open GParted Manual help file. " )
, false
, Gtk : : MESSAGE_ERROR
, Gtk : : BUTTONS_OK
, true
) ;
dialog . set_secondary_text ( error - > message ) ;
dialog . run ( ) ;
}
2004-09-19 14:24:53 -06:00
}
2008-08-05 09:34:10 -06:00
void Win_GParted : : menu_help_contents ( )
{
2009-11-03 10:57:15 -07:00
# ifdef HAVE_DISABLE_DOC
2009-10-17 15:43:20 -06:00
//GParted was configured with --disable-doc
Gtk : : MessageDialog dialog ( * this ,
_ ( " Documentation is not available. " ) ,
false ,
Gtk : : MESSAGE_INFO ,
Gtk : : BUTTONS_OK ,
true ) ;
Glib : : ustring tmp_msg = _ ( " This build of gparted is configured without documentation. " ) ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " Documentation is available at the project web site. " ) ;
tmp_msg + = " \n " ;
2010-10-12 11:35:26 -06:00
tmp_msg + = " http://gparted.org " ;
2009-10-17 15:43:20 -06:00
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
# else
//GParted was configured without --disable-doc
2009-11-03 10:27:35 -07:00
show_help_dialog ( " gparted " , " " ) ;
2009-10-17 15:43:20 -06:00
# endif
2008-08-05 09:34:10 -06:00
}
2004-09-19 14:24:53 -06:00
2006-02-17 14:18:07 -07:00
void Win_GParted : : menu_help_about ( )
2004-09-19 14:24:53 -06:00
{
2005-11-25 15:41:49 -07:00
std : : vector < Glib : : ustring > strings ;
2009-01-06 15:22:09 -07:00
2005-11-25 15:41:49 -07:00
Gtk : : AboutDialog dialog ;
2004-09-19 14:24:53 -06:00
dialog . set_transient_for ( * this ) ;
2009-01-06 15:22:09 -07:00
2005-11-25 15:41:49 -07:00
dialog . set_name ( _ ( " GParted " ) ) ;
2008-09-22 16:41:49 -06:00
dialog . set_logo_icon_name ( " gparted " ) ;
2005-11-25 15:41:49 -07:00
dialog . set_version ( VERSION ) ;
2006-01-26 05:50:46 -07:00
dialog . set_comments ( _ ( " GNOME Partition Editor " ) ) ;
2012-01-25 16:55:51 -07:00
dialog . set_copyright ( " Copyright © 2004-2006 Bart Hakvoort \n Copyright © 2008-2012 Curtis Gedak " ) ;
2005-11-25 15:41:49 -07:00
//authors
strings . push_back ( " Bart Hakvoort <gparted@users.sf.net> " ) ;
2008-04-07 13:41:18 -06:00
strings . push_back ( " Curtis Gedak <gedakc@users.sf.net> " ) ;
2005-11-25 15:41:49 -07:00
dialog . set_authors ( strings ) ;
2006-02-17 14:18:07 -07:00
strings . clear ( ) ;
2005-11-25 15:41:49 -07:00
//artists
2010-10-12 11:35:26 -06:00
strings . push_back ( " http://gparted.org/artwork.php " ) ;
2005-11-25 15:41:49 -07:00
dialog . set_artists ( strings ) ;
2006-02-17 14:18:07 -07:00
strings . clear ( ) ;
2005-11-25 15:41:49 -07:00
/*TO TRANSLATORS: your name(s) here please, if there are more translators put newlines (\n) between the names.
2008-11-04 15:16:06 -07:00
It ' s a good idea to provide the url of your translation team as well . Thanks ! */
2005-11-25 15:41:49 -07:00
Glib : : ustring str_credits = _ ( " translator-credits " ) ;
if ( str_credits ! = " translator-credits " )
dialog . set_translator_credits ( str_credits ) ;
2009-01-06 15:22:09 -07:00
//the url is not clickable because this would introduce an new dep (gnome-vfsmm)
2010-10-12 11:35:26 -06:00
dialog . set_website ( " http://gparted.org " ) ;
2005-11-25 15:41:49 -07:00
2006-02-17 14:18:07 -07:00
dialog . run ( ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : on_partition_selected ( const Partition & partition , bool src_is_treeview )
2004-09-19 14:24:53 -06:00
{
selected_partition = partition ;
2006-02-09 10:02:40 -07:00
2006-02-08 13:36:18 -07:00
set_valid_operations ( ) ;
2009-01-06 15:22:09 -07:00
2005-12-23 17:06:05 -07:00
if ( src_is_treeview )
2006-03-09 06:12:44 -07:00
drawingarea_visualdisk . set_selected ( partition ) ;
2005-12-23 17:06:05 -07:00
else
treeview_detail . set_selected ( partition ) ;
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : on_partition_activated ( )
2005-12-23 17:06:05 -07:00
{
2006-01-08 08:20:14 -07:00
activate_info ( ) ;
2005-12-23 17:06:05 -07:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : on_partition_popup_menu ( unsigned int button , unsigned int time )
2005-12-23 17:06:05 -07:00
{
menu_partition . popup ( button , time ) ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
bool Win_GParted : : max_amount_prim_reached ( )
2004-11-06 04:55:03 -07:00
{
2006-11-26 16:24:39 -07:00
//FIXME: this is the only place where primary_count is used... instead of counting the primaries on each
//refresh, we could just count them here.
2009-01-06 15:22:09 -07:00
//Display error if user tries to create more primary partitions than the partition table can hold.
2004-11-17 06:00:25 -07:00
if ( ! selected_partition . inside_extended & & primary_count > = devices [ current_device ] . max_prims )
2006-03-06 04:56:59 -07:00
{
2009-01-06 15:22:09 -07:00
Gtk : : MessageDialog dialog (
2006-02-17 14:18:07 -07:00
* this ,
2010-10-13 08:54:08 -06:00
String : : ucompose ( ngettext ( " It is not possible to create more than %1 primary partition "
, " It is not possible to create more than %1 primary partitions "
, devices [ current_device ] . max_prims
)
, devices [ current_device ] . max_prims
) ,
2006-02-17 14:18:07 -07:00
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
dialog . set_secondary_text (
2006-03-06 04:56:59 -07:00
_ ( " If you want more partitions you should first create an extended partition. Such a partition can contain other partitions. Because an extended partition is also a primary partition it might be necessary to remove a primary partition first. " ) ) ;
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
dialog . run ( ) ;
2009-01-06 15:22:09 -07:00
2004-11-06 04:55:03 -07:00
return true ;
}
2009-01-06 15:22:09 -07:00
2004-11-06 04:55:03 -07:00
return false ;
}
2004-09-19 14:24:53 -06:00
2006-02-17 14:18:07 -07:00
void Win_GParted : : activate_resize ( )
2004-09-19 14:24:53 -06:00
{
2006-03-01 12:16:13 -07:00
std : : vector < Partition > partitions = devices [ current_device ] . partitions ;
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
if ( operations . size ( ) )
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
2006-03-24 12:08:41 -07:00
if ( operations [ t ] - > device = = devices [ current_device ] )
operations [ t ] - > apply_to_visual ( partitions ) ;
2009-01-06 15:22:09 -07:00
Dialog_Partition_Resize_Move dialog ( gparted_core . get_fs ( selected_partition . filesystem ) ,
2006-02-25 03:09:30 -07:00
devices [ current_device ] . cylsize ) ;
2009-01-06 15:22:09 -07:00
2005-12-07 04:21:27 -07:00
if ( selected_partition . type = = GParted : : TYPE_LOGICAL )
2004-11-06 04:55:03 -07:00
{
unsigned int ext = 0 ;
2006-03-24 12:08:41 -07:00
while ( ext < partitions . size ( ) & & partitions [ ext ] . type ! = GParted : : TYPE_EXTENDED ) ext + + ;
2004-11-06 04:55:03 -07:00
dialog . Set_Data ( selected_partition , partitions [ ext ] . logicals ) ;
}
else
dialog . Set_Data ( selected_partition , partitions ) ;
2009-01-06 15:22:09 -07:00
dialog . set_transient_for ( * this ) ;
2006-03-07 04:55:27 -07:00
if ( dialog . run ( ) = = Gtk : : RESPONSE_OK )
2004-09-19 14:24:53 -06:00
{
2006-03-07 04:55:27 -07:00
dialog . hide ( ) ;
2009-01-06 15:22:09 -07:00
//if selected_partition is NEW we simply remove the NEW operation from the list and add
2006-03-07 04:55:27 -07:00
//it again with the new size and position ( unless it's an EXTENDED )
if ( selected_partition . status = = GParted : : STAT_NEW & & selected_partition . type ! = GParted : : TYPE_EXTENDED )
2004-09-19 14:24:53 -06:00
{
//remove operation which creates this partition
2006-03-07 04:55:27 -07:00
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
2004-09-19 14:24:53 -06:00
{
2006-03-24 12:08:41 -07:00
if ( operations [ t ] - > partition_new = = selected_partition )
2004-09-19 14:24:53 -06:00
{
2006-03-24 12:08:41 -07:00
remove_operation ( t ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//And add the new partition to the end of the operations list
2009-01-06 15:22:09 -07:00
//change 'selected_partition' into a suitable 'partition_original')
2006-03-24 12:08:41 -07:00
selected_partition . Set_Unallocated ( devices [ current_device ] . get_path ( ) ,
selected_partition . sector_start ,
selected_partition . sector_end ,
2010-04-19 19:22:31 -06:00
devices [ current_device ] . sector_size ,
2006-03-24 12:08:41 -07:00
selected_partition . inside_extended ) ;
2006-08-01 14:19:17 -06:00
Operation * operation = new OperationCreate ( devices [ current_device ] ,
2010-04-19 19:22:31 -06:00
selected_partition ,
dialog . Get_New_Partition ( devices [ current_device ] . sector_size ) ) ;
2006-08-01 14:19:17 -06:00
operation - > icon = render_icon ( Gtk : : Stock : : NEW , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2004-09-19 14:24:53 -06:00
break ;
}
}
}
else //normal move/resize on existing partition
2006-08-01 14:19:17 -06:00
{
Operation * operation = new OperationResizeMove ( devices [ current_device ] ,
2010-04-19 19:22:31 -06:00
selected_partition ,
dialog . Get_New_Partition ( devices [ current_device ] . sector_size ) ) ;
2006-08-01 14:19:17 -06:00
operation - > icon = render_icon ( Gtk : : Stock : : GOTO_LAST , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2010-09-01 13:54:00 -06:00
//Display notification if move operation has been queued
2012-01-24 11:20:43 -07:00
if ( operation - > partition_original . sector_start ! = operation - > partition_new . sector_start
& & operation - > partition_original . type ! = TYPE_EXTENDED
)
2010-09-01 13:54:00 -06:00
{
//Warn that move operation might break boot process
Gtk : : MessageDialog dialog ( * this
2010-10-13 09:04:20 -06:00
, _ ( " Moving a partition might cause your operating system to fail to boot. " )
2010-09-01 13:54:00 -06:00
, false
, Gtk : : MESSAGE_WARNING
, Gtk : : BUTTONS_OK
, true
) ;
2010-10-13 09:04:20 -06:00
Glib : : ustring tmp_msg =
/*TO TRANSLATORS: looks like You queued an operation to move the start sector of partition /dev/sda3. */
String : : ucompose ( _ ( " You have queued an operation to move the start sector of partition %1. " )
, operation - > partition_original . get_path ( )
) ;
2010-09-01 13:54:00 -06:00
tmp_msg + = " Failure to boot is most likely to occur if you move the GNU/Linux partition containing /boot, or if you move the Windows system partition C:. " ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " You can learn how to repair the boot configuration in the GParted FAQ. " ) ;
tmp_msg + = " \n " ;
2010-10-12 11:35:26 -06:00
tmp_msg + = " http://gparted.org/faq.php " ;
2010-09-01 13:54:00 -06:00
tmp_msg + = " \n \n " ;
tmp_msg + = " Moving a partition might take a very long time to apply. " ;
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
}
2011-10-05 12:15:16 -06:00
// Try to merge with previous operation
if ( operations . size ( ) > = 2 )
{
Merge_Operations ( operations . size ( ) - 2 , operations . size ( ) - 1 ) ;
}
2006-08-01 14:19:17 -06:00
}
2004-09-19 14:24:53 -06:00
}
}
2006-03-07 04:55:27 -07:00
void Win_GParted : : activate_copy ( )
2004-09-19 14:24:53 -06:00
{
copied_partition = selected_partition ;
}
2006-03-07 04:55:27 -07:00
void Win_GParted : : activate_paste ( )
2004-09-19 14:24:53 -06:00
{
2006-11-26 16:24:39 -07:00
//if max_prims == -1 the current device has an unrecognised disklabel (see also GParted_Core::get_devices)
if ( devices [ current_device ] . max_prims = = - 1 )
2004-09-19 14:24:53 -06:00
{
2009-10-24 14:16:40 -06:00
show_disklabel_unrecognized ( devices [ current_device ] . get_path ( ) ) ;
2006-11-26 16:24:39 -07:00
return ;
}
2006-03-29 12:21:42 -07:00
2006-11-26 16:24:39 -07:00
if ( selected_partition . type = = GParted : : TYPE_UNALLOCATED )
{
2006-03-29 12:21:42 -07:00
if ( ! max_amount_prim_reached ( ) )
2004-11-06 04:55:03 -07:00
{
2006-03-29 12:21:42 -07:00
Dialog_Partition_Copy dialog ( gparted_core . get_fs ( copied_partition . filesystem ) ,
devices [ current_device ] . cylsize ) ;
2008-11-18 16:58:17 -07:00
//we don't need the messages/mount points of the source partition.
2006-07-30 09:13:41 -06:00
copied_partition . messages . clear ( ) ;
2006-03-29 12:21:42 -07:00
copied_partition . clear_mountpoints ( ) ;
dialog . Set_Data ( selected_partition , copied_partition ) ;
dialog . set_transient_for ( * this ) ;
2009-01-06 15:22:09 -07:00
2006-03-29 12:21:42 -07:00
if ( dialog . run ( ) = = Gtk : : RESPONSE_OK )
{
dialog . hide ( ) ;
2006-08-01 14:19:17 -06:00
Operation * operation = new OperationCopy ( devices [ current_device ] ,
2010-04-19 19:22:31 -06:00
selected_partition ,
dialog . Get_New_Partition ( devices [ current_device ] . sector_size ) ,
copied_partition ) ;
2006-08-01 14:19:17 -06:00
operation - > icon = render_icon ( Gtk : : Stock : : COPY , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2006-03-29 12:21:42 -07:00
}
2004-11-06 04:55:03 -07:00
}
2004-09-19 14:24:53 -06:00
}
2006-03-29 12:21:42 -07:00
else
{
Partition partition_new = selected_partition ;
partition_new . filesystem = copied_partition . filesystem ;
2008-11-04 14:47:23 -07:00
partition_new . label = copied_partition . label ;
2012-01-22 13:49:52 -07:00
partition_new . uuid = copied_partition . uuid ;
2006-03-29 12:21:42 -07:00
partition_new . color = copied_partition . color ;
partition_new . set_used ( copied_partition . sectors_used ) ;
2006-07-30 09:13:41 -06:00
partition_new . messages . clear ( ) ;
2009-01-06 15:22:09 -07:00
2006-08-01 14:19:17 -06:00
Operation * operation = new OperationCopy ( devices [ current_device ] ,
selected_partition ,
partition_new ,
2006-08-08 13:04:29 -06:00
copied_partition ) ;
2006-08-01 14:19:17 -06:00
operation - > icon = render_icon ( Gtk : : Stock : : COPY , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2009-11-25 12:36:43 -07:00
//Warn that paste operation will overwrite data in existing partition
Gtk : : MessageDialog dialog ( * this
, _ ( " You have pasted into an existing partition. " )
, false
, Gtk : : MESSAGE_WARNING
, Gtk : : BUTTONS_OK
, true
) ;
/*TO TRANSLATORS: looks like The data in /dev/sda3 will be lost if you apply this operation. */
dialog . set_secondary_text ( String : : ucompose ( _ ( " The data in %1 will be lost if you apply this operation. " ) , partition_new . get_path ( ) ) ) ;
dialog . run ( ) ;
2006-03-29 12:21:42 -07:00
}
2004-09-19 14:24:53 -06:00
}
2006-02-09 10:02:40 -07:00
void Win_GParted : : activate_new ( )
2004-09-19 14:24:53 -06:00
{
2004-11-27 16:31:19 -07:00
//if max_prims == -1 the current device has an unrecognised disklabel (see also GParted_Core::get_devices)
if ( devices [ current_device ] . max_prims = = - 1 )
2009-10-24 14:16:40 -06:00
{
show_disklabel_unrecognized ( devices [ current_device ] . get_path ( ) ) ;
}
2006-02-09 10:02:40 -07:00
else if ( ! max_amount_prim_reached ( ) )
2009-01-06 15:22:09 -07:00
{
2004-11-06 04:55:03 -07:00
Dialog_Partition_New dialog ;
2009-01-06 15:22:09 -07:00
dialog . Set_Data ( selected_partition ,
2006-03-24 12:08:41 -07:00
index_extended > - 1 ,
2006-02-09 10:02:40 -07:00
new_count ,
gparted_core . get_filesystems ( ) ,
devices [ current_device ] . readonly ,
2010-02-24 11:39:42 -07:00
devices [ current_device ] . disktype ) ;
2009-01-06 15:22:09 -07:00
2004-11-06 04:55:03 -07:00
dialog . set_transient_for ( * this ) ;
2009-01-06 15:22:09 -07:00
2006-02-09 10:02:40 -07:00
if ( dialog . run ( ) = = Gtk : : RESPONSE_OK )
2004-11-06 04:55:03 -07:00
{
2006-03-07 04:55:27 -07:00
dialog . hide ( ) ;
2009-01-06 15:22:09 -07:00
2004-11-06 04:55:03 -07:00
new_count + + ;
2006-08-01 14:19:17 -06:00
Operation * operation = new OperationCreate ( devices [ current_device ] ,
2010-04-19 19:22:31 -06:00
selected_partition ,
dialog . Get_New_Partition ( devices [ current_device ] . sector_size ) ) ;
2006-08-01 14:19:17 -06:00
operation - > icon = render_icon ( Gtk : : Stock : : NEW , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2004-11-06 04:55:03 -07:00
}
}
2004-09-19 14:24:53 -06:00
}
2006-01-02 08:18:29 -07:00
void Win_GParted : : activate_delete ( )
2009-01-06 15:22:09 -07:00
{
2006-01-02 08:18:29 -07:00
/* since logicals are *always* numbered from 5 to <last logical> there can be a shift
* in numbers after deletion .
* e . g . consider / dev / hda5 / dev / hda6 / dev / hda7 . Now after removal of / dev / hda6 ,
* / dev / hda7 is renumbered to / dev / hda6
2009-01-06 15:22:09 -07:00
* the new situation is now / dev / hda5 / dev / hda6 . If / dev / hda7 was mounted
2006-01-02 08:18:29 -07:00
* the OS cannot find / dev / hda7 anymore and the results aren ' t that pretty .
* It seems best to check for this and prohibit deletion with some explanation to the user . */
if ( selected_partition . type = = GParted : : TYPE_LOGICAL & &
2009-01-06 15:22:09 -07:00
selected_partition . status ! = GParted : : STAT_NEW & &
2006-01-02 08:18:29 -07:00
selected_partition . partition_number < devices [ current_device ] . highest_busy )
2009-01-06 15:22:09 -07:00
{
2006-02-17 14:18:07 -07:00
Gtk : : MessageDialog dialog ( * this ,
2006-03-14 14:37:47 -07:00
String : : ucompose ( _ ( " Unable to delete %1! " ) , selected_partition . get_path ( ) ) ,
2006-02-17 14:18:07 -07:00
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
2009-01-06 15:22:09 -07:00
dialog . set_secondary_text (
2006-02-17 14:18:07 -07:00
String : : ucompose ( _ ( " Please unmount any logical partitions having a number higher than %1 " ) ,
selected_partition . partition_number ) ) ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
dialog . run ( ) ;
2004-09-24 19:10:21 -06:00
return ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
2006-03-14 14:37:47 -07:00
//if partition is on the clipboard...(NOTE: we can't use Partition::== here..)
if ( selected_partition . get_path ( ) = = copied_partition . get_path ( ) )
2004-10-02 03:39:16 -06:00
{
2006-02-17 14:18:07 -07:00
Gtk : : MessageDialog dialog ( * this ,
2009-01-06 15:22:09 -07:00
String : : ucompose ( _ ( " Are you sure you want to delete %1? " ) ,
2006-03-14 14:37:47 -07:00
selected_partition . get_path ( ) ) ,
2006-02-17 14:18:07 -07:00
false ,
Gtk : : MESSAGE_QUESTION ,
Gtk : : BUTTONS_NONE ,
true ) ;
dialog . set_secondary_text ( _ ( " After deletion this partition is no longer available for copying. " ) ) ;
2009-01-06 15:22:09 -07:00
2006-01-20 16:35:06 -07:00
/*TO TRANSLATORS: dialogtitle, looks like Delete /dev/hda2 (ntfs, 2345 MiB) */
2009-01-06 15:22:09 -07:00
dialog . set_title ( String : : ucompose ( _ ( " Delete %1 (%2, %3) " ) ,
selected_partition . get_path ( ) ,
2006-03-28 05:40:29 -07:00
Utils : : get_filesystem_string ( selected_partition . filesystem ) ,
2010-04-28 09:11:44 -06:00
Utils : : format_size ( selected_partition . get_sector_length ( ) , selected_partition . sector_size ) ) ) ;
2006-01-02 08:18:29 -07:00
dialog . add_button ( Gtk : : Stock : : CANCEL , Gtk : : RESPONSE_CANCEL ) ;
dialog . add_button ( Gtk : : Stock : : DELETE , Gtk : : RESPONSE_OK ) ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
dialog . show_all_children ( ) ;
if ( dialog . run ( ) ! = Gtk : : RESPONSE_OK )
return ;
2004-10-02 03:39:16 -06:00
}
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
//if deleted partition was on the clipboard we erase it...
2006-03-14 14:37:47 -07:00
if ( selected_partition . get_path ( ) = = copied_partition . get_path ( ) )
2006-01-02 08:18:29 -07:00
copied_partition . Reset ( ) ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
/* if deleted one is NEW, it doesn't make sense to add it to the operationslist,
* we erase its creation and possible modifications like resize etc . . from the operationslist .
* Calling Refresh_Visual will wipe every memory of its existence ; - ) */
if ( selected_partition . status = = GParted : : STAT_NEW )
{
2009-01-06 15:22:09 -07:00
//remove all operations done on this new partition (this includes creation)
for ( int t = 0 ; t < static_cast < int > ( operations . size ( ) ) ; t + + )
2006-03-24 12:08:41 -07:00
if ( operations [ t ] - > partition_new . get_path ( ) = = selected_partition . get_path ( ) )
remove_operation ( t - - ) ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
//determine lowest possible new_count
2009-01-06 15:22:09 -07:00
new_count = 0 ;
2006-01-02 08:18:29 -07:00
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
2006-03-24 12:08:41 -07:00
if ( operations [ t ] - > partition_new . status = = GParted : : STAT_NEW & &
operations [ t ] - > partition_new . partition_number > new_count )
new_count = operations [ t ] - > partition_new . partition_number ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
new_count + = 1 ;
2009-01-06 15:22:09 -07:00
2011-10-05 12:15:16 -06:00
// Verify if the two operations can be merged
for ( int t = 0 ; t < static_cast < int > ( operations . size ( ) - 1 ) ; t + + )
{
Merge_Operations ( t , t + 1 ) ;
}
2009-01-06 15:22:09 -07:00
Refresh_Visual ( ) ;
2006-01-02 08:18:29 -07:00
if ( ! operations . size ( ) )
close_operationslist ( ) ;
2004-09-19 14:24:53 -06:00
}
2006-08-01 14:19:17 -06:00
else //deletion of a real partition...
{
Operation * operation = new OperationDelete ( devices [ current_device ] , selected_partition ) ;
operation - > icon = render_icon ( Gtk : : Stock : : DELETE , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
}
2004-09-19 14:24:53 -06:00
}
2006-02-17 14:18:07 -07:00
void Win_GParted : : activate_info ( )
2004-09-19 14:24:53 -06:00
{
Dialog_Partition_Info dialog ( selected_partition ) ;
2004-12-27 05:08:01 -07:00
dialog . set_transient_for ( * this ) ;
2006-01-02 08:18:29 -07:00
dialog . run ( ) ;
2004-09-19 14:24:53 -06:00
}
2006-01-02 08:18:29 -07:00
void Win_GParted : : activate_format ( GParted : : FILESYSTEM new_fs )
2004-09-19 14:24:53 -06:00
{
2004-12-09 15:56:33 -07:00
//check for some limits...
2005-01-11 14:18:15 -07:00
fs = gparted_core . get_fs ( new_fs ) ;
2009-01-06 15:22:09 -07:00
2010-04-27 12:54:14 -06:00
if ( ( selected_partition . get_byte_length ( ) < fs . MIN ) | |
( fs . MAX & & selected_partition . get_byte_length ( ) > fs . MAX ) )
2004-09-19 14:24:53 -06:00
{
2006-02-17 14:18:07 -07:00
Gtk : : MessageDialog dialog ( * this ,
2010-10-12 18:14:30 -06:00
String : : ucompose (
/* TO TRANSLATORS: looks like
* Cannot format this file system to fat16 .
*/
_ ( " Cannot format this file system to %1. " ) ,
Utils : : get_filesystem_string ( new_fs ) ) ,
2006-02-17 14:18:07 -07:00
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
2010-04-27 12:54:14 -06:00
if ( selected_partition . get_byte_length ( ) < fs . MIN )
2010-10-12 18:14:30 -06:00
dialog . set_secondary_text ( String : : ucompose (
/* TO TRANSLATORS: looks like
* A fat16 file system requires a partition of at least 16.00 MiB .
*/
2008-11-18 16:58:17 -07:00
_ ( " A %1 file system requires a partition of at least %2. " ) ,
2006-03-28 05:40:29 -07:00
Utils : : get_filesystem_string ( new_fs ) ,
2010-04-26 11:42:23 -06:00
Utils : : format_size ( fs . MIN , 1 /* Byte */ ) ) ) ;
2004-12-09 15:56:33 -07:00
else
2010-10-12 18:14:30 -06:00
dialog . set_secondary_text ( String : : ucompose (
/* TO TRANSLATORS: looks like
* A partition with a hfs file system has a maximum size of 2.00 GiB .
*/
2008-11-18 16:58:17 -07:00
_ ( " A partition with a %1 file system has a maximum size of %2. " ) ,
2006-03-28 05:40:29 -07:00
Utils : : get_filesystem_string ( new_fs ) ,
2010-04-26 11:42:23 -06:00
Utils : : format_size ( fs . MAX , 1 /* Byte */ ) ) ) ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
dialog . run ( ) ;
2004-12-09 15:56:33 -07:00
return ;
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
//ok we made it. lets create an fitting partition object
2006-03-14 14:37:47 -07:00
Partition part_temp ;
2010-04-19 19:22:31 -06:00
part_temp . Set ( devices [ current_device ] . get_path ( ) ,
selected_partition . get_path ( ) ,
selected_partition . partition_number ,
2006-03-24 12:08:41 -07:00
selected_partition . type ,
2010-04-19 19:22:31 -06:00
new_fs ,
2005-12-07 15:44:40 -07:00
selected_partition . sector_start ,
2010-04-19 19:22:31 -06:00
selected_partition . sector_end ,
devices [ current_device ] . sector_size ,
selected_partition . inside_extended ,
2005-12-07 15:44:40 -07:00
false ) ;
2011-10-05 12:15:16 -06:00
part_temp . Set_Unused ( selected_partition . sectors_unused ) ;
part_temp . set_used ( 0 ) ;
2009-01-06 15:22:09 -07:00
2006-03-18 14:38:19 -07:00
part_temp . status = GParted : : STAT_FORMATTED ;
2009-01-06 15:22:09 -07:00
2006-01-02 08:18:29 -07:00
//if selected_partition is NEW we simply remove the NEW operation from the list and
2008-11-18 16:58:17 -07:00
//add it again with the new file system
2006-01-02 08:18:29 -07:00
if ( selected_partition . status = = GParted : : STAT_NEW )
2004-09-19 14:24:53 -06:00
{
//remove operation which creates this partition
2006-01-02 08:18:29 -07:00
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
2004-09-19 14:24:53 -06:00
{
2006-03-24 12:08:41 -07:00
if ( operations [ t ] - > partition_new = = selected_partition )
2004-09-19 14:24:53 -06:00
{
2006-03-24 12:08:41 -07:00
remove_operation ( t ) ;
2009-01-06 15:22:09 -07:00
2006-08-01 14:19:17 -06:00
//And insert the new partition at the old position in the operations list
2006-01-02 08:18:29 -07:00
//(NOTE: in this case we set status to STAT_NEW)
2004-09-26 12:41:43 -06:00
part_temp . status = STAT_NEW ;
2009-01-06 15:22:09 -07:00
2006-08-01 14:19:17 -06:00
Operation * operation = new OperationCreate ( devices [ current_device ] ,
selected_partition ,
part_temp ) ;
operation - > icon = render_icon ( Gtk : : Stock : : NEW , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation , t ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
break ;
}
}
}
2006-01-02 08:18:29 -07:00
else //normal formatting of an existing partition
2006-08-01 14:19:17 -06:00
{
Operation * operation = new OperationFormat ( devices [ current_device ] ,
selected_partition ,
part_temp ) ;
operation - > icon = render_icon ( Gtk : : Stock : : CONVERT , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2011-10-05 12:15:16 -06:00
// Try to merge with previous operation
if ( operations . size ( ) > = 2 )
{
Merge_Operations ( operations . size ( ) - 2 , operations . size ( ) - 1 ) ;
}
2006-08-01 14:19:17 -06:00
}
2004-09-19 14:24:53 -06:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : thread_unmount_partition ( bool * succes , Glib : : ustring * error )
2006-01-08 08:20:14 -07:00
{
2006-02-20 07:41:05 -07:00
std : : vector < Glib : : ustring > errors , failed_mountpoints , mountpoints = gparted_core . get_all_mountpoints ( ) ;
2006-02-17 14:18:07 -07:00
Glib : : ustring dummy ;
2006-02-20 07:41:05 -07:00
2009-01-06 15:22:09 -07:00
* succes = true ;
2006-03-15 09:12:11 -07:00
for ( unsigned int t = 0 ; t < selected_partition . get_mountpoints ( ) . size ( ) ; t + + )
if ( std : : count ( mountpoints . begin ( ) ,
mountpoints . end ( ) ,
2009-01-06 15:22:09 -07:00
selected_partition . get_mountpoints ( ) [ t ] ) < = 1 )
2006-02-20 07:41:05 -07:00
{
2006-03-17 03:07:49 -07:00
if ( Utils : : execute_command ( " umount -v \" " + selected_partition . get_mountpoints ( ) [ t ] + " \" " ,
2006-03-09 12:37:50 -07:00
dummy ,
* error ) )
2006-02-20 07:41:05 -07:00
{
* succes = false ;
2009-01-06 15:22:09 -07:00
errors . push_back ( * error ) ;
2006-02-20 07:41:05 -07:00
}
}
else
2006-03-15 09:12:11 -07:00
failed_mountpoints . push_back ( selected_partition . get_mountpoints ( ) [ t ] ) ;
2006-02-20 07:41:05 -07:00
2009-01-06 15:22:09 -07:00
2006-02-20 07:41:05 -07:00
if ( * succes & & failed_mountpoints . size ( ) )
{
* succes = false ;
2008-11-18 16:58:17 -07:00
* error = _ ( " The partition could not be unmounted from the following mount points: " ) ;
2006-02-20 07:41:05 -07:00
* error + = " \n \n <i> " + Glib : : build_path ( " \n " , failed_mountpoints ) + " </i> \n \n " ;
2008-11-18 16:58:17 -07:00
* error + = _ ( " Most likely other partitions are also mounted on these mount points. You are advised to unmount them manually. " ) ;
2006-02-20 07:41:05 -07:00
}
else
* error = " <i> " + Glib : : build_path ( " \n " , errors ) + " </i> " ;
2006-02-15 09:05:26 -07:00
2006-01-08 08:20:14 -07:00
pulse = false ;
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : thread_mount_partition ( Glib : : ustring mountpoint , bool * succes , Glib : : ustring * error )
2004-11-06 12:48:24 -07:00
{
2006-03-09 12:37:50 -07:00
Glib : : ustring dummy ;
std : : vector < Glib : : ustring > errors ;
2009-01-06 15:22:09 -07:00
2006-03-17 03:07:49 -07:00
* succes = ! Utils : : execute_command ( " mount -v " + selected_partition . get_path ( ) + " \" " + mountpoint + " \" " ,
2006-03-16 10:09:17 -07:00
dummy ,
* error ) ;
2006-02-15 09:05:26 -07:00
2006-03-09 12:37:50 -07:00
pulse = false ;
2006-01-07 14:23:09 -07:00
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : thread_toggle_swap ( bool * succes , Glib : : ustring * error )
{
2006-02-17 14:18:07 -07:00
Glib : : ustring dummy ;
2009-01-06 15:22:09 -07:00
2006-02-08 13:36:18 -07:00
if ( selected_partition . busy )
2006-04-02 07:04:24 -06:00
* succes = ! Utils : : execute_command ( " swapoff -v " + selected_partition . get_path ( ) + " && sync " ,
dummy ,
* error ) ;
2006-01-08 08:20:14 -07:00
else
2006-04-02 07:04:24 -06:00
* succes = ! Utils : : execute_command ( " swapon -v " + selected_partition . get_path ( ) + " && sync " ,
dummy ,
* error ) ;
2006-01-08 08:20:14 -07:00
pulse = false ;
}
2010-08-09 13:37:08 -06:00
2011-01-28 11:09:21 -07:00
// Runs gpart in a thread
void Win_GParted : : thread_guess_partition_table ( )
{
this - > gpart_output = " " ;
this - > gparted_core . guess_partition_table ( devices [ current_device ] , this - > gpart_output ) ;
pulse = false ;
}
void Win_GParted : : toggle_swap_mount_state ( )
2010-08-09 13:37:08 -06:00
{
int operation_count = partition_in_operation_queue_count ( selected_partition ) ;
if ( operation_count > 0 )
{
//Note that this situation will only occur when trying to swapon a partition.
// This is because GParted does not permit queueing operations on partitions
// that are currently active (i.e., swap enabled, or mounted). Hence this
// situation will not occur for the swapoff or unmount actions that this
// method handles.
/*TO TRANSLATORS: Singular case looks like 1 operation is currently pending for partition /dev/sdd8. */
Glib : : ustring tmp_msg =
String : : ucompose ( ngettext ( " %1 operation is currently pending for partition %2. "
, " %1 operations are currently pending for partition %2. "
, operation_count
)
, operation_count
, selected_partition . get_path ( )
) ;
Gtk : : MessageDialog dialog ( * this
, tmp_msg
, false
, Gtk : : MESSAGE_INFO
, Gtk : : BUTTONS_OK
, true
) ;
tmp_msg = _ ( " The swapon action cannot be performed if an operation is pending for the partition. " ) ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " Use the Edit menu to undo, clear, or apply operations before using swapon with this partition. " ) ;
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
return ;
}
2006-02-15 09:05:26 -07:00
bool succes = false ;
Glib : : ustring error ;
2006-01-08 08:20:14 -07:00
pulse = true ;
2006-03-09 12:37:50 -07:00
if ( selected_partition . filesystem = = GParted : : FS_LINUX_SWAP )
{
2009-01-06 15:22:09 -07:00
thread = Glib : : Thread : : create ( sigc : : bind < bool * , Glib : : ustring * > (
2006-02-15 09:05:26 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : thread_toggle_swap ) , & succes , & error ) , true ) ;
2006-01-08 08:20:14 -07:00
2009-01-06 15:22:09 -07:00
show_pulsebar (
String : : ucompose (
2006-03-14 14:37:47 -07:00
selected_partition . busy ? _ ( " Deactivating swap on %1 " ) : _ ( " Activating swap on %1 " ) ,
selected_partition . get_path ( ) ) ) ;
2006-01-08 08:20:14 -07:00
2006-03-09 12:37:50 -07:00
if ( ! succes )
{
2009-01-06 15:22:09 -07:00
Gtk : : MessageDialog dialog (
2006-03-09 12:37:50 -07:00
* this ,
selected_partition . busy ? _ ( " Could not deactivate swap " ) : _ ( " Could not activate swap " ) ,
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
dialog . set_secondary_text ( error ) ;
2009-01-06 15:22:09 -07:00
2006-03-09 12:37:50 -07:00
dialog . run ( ) ;
}
}
2006-03-16 10:09:17 -07:00
else if ( selected_partition . busy )
2006-01-07 14:23:09 -07:00
{
2009-01-06 15:22:09 -07:00
thread = Glib : : Thread : : create ( sigc : : bind < bool * , Glib : : ustring * > (
2006-03-16 10:09:17 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : thread_unmount_partition ) , & succes , & error ) , true ) ;
2006-03-09 12:37:50 -07:00
2006-03-16 10:09:17 -07:00
show_pulsebar ( String : : ucompose ( _ ( " Unmounting %1 " ) , selected_partition . get_path ( ) ) ) ;
2009-01-06 15:22:09 -07:00
2006-03-09 12:37:50 -07:00
if ( ! succes )
{
2009-01-06 15:22:09 -07:00
Gtk : : MessageDialog dialog ( * this ,
2006-03-16 10:09:17 -07:00
String : : ucompose ( _ ( " Could not unmount %1 " ) , selected_partition . get_path ( ) ) ,
2006-03-09 12:37:50 -07:00
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
dialog . set_secondary_text ( error , true ) ;
2009-01-06 15:22:09 -07:00
2006-03-09 12:37:50 -07:00
dialog . run ( ) ;
}
2006-01-07 14:23:09 -07:00
}
2006-03-09 12:37:50 -07:00
2006-01-07 14:23:09 -07:00
menu_gparted_refresh_devices ( ) ;
2004-11-06 12:48:24 -07:00
}
2010-08-09 13:37:08 -06:00
2009-01-06 15:22:09 -07:00
void Win_GParted : : activate_mount_partition ( unsigned int index )
2006-03-16 10:09:17 -07:00
{
2010-08-09 13:37:08 -06:00
int operation_count = partition_in_operation_queue_count ( selected_partition ) ;
if ( operation_count > 0 )
{
/*TO TRANSLATORS: Plural case looks like 4 operations are currently pending for partition /dev/sdd8. */
Glib : : ustring tmp_msg =
String : : ucompose ( ngettext ( " %1 operation is currently pending for partition %2. "
, " %1 operations are currently pending for partition %2. "
, operation_count
)
, operation_count
, selected_partition . get_path ( )
) ;
Gtk : : MessageDialog dialog ( * this
, tmp_msg
, false
, Gtk : : MESSAGE_INFO
, Gtk : : BUTTONS_OK
, true
) ;
tmp_msg = _ ( " The mount action cannot be performed if an operation is pending for the partition. " ) ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " Use the Edit menu to undo, clear, or apply operations before using mount with this partition. " ) ;
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
return ;
}
2006-03-16 10:09:17 -07:00
bool succes = false ;
Glib : : ustring error ;
2010-08-09 13:37:08 -06:00
2006-03-16 10:18:03 -07:00
pulse = true ;
2009-01-06 15:22:09 -07:00
thread = Glib : : Thread : : create ( sigc : : bind < Glib : : ustring , bool * , Glib : : ustring * > (
2006-03-16 10:09:17 -07:00
sigc : : mem_fun ( * this , & Win_GParted : : thread_mount_partition ) ,
selected_partition . get_mountpoints ( ) [ index ] ,
& succes ,
& error ) ,
true ) ;
show_pulsebar ( String : : ucompose ( _ ( " mounting %1 on %2 " ) ,
selected_partition . get_path ( ) ,
selected_partition . get_mountpoints ( ) [ index ] ) ) ;
if ( ! succes )
{
2009-01-06 15:22:09 -07:00
Gtk : : MessageDialog dialog ( * this ,
2006-03-16 10:09:17 -07:00
String : : ucompose ( _ ( " Could not mount %1 on %2 " ) ,
selected_partition . get_path ( ) ,
selected_partition . get_mountpoints ( ) [ index ] ) ,
false ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
dialog . set_secondary_text ( error , true ) ;
2009-01-06 15:22:09 -07:00
2006-03-16 10:09:17 -07:00
dialog . run ( ) ;
}
menu_gparted_refresh_devices ( ) ;
}
2004-11-06 12:48:24 -07:00
2006-02-17 14:18:07 -07:00
void Win_GParted : : activate_disklabel ( )
2005-01-30 07:31:29 -07:00
{
2010-08-10 12:59:26 -06:00
//If there are active mounted partitions on the device then warn
// the user that all partitions must be unactive before creating
// a new partition table
int active_count = active_partitions_on_device_count ( devices [ current_device ] ) ;
if ( active_count > 0 )
{
Glib : : ustring tmp_msg =
String : : ucompose ( /*TO TRANSLATORS: Singular case looks like 1 partition is currently active on device /dev/sda. */
ngettext ( " %1 partition is currently active on device %2. "
/*TO TRANSLATORS: Plural case looks like 3 partitions are currently active on device /dev/sda. */
, " %1 partitions are currently active on device %2. "
, active_count
)
, active_count
, devices [ current_device ] . get_path ( )
) ;
Gtk : : MessageDialog dialog ( * this
, tmp_msg
, false
, Gtk : : MESSAGE_INFO
, Gtk : : BUTTONS_OK
, true
) ;
tmp_msg = _ ( " A new partition table cannot be created when there are active partitions. " ) ;
tmp_msg + = " " ;
tmp_msg + = _ ( " Active partitions are those that are in use, such as a mounted file system, or enabled swap space. " ) ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " Use Partition menu options, such as unmount or swapoff, to deactivate all partitions on this device before creating a new partition table. " ) ;
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
return ;
}
2009-10-25 14:33:36 -06:00
//If there are pending operations then warn the user that these
// operations must either be applied or cleared before creating
// a new partition table.
if ( operations . size ( ) )
{
Glib : : ustring tmp_msg =
String : : ucompose ( ngettext ( " %1 operation is currently pending. "
, " %1 operations are currently pending. "
, operations . size ( )
)
, operations . size ( )
) ;
Gtk : : MessageDialog dialog ( * this
, tmp_msg
, false
, Gtk : : MESSAGE_INFO
, Gtk : : BUTTONS_OK
, true
) ;
tmp_msg = _ ( " A new partition table cannot be created when there are pending operations. " ) ;
tmp_msg + = " \n " ;
tmp_msg + = _ ( " Use the Edit menu to either clear or apply all operations before creating a new partition table. " ) ;
dialog . set_secondary_text ( tmp_msg ) ;
dialog . run ( ) ;
return ;
}
//Display dialog for creating a new partition table.
2006-03-14 14:37:47 -07:00
Dialog_Disklabel dialog ( devices [ current_device ] . get_path ( ) , gparted_core . get_disklabeltypes ( ) ) ;
2005-01-30 07:31:29 -07:00
dialog . set_transient_for ( * this ) ;
2009-07-06 15:58:08 -06:00
if ( dialog . run ( ) = = Gtk : : RESPONSE_APPLY )
2005-01-30 07:31:29 -07:00
{
2008-04-18 09:28:30 -06:00
if ( ! gparted_core . set_disklabel ( devices [ current_device ] . get_path ( ) , dialog . Get_Disklabel ( ) ) )
2005-01-30 07:31:29 -07:00
{
2006-02-17 14:18:07 -07:00
Gtk : : MessageDialog dialog ( * this ,
2008-04-18 09:28:30 -06:00
_ ( " Error while creating partition table. " ) ,
2006-02-17 14:18:07 -07:00
true ,
Gtk : : MESSAGE_ERROR ,
Gtk : : BUTTONS_OK ,
true ) ;
dialog . run ( ) ;
2005-01-30 07:31:29 -07:00
}
2006-04-15 06:42:57 -06:00
dialog . hide ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
menu_gparted_refresh_devices ( ) ;
2005-01-30 07:31:29 -07:00
}
}
2011-01-28 11:09:21 -07:00
//Runs when the Device->Attempt Rescue Data is clicked
void Win_GParted : : activate_attempt_rescue_data ( )
{
if ( Glib : : find_program_in_path ( " gpart " ) . empty ( ) ) //Gpart must be installed to continue
{
Gtk : : MessageDialog errorDialog ( * this , " " , true , Gtk : : MESSAGE_ERROR , Gtk : : BUTTONS_OK , true ) ;
errorDialog . set_message ( _ ( " Command gpart was not found " ) ) ;
errorDialog . set_secondary_text ( _ ( " This feature uses gpart. Please install gpart and try again. " ) ) ;
errorDialog . run ( ) ;
return ;
}
//Dialog information
Glib : : ustring sec_text = _ ( " A full disk scan is needed to find file systems. " ) ;
sec_text + = " \n " ;
sec_text + = _ ( " The scan might take a very long time. " ) ;
sec_text + = " \n " ;
sec_text + = _ ( " After the scan you can mount any discovered file systems and copy the data to other media. " ) ;
sec_text + = " \n " ;
sec_text + = _ ( " Do you want to continue? " ) ;
Gtk : : MessageDialog messageDialog ( * this , " " , true , Gtk : : MESSAGE_WARNING , Gtk : : BUTTONS_OK_CANCEL , true ) ;
/*TO TRANSLATORS: looks like Search for file systems on /deb/sdb */
messageDialog . set_message ( String : : ucompose ( _ ( " Search for file systems on %1 " ) , devices [ current_device ] . get_path ( ) ) ) ;
messageDialog . set_secondary_text ( sec_text ) ;
if ( messageDialog . run ( ) ! = Gtk : : RESPONSE_OK )
{
return ;
}
messageDialog . hide ( ) ;
pulse = true ;
this - > thread = Glib : : Thread : : create ( sigc : : mem_fun ( * this , & Win_GParted : : thread_guess_partition_table ) , true ) ;
/*TO TRANSLATORS: looks like Searching for file systems on /deb/sdb */
show_pulsebar ( String : : ucompose ( _ ( " Searching for file systems on %1 " ) , devices [ current_device ] . get_path ( ) ) ) ;
Dialog_Rescue_Data dialog ;
dialog . set_transient_for ( * this ) ;
//Reads the output of gpart
dialog . init_partitions ( & devices [ current_device ] , this - > gpart_output ) ;
if ( dialog . get_partitions ( ) . size ( ) = = 0 ) //No partitions found
{
//Dialog information
Gtk : : MessageDialog errorDialog ( * this , " " , true , Gtk : : MESSAGE_ERROR , Gtk : : BUTTONS_OK , true ) ;
/*TO TRANSLATORS: looks like No file systems found on /deb/sdb */
errorDialog . set_message ( String : : ucompose ( _ ( " No file systems found on %1 " ) , devices [ current_device ] . get_path ( ) ) ) ;
errorDialog . set_secondary_text ( _ ( " The disk scan by gpart did not find any recognizable file systems on this disk. " ) ) ;
errorDialog . run ( ) ;
return ;
}
dialog . run ( ) ;
dialog . hide ( ) ;
Glib : : ustring commandUmount = " umount /tmp/gparted-roview* " ;
Utils : : execute_command ( commandUmount ) ;
menu_gparted_refresh_devices ( ) ;
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : activate_manage_flags ( )
2006-03-31 03:49:27 -07:00
{
2006-04-02 05:18:34 -06:00
get_window ( ) - > set_cursor ( Gdk : : Cursor ( Gdk : : WATCH ) ) ;
while ( Gtk : : Main : : events_pending ( ) )
Gtk : : Main : : iteration ( ) ;
2006-03-31 03:49:27 -07:00
2006-04-02 05:18:34 -06:00
DialogManageFlags dialog ( selected_partition , gparted_core . get_available_flags ( selected_partition ) ) ;
dialog . set_transient_for ( * this ) ;
2006-03-31 03:49:27 -07:00
dialog . signal_get_flags . connect (
sigc : : mem_fun ( & gparted_core , & GParted_Core : : get_available_flags ) ) ;
dialog . signal_toggle_flag . connect (
sigc : : mem_fun ( & gparted_core , & GParted_Core : : toggle_flag ) ) ;
2006-04-02 05:18:34 -06:00
get_window ( ) - > set_cursor ( ) ;
2009-01-06 15:22:09 -07:00
2006-03-31 03:49:27 -07:00
dialog . run ( ) ;
dialog . hide ( ) ;
2009-01-06 15:22:09 -07:00
2006-03-31 03:49:27 -07:00
if ( dialog . any_change )
menu_gparted_refresh_devices ( ) ;
}
2009-01-06 15:22:09 -07:00
void Win_GParted : : activate_check ( )
2006-11-26 07:27:16 -07:00
{
Operation * operation = new OperationCheck ( devices [ current_device ] , selected_partition ) ;
operation - > icon = render_icon ( Gtk : : Stock : : EXECUTE , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
2011-10-05 12:15:16 -06:00
// Verify if the two operations can be merged
for ( unsigned int t = 0 ; t < operations . size ( ) - 1 ; t + + )
{
if ( operations [ t ] - > type = = OPERATION_CHECK )
{
if ( Merge_Operations ( t , operations . size ( ) - 1 ) )
break ;
}
}
2006-11-26 07:27:16 -07:00
}
2005-01-30 07:31:29 -07:00
2009-01-06 15:22:09 -07:00
void Win_GParted : : activate_label_partition ( )
2008-04-07 13:41:18 -06:00
{
Dialog_Partition_Label dialog ( selected_partition ) ;
dialog . set_transient_for ( * this ) ;
if ( ( dialog . run ( ) = = Gtk : : RESPONSE_OK )
2009-01-06 15:22:09 -07:00
& & ( dialog . get_new_label ( ) ! = selected_partition . label ) )
2008-04-07 13:41:18 -06:00
{
dialog . hide ( ) ;
//Make a duplicate of the selected partition (used in UNDO)
Partition part_temp ;
2010-04-19 19:22:31 -06:00
part_temp . Set ( devices [ current_device ] . get_path ( ) ,
selected_partition . get_path ( ) ,
selected_partition . partition_number ,
2008-04-07 13:41:18 -06:00
selected_partition . type ,
2010-04-19 19:22:31 -06:00
selected_partition . filesystem ,
2008-04-07 13:41:18 -06:00
selected_partition . sector_start ,
2010-04-19 19:22:31 -06:00
selected_partition . sector_end ,
devices [ current_device ] . sector_size ,
selected_partition . inside_extended ,
2008-04-07 13:41:18 -06:00
false ) ;
2011-10-05 12:15:16 -06:00
part_temp . Set_Unused ( selected_partition . sectors_unused ) ;
part_temp . set_used ( selected_partition . sectors_used ) ;
2008-04-07 13:41:18 -06:00
part_temp . label = dialog . get_new_label ( ) ;
2012-01-22 13:49:52 -07:00
part_temp . uuid = selected_partition . uuid ;
2008-04-07 13:41:18 -06:00
Operation * operation = new OperationLabelPartition ( devices [ current_device ] ,
selected_partition , part_temp ) ;
operation - > icon = render_icon ( Gtk : : Stock : : EXECUTE , Gtk : : ICON_SIZE_MENU ) ;
2011-10-05 12:15:16 -06:00
2008-04-07 13:41:18 -06:00
Add_Operation ( operation ) ;
2011-10-05 12:15:16 -06:00
// Verify if the two operations can be merged
for ( unsigned int t = 0 ; t < operations . size ( ) - 1 ; t + + )
{
if ( operations [ t ] - > type = = OPERATION_LABEL_PARTITION )
{
if ( Merge_Operations ( t , operations . size ( ) - 1 ) )
break ;
}
}
2008-04-07 13:41:18 -06:00
}
}
2009-01-06 15:22:09 -07:00
2012-01-22 13:49:52 -07:00
void Win_GParted : : activate_change_uuid ( )
{
//Make a duplicate of the selected partition (used in UNDO)
Partition part_temp ;
part_temp . Set ( devices [ current_device ] . get_path ( ) ,
selected_partition . get_path ( ) ,
selected_partition . partition_number ,
selected_partition . type ,
selected_partition . filesystem ,
selected_partition . sector_start ,
selected_partition . sector_end ,
devices [ current_device ] . sector_size ,
selected_partition . inside_extended ,
false ) ;
part_temp . label = selected_partition . label ;
part_temp . uuid = _ ( " (New UUID - will be randomly generated) " ) ;
Operation * operation = new OperationChangeUUID ( devices [ current_device ] ,
selected_partition , part_temp ) ;
operation - > icon = render_icon ( Gtk : : Stock : : EXECUTE , Gtk : : ICON_SIZE_MENU ) ;
Add_Operation ( operation ) ;
// Verify if the two operations can be merged
for ( unsigned int t = 0 ; t < operations . size ( ) - 1 ; t + + )
{
if ( operations [ t ] - > type = = OPERATION_CHANGE_UUID )
{
if ( Merge_Operations ( t , operations . size ( ) - 1 ) )
break ;
}
}
}
2006-02-17 14:18:07 -07:00
void Win_GParted : : activate_undo ( )
2004-09-19 14:24:53 -06:00
{
2006-11-26 07:27:16 -07:00
//when undoing a creation it's safe to decrease the newcount by one
2006-07-29 09:20:32 -06:00
if ( operations . back ( ) - > type = = OPERATION_CREATE )
2004-10-06 09:32:40 -06:00
new_count - - ;
2006-03-24 12:08:41 -07:00
2009-01-06 15:22:09 -07:00
remove_operation ( ) ;
2006-02-17 14:18:07 -07:00
Refresh_Visual ( ) ;
2009-01-06 15:22:09 -07:00
2006-02-17 14:18:07 -07:00
if ( ! operations . size ( ) )
close_operationslist ( ) ;
2011-01-19 15:32:56 -07:00
//FIXME: A slight flicker may be introduced by this extra display refresh.
//An extra display refresh seems to prevent the disk area visual disk from
// disappearing when there enough operations to require a scrollbar
// (about 4+ operations with default window size) and a user clicks on undo.
// See also Win_GParted::Add_operation().
drawingarea_visualdisk . queue_draw ( ) ;
2004-09-19 14:24:53 -06:00
}
2010-08-09 13:33:28 -06:00
2009-01-06 15:22:09 -07:00
void Win_GParted : : remove_operation ( int index , bool remove_all )
2006-03-24 12:08:41 -07:00
{
if ( remove_all )
{
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
delete operations [ t ] ;
operations . clear ( ) ;
}
else if ( index = = - 1 & & operations . size ( ) > 0 )
{
delete operations . back ( ) ;
operations . pop_back ( ) ;
}
else if ( index > - 1 & & index < static_cast < int > ( operations . size ( ) ) )
{
delete operations [ index ] ;
operations . erase ( operations . begin ( ) + index ) ;
}
}
2004-09-19 14:24:53 -06:00
2010-08-10 11:36:10 -06:00
int Win_GParted : : partition_in_operation_queue_count ( const Partition & partition )
{
int operation_count = 0 ;
for ( unsigned int t = 0 ; t < operations . size ( ) ; t + + )
{
if ( partition . get_path ( ) = = operations [ t ] - > partition_original . get_path ( ) )
operation_count + + ;
}
return operation_count ;
}
2010-08-10 12:52:59 -06:00
int Win_GParted : : active_partitions_on_device_count ( const Device & device )
{
int active_count = 0 ;
//Count the active partitions on the device
for ( unsigned int k = 0 ; k < device . partitions . size ( ) ; k + + )
{
//FIXME: Should also count other types of active partitions, such as LVM2 when we know how.
//Count the active primary partitions
if ( device . partitions [ k ] . busy
& & device . partitions [ k ] . type ! = TYPE_EXTENDED
& & device . partitions [ k ] . type ! = TYPE_UNALLOCATED
)
active_count + + ;
//Count the active logical partitions
if ( device . partitions [ k ] . busy
& & device . partitions [ k ] . type = = TYPE_EXTENDED
)
{
for ( unsigned int j = 0 ; j < device . partitions [ k ] . logicals . size ( ) ; j + + )
{
if ( device . partitions [ k ] . logicals [ j ] . busy
& & device . partitions [ k ] . logicals [ j ] . type ! = TYPE_UNALLOCATED
)
active_count + + ;
}
}
}
return active_count ;
}
2006-02-17 14:18:07 -07:00
void Win_GParted : : activate_apply ( )
2004-09-19 14:24:53 -06:00
{
2006-01-19 12:15:15 -07:00
Gtk : : MessageDialog dialog ( * this ,
2006-02-17 14:18:07 -07:00
_ ( " Are you sure you want to apply the pending operations? " ) ,
2006-01-19 12:15:15 -07:00
false ,
Gtk : : MESSAGE_WARNING ,
Gtk : : BUTTONS_NONE ,
true ) ;
2009-01-19 13:38:22 -07:00
Glib : : ustring temp ;
temp = _ ( " Editing partitions has the potential to cause LOSS of DATA. " ) ;
temp + = " \n " ;
temp + = _ ( " You are advised to backup your data before proceeding. " ) ;
dialog . set_secondary_text ( temp ) ;
2008-11-04 15:16:06 -07:00
dialog . set_title ( _ ( " Apply operations to device " ) ) ;
2009-01-06 15:22:09 -07:00
2004-11-17 06:00:25 -07:00
dialog . add_button ( Gtk : : Stock : : CANCEL , Gtk : : RESPONSE_CANCEL ) ;
dialog . add_button ( Gtk : : Stock : : APPLY , Gtk : : RESPONSE_OK ) ;
2009-01-06 15:22:09 -07:00
2006-01-19 12:15:15 -07:00
dialog . show_all_children ( ) ;
if ( dialog . run ( ) = = Gtk : : RESPONSE_OK )
2004-09-19 14:24:53 -06:00
{
2006-01-19 12:15:15 -07:00
dialog . hide ( ) ; //hide confirmationdialog
2009-01-06 15:22:09 -07:00
2006-01-19 12:15:15 -07:00
Dialog_Progress dialog_progress ( operations ) ;
2006-01-26 08:54:44 -07:00
dialog_progress . set_transient_for ( * this ) ;
2006-01-19 12:15:15 -07:00
dialog_progress . signal_apply_operation . connect (
sigc : : mem_fun ( gparted_core , & GParted_Core : : apply_operation_to_disk ) ) ;
2006-12-01 06:01:46 -07:00
dialog_progress . signal_get_libparted_version . connect (
sigc : : mem_fun ( gparted_core , & GParted_Core : : get_libparted_version ) ) ;
2009-01-06 15:22:09 -07:00
2006-02-07 08:17:44 -07:00
int response ;
do
{
response = dialog_progress . run ( ) ;
}
while ( response = = Gtk : : RESPONSE_CANCEL | | response = = Gtk : : RESPONSE_OK ) ;
2009-01-06 15:22:09 -07:00
2006-01-19 12:15:15 -07:00
dialog_progress . hide ( ) ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//wipe operations...
2006-03-24 12:08:41 -07:00
remove_operation ( - 1 , true ) ;
2006-09-17 07:23:47 -06:00
hbox_operations . clear ( ) ;
2006-01-19 12:15:15 -07:00
close_operationslist ( ) ;
2009-01-06 15:22:09 -07:00
2004-10-11 04:23:24 -06:00
//reset new_count to 1
2004-10-16 09:42:08 -06:00
new_count = 1 ;
2009-01-06 15:22:09 -07:00
2004-09-19 14:24:53 -06:00
//reread devices and their layouts...
2006-01-19 12:15:15 -07:00
menu_gparted_refresh_devices ( ) ;
2004-09-19 14:24:53 -06:00
}
}
} // GParted