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

overloaded operator == rewrote the graphical partitiondisplay. It now 

* include/Partition.h,
  src/Partition.cc: overloaded operator ==
* include/VBox_VisualDisk.h,
  src/VBox_VisualDisk.cc: rewrote the graphical partitiondisplay. It
  now supports resizing and the extended partition is also selectable.
  see also #312656
* include/Win_GParted.h,
  src/Win_GParted.cc: use the new graphical partitiondisplay.
* src/TreeView_Detail.cc: minor cleanups
This commit is contained in:
Bart Hakvoort 2005-12-22 22:20:55 +00:00
parent afb93e5449
commit adc76a7686
8 changed files with 561 additions and 375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
View File

@ -1,3 +1,15 @@
2005-12-22 Bart Hakvoort <hakvoort@cvs.gnome.org>
* include/Partition.h,
src/Partition.cc: overloaded operator ==
* include/VBox_VisualDisk.h,
src/VBox_VisualDisk.cc: rewrote the graphical partitiondisplay. It
now supports resizing and the extended partition is also selectable.
see also #312656
* include/Win_GParted.h,
src/Win_GParted.cc: use the new graphical partitiondisplay.
* src/TreeView_Detail.cc: minor cleanups
2005-12-15 Bart Hakvoort <hakvoort@cvs.gnome.org> 2005-12-15 Bart Hakvoort <hakvoort@cvs.gnome.org>
* include/Dialog_Disklabel.h, * include/Dialog_Disklabel.h,

2
include/Partition.h
View File

@ -78,6 +78,8 @@ public:
const long Get_Used_MB( ) const ; const long Get_Used_MB( ) const ;
const long Get_Unused_MB( ) const ; const long Get_Unused_MB( ) const ;
bool operator==( const Partition & partition ) ;
//some public members //some public members
Glib::ustring partition;//the symbolic path (e.g. /dev/hda1 ) Glib::ustring partition;//the symbolic path (e.g. /dev/hda1 )
Glib::ustring device_path ; Glib::ustring device_path ;

133
include/VBox_VisualDisk.h
View File

@ -19,78 +19,111 @@
#define VBOX_VISUALDISK #define VBOX_VISUALDISK
#include "../include/Partition.h" #include "../include/Partition.h"
#include "../include/Device.h"
#include <gtkmm/box.h> #include <gtkmm/box.h>
#include <gtkmm/frame.h> #include <gtkmm/frame.h>
#include <gtkmm/eventbox.h>
#include <gtkmm/tooltips.h>
#include <gtkmm/checkbutton.h>
#include <gtkmm/drawingarea.h> #include <gtkmm/drawingarea.h>
#include <gtkmm/image.h>
#define BORDER 8
namespace GParted namespace GParted
{ {
class VBox_VisualDisk : public Gtk::VBox class VBox_VisualDisk : public Gtk::VBox
{ {
//struct which contains visual information about the partitions. This prevents recalculation of everything after an expose en therefore saves performance..
struct Visual_Partition
{
//2 attributes used for selection ( see Set_Selected() an drawingarea_on_expose() for more info )
Sector sector_start;
int index;
int length; //pixels
int used; //pixels
int height; //pixels
int text_y; //pixels
Gdk::Color color_fs;
Gtk::DrawingArea *drawingarea;
Glib::RefPtr<Gdk::GC> gc;
Glib::RefPtr<Pango::Layout> pango_layout;
};
public: public:
VBox_VisualDisk( const std::vector<Partition> & partitions, const Sector device_length ); VBox_VisualDisk();
~VBox_VisualDisk( ); ~VBox_VisualDisk();
void Set_Selected( const Partition & );
void load_partitions( const std::vector<Partition> & partitions, const Sector device_length );
void set_selected( const Partition & partition ) ;
void clear() ;
//public signal for interclass communication //public signal for interclass communication
sigc::signal<void,GdkEventButton *, const Partition &> signal_mouse_click; sigc::signal<void, GdkEventButton *, const Partition &> signal_mouse_click;
private: private:
void Build_Visual_Disk( ) ; //i still dream of some fully resizeable visualdisk.... struct visual_partition ;
void Create_Visual_Partition( const Partition & partition ) ;
void Prepare_Legend( std::vector<GParted::FILESYSTEM> & legend, const std::vector<Partition> & partitions ) ;
void Build_Legend( ) ;
//signal handlers //private functions
void drawingarea_on_realize( Visual_Partition * ); int get_total_separator_px( const std::vector<Partition> & partitions ) ;
bool drawingarea_on_expose( GdkEventExpose *, Visual_Partition* );
bool on_drawingarea_button_press( GdkEventButton *, const Partition & );
std::vector<Partition> partitions; void set_static_data( const std::vector<Partition> & partitions, std::vector<visual_partition> & visual_partitions, Sector length ) ;
Sector device_length; int calc_length( std::vector<visual_partition> & visual_partitions, int length_px ) ;
void calc_position_and_height( std::vector<visual_partition> & visual_partitions, int start, int border ) ;
void calc_used_unused( std::vector<visual_partition> & visual_partitions ) ;
void calc_text( std::vector<visual_partition> & visual_partitions ) ;
Gtk::Frame *frame_disk_legend ; void build_legend( const std::vector<Partition> & partitions ) ;
Gtk::HBox hbox_disk_main, *hbox_disk, *hbox_extended, hbox_legend_main, *hbox_legend; void prepare_legend( const std::vector<Partition> & partitions, std::vector<GParted::FILESYSTEM> & legend) ;
Gtk::CheckButton checkbutton_filesystem; Gtk::HBox * create_legend_item( GParted::FILESYSTEM fs ) ;
Gtk::Tooltips tooltips;
Gtk::Image *image ;
Visual_Partition *visual_partition; void draw_partitions( const std::vector<visual_partition> & visual_partitions ) ;
std::vector <Visual_Partition *> visual_partitions;
Gtk::EventBox * eventbox_extended; bool set_selected( std::vector<visual_partition> & visual_partitions, int x, int y ) ;
void set_selected( std::vector<visual_partition> & visual_partitions, const Partition & partition ) ;
void free_colors( std::vector<visual_partition> & visual_partitions ) ;
//signalhandlers
void drawingarea_on_realize();
bool drawingarea_on_expose( GdkEventExpose * event );
bool on_drawingarea_button_press( GdkEventButton * event );
void on_resize( Gtk::Allocation & allocation ) ;
//variables
struct visual_partition
{
double fraction ;
double fraction_used ;
int x_start, length ;
int y_start, height ;
int x_used_start, used_length ;
int x_unused_start, unused_length ;
int y_used_unused_start, used_unused_height ;
int x_text, y_text ;
bool selected ;
Gdk::Color color ;
Glib::RefPtr<Pango::Layout> pango_layout;
//real partition
Partition partition ;
std::vector<visual_partition> logicals ;
visual_partition()
{
fraction = fraction_used =
x_start = length =
y_start = height =
x_used_start = used_length =
x_unused_start = unused_length =
y_used_unused_start = used_unused_height =
x_text = y_text = 0 ;
selected = false ;
pango_layout .clear() ;
}
~visual_partition()
{
pango_layout .clear() ;
logicals .clear() ;
}
};
std::vector<visual_partition> visual_partitions ;
visual_partition selected_vp ;
int TOT_SEP, MIN_SIZE ;
Gtk::Frame *frame ;
Gtk::DrawingArea drawingarea;
Gtk::HBox hbox_legend ;
Glib::RefPtr<Gdk::GC> gc;
Gdk::Color color_used, color_unused, color_text; Gdk::Color color_used, color_unused, color_text;
Glib::ustring str_temp ;
int temp, selected_partition, SCREEN_WIDTH;
}; };
} //GParted } //GParted

12
include/Win_GParted.h
View File

@ -39,7 +39,6 @@
#include <gtkmm/separatortoolitem.h> #include <gtkmm/separatortoolitem.h>
#include <gtkmm/menubar.h> #include <gtkmm/menubar.h>
#include <gtkmm/statusbar.h> #include <gtkmm/statusbar.h>
#include <gtkmm/radiobutton.h>
#include <gtkmm/liststore.h> #include <gtkmm/liststore.h>
#include <unistd.h> //should be included by gtkmm headers. but decided to include it anyway after getting some bugreports.. #include <unistd.h> //should be included by gtkmm headers. but decided to include it anyway after getting some bugreports..
@ -159,7 +158,7 @@ private:
Gtk::HPaned hpaned_main; Gtk::HPaned hpaned_main;
Gtk::VPaned vpaned_main; Gtk::VPaned vpaned_main;
Gtk::VBox vbox_main,vbox_info, *vbox; Gtk::VBox vbox_main,vbox_info, *vbox;
Gtk::HBox hbox_toolbar,hbox_visual, hbox_operations, *hbox; Gtk::HBox hbox_toolbar, hbox_operations, *hbox;
Gtk::Toolbar toolbar_main; Gtk::Toolbar toolbar_main;
Gtk::MenuBar menubar_main; Gtk::MenuBar menubar_main;
Gtk::OptionMenu optionmenu_devices; Gtk::OptionMenu optionmenu_devices;
@ -175,7 +174,7 @@ private:
Gtk::MenuItem *menu_item; Gtk::MenuItem *menu_item;
Gtk::ProgressBar *pulsebar ; Gtk::ProgressBar *pulsebar ;
VBox_VisualDisk *vbox_visual_disk; VBox_VisualDisk vbox_visual_disk;
TreeView_Detail treeview_detail; TreeView_Detail treeview_detail;
//operations list //operations list
@ -189,7 +188,12 @@ private:
Gtk::TreeModelColumn<Glib::ustring> operation_description; Gtk::TreeModelColumn<Glib::ustring> operation_description;
Gtk::TreeModelColumn< Glib::RefPtr<Gdk::Pixbuf> > operation_icon; Gtk::TreeModelColumn< Glib::RefPtr<Gdk::Pixbuf> > operation_icon;
treeview_operations_Columns( ) { add( operation_number ); add( operation_description ); add( operation_icon ); } treeview_operations_Columns()
{
add( operation_number );
add( operation_description );
add( operation_icon );
}
}; };
treeview_operations_Columns treeview_operations_columns; treeview_operations_Columns treeview_operations_columns;

7
src/Partition.cc
View File

@ -105,6 +105,13 @@ const long Partition::Get_Unused_MB( ) const
return Get_Length_MB( ) - Get_Used_MB( ) ; return Get_Length_MB( ) - Get_Used_MB( ) ;
} }
bool Partition::operator==( const Partition & partition )
{
return this ->partition_number == partition .partition_number &&
this ->sector_start == partition .sector_start &&
this ->type == partition .type ;
}
Partition::~Partition( ) Partition::~Partition( )
{ {
} }

8
src/TreeView_Detail.cc
View File

@ -85,7 +85,7 @@ void TreeView_Detail::Load_Partitions( const std::vector<Partition> & partitions
void TreeView_Detail::Set_Selected( const Partition & partition ) void TreeView_Detail::Set_Selected( const Partition & partition )
{ {
//look for appropiate row //look for appropiate row
for( iter = treestore_detail ->children( ) .begin( ) ; iter != treestore_detail ->children( ) .end( ) ; iter++ ) for( iter = treestore_detail ->children() .begin() ; iter != treestore_detail ->children() .end() ; iter++ )
{ {
row = *iter; row = *iter;
partition_temp = row[ treeview_detail_columns.partition_struct ] ; partition_temp = row[ treeview_detail_columns.partition_struct ] ;
@ -99,15 +99,15 @@ void TreeView_Detail::Set_Selected( const Partition & partition )
} }
//logicals //logicals
if ( row .children( ) .size( ) > 0 ) //this is the row with the extended partition, search it's childrows... if ( row .children() .size( ) > 0 ) //this is the row with the extended partition, search it's childrows...
for( iter_child = row .children( ) .begin( ) ; iter_child != row.children( ) .end( ) ; iter_child++ ) for( iter_child = row .children() .begin() ; iter_child != row.children() .end() ; iter_child++ )
{ {
childrow = *iter_child; childrow = *iter_child;
partition_temp = childrow[ treeview_detail_columns.partition_struct ] ; partition_temp = childrow[ treeview_detail_columns.partition_struct ] ;
if ( partition .sector_start >= partition_temp .sector_start && partition .sector_end <= partition_temp .sector_end ) if ( partition .sector_start >= partition_temp .sector_start && partition .sector_end <= partition_temp .sector_end )
{ {
this ->expand_all( ); this ->expand_all();
this ->set_cursor( static_cast <Gtk::TreePath> ( childrow ) ); this ->set_cursor( static_cast <Gtk::TreePath> ( childrow ) );
return; return;
} }

609
src/VBox_VisualDisk.cc
View File

@ -17,311 +17,448 @@
#include "../include/VBox_VisualDisk.h" #include "../include/VBox_VisualDisk.h"
#include <gtkmm/image.h>
#define BORDER 8
#define SEP 5
#define HEIGHT 70
namespace GParted namespace GParted
{ {
VBox_VisualDisk::VBox_VisualDisk( const std::vector<Partition> & partitions, const Sector device_length ) VBox_VisualDisk::VBox_VisualDisk()
{ {
this ->partitions = partitions ;
this ->device_length = device_length ;
selected_partition = -1;
//create frame which contains the visual disk
frame_disk_legend = manage( new Gtk::Frame( ) ) ;
frame_disk_legend ->set_shadow_type( Gtk::SHADOW_ETCHED_OUT );
hbox_disk_main .pack_start( *frame_disk_legend, Gtk::PACK_EXPAND_PADDING );
hbox_disk = NULL ;
hbox_extended = NULL ;
this ->set_border_width( 10 ); this ->set_border_width( 10 );
this ->set_spacing( 12 ); this ->set_spacing( 5 );
this ->pack_start( hbox_disk_main, Gtk::PACK_SHRINK );
//set and allocated some standard colors //set and allocated some standard colors
color_used .set( "#F8F8BA" ); this ->get_colormap( ) ->alloc_color( color_used ) ;//bleach yellow ;) color_used .set( Utils::Get_Color( GParted::FS_USED ) );
color_unused .set( "white" ); this ->get_colormap( ) ->alloc_color( color_unused ) ; this ->get_colormap() ->alloc_color( color_used ) ;
color_text .set( "black" ); this ->get_colormap( ) ->alloc_color( color_text ) ;
color_unused .set( Utils::Get_Color( GParted::FS_UNUSED ) );
this ->get_colormap() ->alloc_color( color_unused ) ;
//since disksegments have minimal sizes ( unallocated 15 and partitions 20 pixels ) i do some checking to prevent the visual disk from growing to much color_text .set( "black" );
Sector sectors_per_pixel = Utils::Round( device_length / 750.00 ) ; this ->get_colormap() ->alloc_color( color_text ) ;
double extra_pixels = 0 ; //prepare drawingarea and frame and pack them
drawingarea .set_events( Gdk::BUTTON_PRESS_MASK );
for ( unsigned int t = 0; t < partitions .size( ) ; t++ ) drawingarea .signal_realize() .connect( sigc::mem_fun(*this, &VBox_VisualDisk::drawingarea_on_realize) ) ;
{ drawingarea .signal_expose_event() .connect( sigc::mem_fun(*this, &VBox_VisualDisk::drawingarea_on_expose) ) ;
double width = static_cast<double> (partitions[ t ] .sector_end - partitions[ t ] .sector_start) / sectors_per_pixel ; drawingarea .signal_button_press_event() .connect( sigc::mem_fun( *this, &VBox_VisualDisk::on_drawingarea_button_press) ) ;
if ( (partitions[ t ] .type == GParted::TYPE_PRIMARY || partitions[ t ] .type == GParted::TYPE_LOGICAL) && width < 20 ) drawingarea .set_size_request( -1, HEIGHT ) ;
extra_pixels += (20 - width) ;
else if ( partitions[ t ] .type == GParted::TYPE_UNALLOCATED && width < 15 )
extra_pixels += (15 - width) ;
}
//draw visual disk and its legend frame = manage( new Gtk::Frame() ) ;
this ->SCREEN_WIDTH = 750 - Utils::Round( extra_pixels ) ; frame ->add( drawingarea );
frame ->set_shadow_type( Gtk::SHADOW_ETCHED_OUT ) ;
this ->pack_start( *frame, Gtk::PACK_EXPAND_WIDGET ) ;
Build_Visual_Disk( ) ; //pack hbox which holds the legend
Build_Legend( ) ; this ->pack_start( hbox_legend );
} }
void VBox_VisualDisk::Build_Visual_Disk( ) void VBox_VisualDisk::load_partitions( const std::vector<Partition> & partitions, const Sector device_length )
{ {
//since there is a 5 pixel space between every partition.... ( extended adds 2 *5 more, but that doesn't matter that much. clear() ;
//NOTE that a part < 20 will also grow to 20, so length in pixels may vary across different devices..
this ->SCREEN_WIDTH -= ( (partitions .size( ) -1) *5 ) ;
//create hbox_disk and add to frame TOT_SEP = get_total_separator_px( partitions ) ;
hbox_disk = manage( new Gtk::HBox( ) ) ; set_static_data( partitions, visual_partitions, device_length ) ;
hbox_disk ->set_spacing( 5 );
frame_disk_legend ->add( *hbox_disk );
drawingarea .queue_resize() ;
//walk through all partitions.... build_legend( partitions ) ;
for ( unsigned int i = 0 ; i < partitions .size( ) ; i++ )
{
Create_Visual_Partition( partitions[ i ] ) ;
if ( partitions[ i ].type != GParted::TYPE_EXTENDED )
hbox_disk ->pack_start( *( visual_partitions .back( ) ->drawingarea ), Gtk::PACK_SHRINK ) ;
}
this ->show_all_children( ) ;
} }
void VBox_VisualDisk::Create_Visual_Partition( const Partition & partition ) void VBox_VisualDisk::set_selected( const Partition & partition )
{ {
int x,y;//for pango_layout check set_selected( visual_partitions, partition ) ;
visual_partition = new Visual_Partition( ) ; draw_partitions( visual_partitions ) ;
visual_partitions .push_back( visual_partition ) ; }
visual_partitions .back( ) ->index = visual_partitions .size( ) -1 ; // <---- BELACHELIJK!! DOE DAAR IETS AAN!!!
visual_partitions .back( ) ->sector_start = partition .sector_start ;
if ( partition .type == GParted::TYPE_EXTENDED ) void VBox_VisualDisk::clear()
{
free_colors( visual_partitions ) ;
visual_partitions .clear() ;
hbox_legend .children() .clear() ;
drawingarea .queue_resize() ;
}
int VBox_VisualDisk::get_total_separator_px( const std::vector<Partition> & partitions )
{
for ( unsigned int t = 0 ; t < partitions .size() ; t++ )
if ( partitions[ t ] .type == GParted::TYPE_EXTENDED )
return ( partitions[ t ] .logicals .size() -1 + partitions .size() -1 ) * SEP ;
return ( partitions .size() -1 ) * SEP ;
}
void VBox_VisualDisk::set_static_data( const std::vector<Partition> & partitions, std::vector<visual_partition> & visual_partitions, Sector length )
{
Sector p_length ;
visual_partition vp ;
for ( unsigned int t = 0 ; t < partitions .size() ; t++ )
{ {
visual_partitions.back( ) ->drawingarea = NULL ;//it's just a dummy ;-) ( see Set_Selected() ) visual_partitions .push_back( vp ) ;
visual_partitions.back( ) ->length = 0 ; //keeps total_length clean
eventbox_extended = manage( new Gtk::EventBox( ) ) ; visual_partitions .back() .partition = partitions[ t ] ;
eventbox_extended ->set_size_request( -1, 60 );
eventbox_extended ->modify_bg( eventbox_extended ->get_state( ), partition .color );
hbox_disk ->pack_start( *eventbox_extended, Gtk::PACK_SHRINK ) ;
hbox_extended = manage( new Gtk::HBox( ) ) ; p_length = partitions[ t ] .sector_end - partitions[ t ] .sector_start ;
hbox_extended ->set_border_width( 5 ); visual_partitions .back() .fraction = p_length / static_cast<double>( length ) ;
hbox_extended ->set_spacing( 5 );
eventbox_extended ->add( *hbox_extended ) ;
for ( unsigned int t = 0 ; t < partition .logicals .size( ) ; t++ ) if ( partitions[ t ] .type == GParted::TYPE_UNALLOCATED || partitions[ t ] .type == GParted::TYPE_EXTENDED )
visual_partitions .back() .fraction_used = -1 ;
else if ( partitions[ t ] .sectors_used > 0 )
visual_partitions .back() .fraction_used = partitions[ t ] .sectors_used / static_cast<double>( p_length ) ;
visual_partitions .back() .color = partitions[ t ] .color;
this ->get_colormap( ) ->alloc_color( visual_partitions .back() .color );
if ( partitions[ t ] .type == GParted::TYPE_EXTENDED )
set_static_data( partitions[ t ] .logicals,
visual_partitions .back() .logicals,
partitions[ t ] .sector_end - partitions[ t ] .sector_start ) ;
else
visual_partitions .back() .pango_layout = drawingarea .create_pango_layout(
partitions[ t ] .partition + "\n" + String::ucompose( _("%1 MB"), partitions[ t ] .Get_Length_MB() ) ) ;
}
}
int VBox_VisualDisk::calc_length( std::vector<visual_partition> & visual_partitions, int length_px )
{
int calced_length = 0 ;
for ( int t = 0 ; t < static_cast<int>( visual_partitions .size() ) ; t++ )
{
visual_partitions[ t ] .length = Utils::Round( length_px * visual_partitions[ t ] .fraction ) ;
if ( visual_partitions[ t ] .logicals .size() > 0 )
{ {
Create_Visual_Partition( partition .logicals[ t ] ) ; int ext_length = calc_length( visual_partitions[ t ] .logicals, visual_partitions[ t ] .length - (2 * BORDER) ) ;
hbox_extended ->pack_start( *( visual_partitions .back( ) ->drawingarea ), Gtk::PACK_SHRINK ) ;
visual_partitions[ t ] .length = ext_length + (2 * BORDER) ;
}
else if ( visual_partitions[ t ] .length < MIN_SIZE )
visual_partitions[ t ] .length = MIN_SIZE ;
calced_length += visual_partitions[ t ] .length ;
}
return calced_length + (visual_partitions .size() - 1) * SEP ;
}
void VBox_VisualDisk::calc_position_and_height( std::vector<visual_partition> & visual_partitions, int start, int border )
{
for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
{
visual_partitions[ t ] .x_start = start ;
visual_partitions[ t ] .y_start = border ;
visual_partitions[ t ] .height = HEIGHT - ( border * 2 ) ;
if ( visual_partitions[ t ] .logicals .size() > 0 )
calc_position_and_height( visual_partitions[ t ] .logicals,
visual_partitions[ t ] .x_start + BORDER,
BORDER ) ;
start += visual_partitions[ t ] .length + SEP ;
}
}
void VBox_VisualDisk::calc_used_unused( std::vector<visual_partition> & visual_partitions )
{
for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
{
if ( visual_partitions[ t ] .fraction_used > -1 )
{
//used
visual_partitions[ t ] .x_used_start = visual_partitions[ t ] .x_start + BORDER ;
if ( visual_partitions[ t ] .fraction_used )
visual_partitions[ t ] .used_length =
Utils::Round( ( visual_partitions[ t ] .length - (2*BORDER) ) * visual_partitions[ t ] .fraction_used ) ;
//unused
visual_partitions[ t ] .x_unused_start = visual_partitions[ t ] .x_used_start + visual_partitions[ t ] .used_length ;
visual_partitions[ t ] .unused_length
= visual_partitions[ t ] .length - (2 * BORDER) - visual_partitions[ t ] .used_length ;
//y position and height
visual_partitions[ t ] .y_used_unused_start = visual_partitions[ t ] .y_start + BORDER ;
visual_partitions[ t ] .used_unused_height = visual_partitions[ t ] .height - (2 * BORDER) ;
} }
return ; if ( visual_partitions[ t ] .logicals .size() > 0 )
calc_used_unused( visual_partitions[ t ] .logicals ) ;
} }
visual_partitions .back( ) ->length = static_cast<int> ( SCREEN_WIDTH / ( device_length / static_cast<double>(partition .sector_end - partition .sector_start) ) );
if ( visual_partitions .back( ) ->length < 20 )//we need a min. size. Otherwise some small partitions wouldn't be visible
visual_partitions .back( ) ->length = ( partition .type == GParted::TYPE_UNALLOCATED ) ? 15 : 20 ;
if ( partition .inside_extended )
{
visual_partitions .back( ) ->height = 34 ;
visual_partitions .back( ) ->text_y = 9 ;
}
else
{
visual_partitions .back( ) ->height = 44 ;
visual_partitions .back( ) ->text_y = 15 ;
}
if ( partition .type == GParted::TYPE_UNALLOCATED )
visual_partitions .back( ) ->used = -1;
else
visual_partitions .back( ) ->used = static_cast<int>( (visual_partitions .back( ) ->length - (BORDER *2)) / ( static_cast<double>(partition .sector_end - partition .sector_start) / partition .sectors_used ) );
visual_partitions.back( ) ->color_fs = partition .color;
this ->get_colormap( ) ->alloc_color( visual_partitions .back( ) ->color_fs );
visual_partitions .back( ) ->drawingarea = manage( new Gtk::DrawingArea( ) ) ;
visual_partitions .back( ) ->drawingarea ->set_size_request( visual_partitions .back( ) ->length +1, 60 );
visual_partitions .back( ) ->drawingarea ->set_events( Gdk::BUTTON_PRESS_MASK );
//connect signal handlers
visual_partitions .back( ) ->drawingarea ->signal_button_press_event( ) .connect( sigc::bind<Partition>(sigc::mem_fun(*this, &VBox_VisualDisk::on_drawingarea_button_press), partition ) );
visual_partitions .back( ) ->drawingarea ->signal_realize( ) .connect( sigc::bind<Visual_Partition *>(sigc::mem_fun(*this, &VBox_VisualDisk::drawingarea_on_realize), visual_partitions .back( ) ) );
visual_partitions .back( ) ->drawingarea ->signal_expose_event( ) .connect( sigc::bind<Visual_Partition *>(sigc::mem_fun(*this, &VBox_VisualDisk::drawingarea_on_expose), visual_partitions .back( ) ));
//create pangolayout and see if it fits in the visual partition
str_temp = partition .partition + "\n" + String::ucompose( _("%1 MB"), partition .Get_Length_MB( ) ) ;
visual_partitions .back( ) ->pango_layout = visual_partitions .back( ) ->drawingarea ->create_pango_layout ( str_temp ) ;
visual_partitions .back( ) ->pango_layout ->get_pixel_size( x, y ) ;
if ( visual_partitions .back( ) ->length - BORDER * 2 -2 < x )
visual_partitions .back( ) ->pango_layout ->set_text( "" ) ;
//tooltip
str_temp = "" ;
if ( partition .type != GParted::TYPE_UNALLOCATED )
str_temp = Utils::Get_Filesystem_String( partition .filesystem ) + "\n" ;
str_temp += partition .partition + "\n" + String::ucompose( _("%1 MB"), partition .Get_Length_MB( ) ) ;
tooltips .set_tip( *( visual_partitions.back( ) ->drawingarea ), str_temp ) ;
} }
void VBox_VisualDisk::Prepare_Legend( std::vector<GParted::FILESYSTEM> & legend, const std::vector<Partition> & partitions ) void VBox_VisualDisk::calc_text( std::vector<visual_partition> & visual_partitions )
{ {
for ( unsigned int t = 0 ; t < partitions .size( ) ; t++ ) int length, height ;
for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
{ {
if ( std::find( legend .begin( ), legend .end( ), partitions[ t ] .filesystem ) == legend .end( ) ) if ( visual_partitions[ t ] .pango_layout )
{
//see if the text fits in the partition... (and if so, center the text..)
visual_partitions[ t ] .pango_layout ->get_pixel_size( length, height ) ;
if ( length < visual_partitions[ t ] .length - (2 * BORDER) - 2 )
{
visual_partitions[ t ] .x_text = visual_partitions[ t ] .x_start +
Utils::Round( (visual_partitions[ t ] .length / 2) - (length / 2) ) ;
visual_partitions[ t ] .y_text = visual_partitions[ t ] .y_start +
Utils::Round( (visual_partitions[ t ] .height / 2) - (height / 2) ) ;
}
else
visual_partitions[ t ] .x_text = visual_partitions[ t ] .y_text = 0 ;
}
if ( visual_partitions[ t ] .logicals .size() > 0 )
calc_text( visual_partitions[ t ] .logicals ) ;
}
}
void VBox_VisualDisk::build_legend( const std::vector<Partition> & partitions )
{
std::vector<GParted::FILESYSTEM> legend ;
prepare_legend( partitions, legend ) ;
frame = manage( new Gtk::Frame() ) ;
hbox_legend .pack_start( *frame, Gtk::PACK_EXPAND_PADDING );
Gtk::HBox * hbox = manage( new Gtk::HBox( false, 15 ) );
hbox ->set_border_width( 3 ) ;
frame ->add( *hbox ) ;
bool hide_used_unused = true;
for ( unsigned int t = 0 ; t < legend .size() ; t++ )
{
hbox ->pack_start( * create_legend_item( legend[ t ] ), Gtk::PACK_SHRINK ) ;
if ( legend[ t ] != GParted::FS_UNALLOCATED && legend[ t ] != GParted::FS_EXTENDED && legend[ t ] != GParted::FS_LINUX_SWAP )
hide_used_unused = false ;
}
if ( ! hide_used_unused )
{
frame = manage( new Gtk::Frame() ) ;
hbox_legend .pack_start( *frame, Gtk::PACK_EXPAND_PADDING );
hbox = manage( new Gtk::HBox( false, 15 ) );
hbox ->set_border_width( 3 ) ;
frame ->add( *hbox ) ;
hbox ->pack_start( * create_legend_item( GParted::FS_USED ), Gtk::PACK_SHRINK ) ;
hbox ->pack_start( * create_legend_item( GParted::FS_UNUSED ), Gtk::PACK_SHRINK ) ;
}
hbox_legend .show_all_children() ;
}
void VBox_VisualDisk::prepare_legend( const std::vector<Partition> & partitions, std::vector<GParted::FILESYSTEM> & legend )
{
for ( unsigned int t = 0 ; t < partitions .size() ; t++ )
{
if ( std::find( legend .begin(), legend .end(), partitions[ t ] .filesystem ) == legend .end() )
legend .push_back( partitions[ t ] .filesystem ); legend .push_back( partitions[ t ] .filesystem );
if ( partitions[ t ] .type == GParted::TYPE_EXTENDED ) if ( partitions[ t ] .type == GParted::TYPE_EXTENDED )
Prepare_Legend( legend, partitions[ t ] .logicals ) ; prepare_legend( partitions[ t ] .logicals, legend ) ;
} }
} }
void VBox_VisualDisk::Build_Legend( ) Gtk::HBox * VBox_VisualDisk::create_legend_item( GParted::FILESYSTEM fs )
{ {
//add the hboxes and frame_legenda Gtk::HBox * hbox = manage( new Gtk::HBox( false, 5 ) ) ;
frame_disk_legend = manage( new Gtk::Frame( ) ) ; hbox ->pack_start( * manage( new Gtk::Image( Utils::get_color_as_pixbuf( fs, 16, 16 ) ) ), Gtk::PACK_SHRINK );
hbox_legend_main .pack_start( *frame_disk_legend, Gtk::PACK_EXPAND_PADDING );
hbox_legend = manage( new Gtk::HBox( ) ); hbox ->pack_start( * Utils::mk_label( Utils::Get_Filesystem_String( fs ) ), Gtk::PACK_SHRINK );
hbox_legend ->set_border_width( 2 ) ;
frame_disk_legend ->add( *hbox_legend ) ;
this ->pack_start( hbox_legend_main );
std::vector<GParted::FILESYSTEM> legend ; return hbox ;
Prepare_Legend( legend, partitions ) ; }
bool hide_used_unused = true; void VBox_VisualDisk::draw_partitions( const std::vector<visual_partition> & visual_partitions )
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK ); {
for ( unsigned int t = 0 ; t < legend .size( ) ; t++ ) for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
{ {
if ( legend[ t ] != GParted::FS_UNALLOCATED && legend[ t ] != GParted::FS_EXTENDED && legend[ t ] != GParted::FS_LINUX_SWAP ) //partition...
hide_used_unused = false ; gc ->set_foreground( visual_partitions[ t ] .color );
drawingarea .get_window() ->draw_rectangle( gc,
true,
visual_partitions[ t ] .x_start,
visual_partitions[ t ] .y_start,
visual_partitions[ t ] .length,
visual_partitions[ t ] .height );
if ( t ) //used..
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK ); if ( visual_partitions[ t ] .used_length > 0 )
{
image = manage( new Gtk::Image( Utils::get_color_as_pixbuf( legend[ t ], 16, 16 ) ) ) ; gc ->set_foreground( color_used );
hbox_legend ->pack_start( *image, Gtk::PACK_SHRINK ); drawingarea .get_window() ->draw_rectangle( gc,
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK ); true,
visual_partitions[ t ] .x_used_start,
hbox_legend ->pack_start( * Utils::mk_label( Utils::Get_Filesystem_String( legend[ t ] ) ), Gtk::PACK_SHRINK ); visual_partitions[ t ] .y_used_unused_start,
} visual_partitions[ t ] .used_length,
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK ); visual_partitions[ t ] .used_unused_height );
}
//if there are any partitions add used/unused
if ( ! hide_used_unused )
{
frame_disk_legend = manage( new Gtk::Frame( ) ) ;
hbox_legend_main .pack_start( *frame_disk_legend, Gtk::PACK_EXPAND_PADDING );
hbox_legend = manage( new Gtk::HBox( ) );
hbox_legend ->set_border_width( 2 ) ;
frame_disk_legend ->add( *hbox_legend );
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK );
//used
image = manage( new Gtk::Image( Utils::get_color_as_pixbuf( GParted::FS_USED, 16, 16 ) ) ) ;
hbox_legend ->pack_start( *image, Gtk::PACK_SHRINK );
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK );
hbox_legend ->pack_start( * Utils::mk_label( Utils::Get_Filesystem_String( GParted::FS_USED ) ), Gtk::PACK_SHRINK );
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK );
//unused //unused
image = manage( new Gtk::Image( Utils::get_color_as_pixbuf( GParted::FS_UNUSED, 16, 16 ) ) ) ; if ( visual_partitions[ t ] .unused_length > 0 )
hbox_legend ->pack_start( *image, Gtk::PACK_SHRINK );
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK );
hbox_legend ->pack_start( * Utils::mk_label( Utils::Get_Filesystem_String( GParted::FS_UNUSED ) ), Gtk::PACK_SHRINK );
hbox_legend ->pack_start( * Utils::mk_label( " " ), Gtk::PACK_SHRINK );
}
}
void VBox_VisualDisk::Set_Selected( const Partition & partition )
{
//clean previously selected one
temp = selected_partition ;
selected_partition = -1;
if ( temp >= 0 ) //prevent segfault at firsttime selection
drawingarea_on_expose( NULL, visual_partitions[ temp ] ) ;
if ( partition.type == GParted::TYPE_EXTENDED )
return; //extended can not be selected in visualdisk (yet )
//now set new selected one
for ( unsigned int t = 0;t < visual_partitions.size() ; t++ )
{
if ( visual_partitions[ t ] ->sector_start == partition .sector_start && visual_partitions[ t ] ->drawingarea != NULL )
{ {
selected_partition = t; gc ->set_foreground( color_unused );
drawingarea_on_expose( NULL, visual_partitions[ t ] ) ; drawingarea .get_window() ->draw_rectangle( gc,
return; true,
visual_partitions[ t ] .x_unused_start,
visual_partitions[ t ] .y_used_unused_start,
visual_partitions[ t ] .unused_length,
visual_partitions[ t ] .used_unused_height );
} }
//text
if ( visual_partitions[ t ] .x_text > 0 )
{
gc ->set_foreground( color_text );
drawingarea .get_window() ->draw_layout( gc,
visual_partitions[ t ] .x_text,
visual_partitions[ t ] .y_text,
visual_partitions[ t ] .pango_layout ) ;
}
//selection rectangle...
if ( visual_partitions[ t ] .selected )
{
gc ->set_foreground( color_used );
//selection start and ends at 4px from the borders, hence the >8 restriction
if ( visual_partitions[ t ] .length > 8 )
drawingarea .get_window() ->draw_rectangle( gc,
false,
visual_partitions[ t ] .x_start +4,
visual_partitions[ t ] .y_start +4,
visual_partitions[ t ] .length -9,
visual_partitions[ t ] .height -9 );
else
drawingarea .get_window() ->draw_rectangle( gc,
true,
visual_partitions[ t ] .x_start,
visual_partitions[ t ] .y_start +9,
visual_partitions[ t ] .length,
visual_partitions[ t ] .height -19 );
}
if ( visual_partitions[ t ] .logicals .size() > 0 )
draw_partitions( visual_partitions[ t ] .logicals ) ;
} }
} }
void VBox_VisualDisk::drawingarea_on_realize( Visual_Partition* vp ) bool VBox_VisualDisk::set_selected( std::vector<visual_partition> & visual_partitions, int x, int y )
{ {
vp ->gc = Gdk::GC::create( vp ->drawingarea ->get_window( ) ); bool found = false ;
vp ->drawingarea ->get_window( ) ->set_background( vp ->color_fs ); for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
//eventmasks necessary for tooltips
vp ->drawingarea ->add_events( Gdk::ENTER_NOTIFY_MASK );
vp ->drawingarea ->add_events( Gdk::LEAVE_NOTIFY_MASK );
}
bool VBox_VisualDisk::drawingarea_on_expose( GdkEventExpose * ev, Visual_Partition* vp )
{
vp ->drawingarea ->get_window( ) ->clear( ) ;
if ( vp ->used != -1 ) //if not unknown or unallocated
{ {
vp ->gc ->set_foreground( color_used ); if ( visual_partitions[ t ] .x_start <= x && x < visual_partitions[ t ] .x_start + visual_partitions[ t ] .length &&
vp ->drawingarea ->get_window( ) ->draw_rectangle( vp ->gc, true, BORDER, BORDER, vp ->used, vp ->height ); visual_partitions[ t ] .y_start <= y && y < visual_partitions[ t ] .y_start + visual_partitions[ t ] .height )
{
visual_partitions[ t ] .selected = true ;
selected_vp = visual_partitions[ t ] ;
found = true ;
}
else
visual_partitions[ t ] .selected = false ;
if ( visual_partitions[ t ] .logicals .size() > 0 )
visual_partitions[ t ] .selected &= ! set_selected( visual_partitions[ t ] .logicals, x, y ) ;
vp ->gc ->set_foreground( color_unused );
vp ->drawingarea ->get_window( ) ->draw_rectangle( vp ->gc, true, BORDER + vp ->used, BORDER, vp ->length - vp ->used - BORDER *2 , vp ->height );
} }
vp ->gc ->set_foreground( color_text ); return found ;
vp ->drawingarea ->get_window( ) ->draw_layout( vp ->gc, BORDER +2, vp ->text_y, vp ->pango_layout ) ;
//if partition is selected one..
if ( vp ->index == selected_partition )
{
vp ->gc ->set_foreground( color_used );
vp ->drawingarea ->get_window( ) ->draw_rectangle( vp ->gc, false, 4, 4, vp ->length -8, vp ->height +8 );
}
return true;
} }
bool VBox_VisualDisk::on_drawingarea_button_press( GdkEventButton *event, const Partition & partition ) void VBox_VisualDisk::set_selected( std::vector<visual_partition> & visual_partitions, const Partition & partition )
{ {
signal_mouse_click .emit( event, partition ); for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
return true; {
if ( visual_partitions[ t ] .partition == partition )
{
visual_partitions[ t ] .selected = true ;
selected_vp = visual_partitions[ t ] ;
}
else
visual_partitions[ t ] .selected = false ;
if ( visual_partitions[ t ] .logicals .size() > 0 )
set_selected( visual_partitions[ t ] .logicals, partition ) ;
}
} }
VBox_VisualDisk::~VBox_VisualDisk( ) void VBox_VisualDisk::drawingarea_on_realize()
{ {
for ( unsigned int t = 0 ; t < visual_partitions .size( ) ; t++ ) gc = Gdk::GC::create( drawingarea .get_window() );
{
this ->get_colormap( ) ->free_colors( visual_partitions[ t ] ->color_fs, 1 ) ;
delete visual_partitions[ t ] ;
}
visual_partitions .clear( ) ; //connect here to prevent premature signalling (only relevant at startup)
drawingarea .signal_size_allocate() .connect( sigc::mem_fun( *this, &VBox_VisualDisk::on_resize ) ) ;
}
bool VBox_VisualDisk::drawingarea_on_expose( GdkEventExpose * event )
{
draw_partitions( visual_partitions ) ;
return true ;
}
bool VBox_VisualDisk::on_drawingarea_button_press( GdkEventButton * event )
{
if ( set_selected( visual_partitions, static_cast<int>( event ->x ), static_cast<int>( event ->y ) ) )
signal_mouse_click .emit( event, selected_vp .partition );
return true ;
}
void VBox_VisualDisk::on_resize( Gtk::Allocation & allocation )
{
MIN_SIZE = 20 ;
int calced, TOTAL ;
do
{
TOTAL = allocation .get_width() - TOT_SEP ;
calced = allocation .get_width() ; //for first time :)
do
{
TOTAL -= ( calced - allocation .get_width() ) ;
calced = calc_length( visual_partitions, TOTAL ) ;
}
while ( calced > allocation .get_width() && TOTAL > 0 ) ;
MIN_SIZE-- ;
}
while ( TOTAL <= 0 && MIN_SIZE > 0 ) ;
calc_position_and_height( visual_partitions, 0, 0 ) ;
calc_used_unused( visual_partitions ) ;
calc_text( visual_partitions ) ;
}
void VBox_VisualDisk::free_colors( std::vector<visual_partition> & visual_partitions )
{
for ( unsigned int t = 0 ; t < visual_partitions .size() ; t++ )
{
this ->get_colormap( ) ->free_color( visual_partitions[ t ] .color ) ;
if ( visual_partitions[ t ] .logicals .size() > 0 )
free_colors( visual_partitions[ t ] .logicals ) ;
}
}
VBox_VisualDisk::~VBox_VisualDisk()
{
clear() ;
//free the allocated colors //free the allocated colors
this ->get_colormap( ) ->free_colors( color_used, 1 ) ; this ->get_colormap( ) ->free_colors( color_used, 1 ) ;

111
src/Win_GParted.cc
View File

@ -28,7 +28,6 @@ Win_GParted::Win_GParted( )
selected_partition .Reset( ) ; selected_partition .Reset( ) ;
new_count = 1; new_count = 1;
current_device = 0 ; current_device = 0 ;
vbox_visual_disk = NULL;
pulse = false ; pulse = false ;
//==== GUI ========================= //==== GUI =========================
@ -50,8 +49,9 @@ Win_GParted::Win_GParted( )
init_toolbar( ) ; init_toolbar( ) ;
vbox_main.pack_start( hbox_toolbar, Gtk::PACK_SHRINK ); vbox_main.pack_start( hbox_toolbar, Gtk::PACK_SHRINK );
//hbox_visual... ( contains the visual represenation of the disks ) //vbox_visual_disk... ( contains the visual represenation of the disks )
vbox_main.pack_start( hbox_visual, Gtk::PACK_SHRINK ); vbox_visual_disk .signal_mouse_click.connect( sigc::mem_fun( this, &Win_GParted::mouse_click ) ) ;
vbox_main .pack_start( vbox_visual_disk, Gtk::PACK_SHRINK ) ;
//hpaned_main (NOTE: added to vpaned_main) //hpaned_main (NOTE: added to vpaned_main)
init_hpaned_main( ) ; init_hpaned_main( ) ;
@ -459,41 +459,45 @@ void Win_GParted::Add_Operation( OperationType operationtype, const Partition &
void Win_GParted::Refresh_Visual( ) void Win_GParted::Refresh_Visual( )
{ {
std::vector<Partition> partitions = devices[ current_device ] .device_partitions ; std::vector<Partition> partitions = devices[ current_device ] .device_partitions ;
liststore_operations ->clear( ); liststore_operations ->clear();
//make all operations visible //make all operations visible
for ( unsigned int t = 0 ; t < operations .size( ); t++ ) for ( unsigned int t = 0 ; t < operations .size(); t++ )
{ {
if ( operations[ t ] .device .path == devices[ current_device ] .path ) if ( operations[ t ] .device .path == devices[ current_device ] .path )
operations[ t ] .Apply_Operation_To_Visual( partitions ) ; operations[ t ] .Apply_Operation_To_Visual( partitions ) ;
treerow = *( liststore_operations ->append( ) ); treerow = *( liststore_operations ->append() );
treerow[ treeview_operations_columns .operation_number ] = t +1; treerow[ treeview_operations_columns .operation_number ] = t +1;
treerow[ treeview_operations_columns .operation_description ] = operations[ t ] .str_operation ; treerow[ treeview_operations_columns .operation_description ] = operations[ t ] .str_operation ;
switch ( operations[ t ] .operationtype ) switch ( operations[ t ] .operationtype )
{ {
case GParted::DELETE : treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::DELETE, Gtk::ICON_SIZE_MENU); case GParted::DELETE :
break; treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::DELETE, Gtk::ICON_SIZE_MENU);
case GParted::CREATE : treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::NEW, Gtk::ICON_SIZE_MENU); break;
break; case GParted::CREATE :
case GParted::RESIZE_MOVE: treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_MENU); treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::NEW, Gtk::ICON_SIZE_MENU);
break; break;
case GParted::CONVERT : treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::CONVERT, Gtk::ICON_SIZE_MENU); case GParted::RESIZE_MOVE:
break; treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_MENU);
case GParted::COPY : treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::COPY, Gtk::ICON_SIZE_MENU); break;
break; case GParted::CONVERT :
treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::CONVERT, Gtk::ICON_SIZE_MENU);
break;
case GParted::COPY :
treerow[ treeview_operations_columns.operation_icon ] =render_icon(Gtk::Stock::COPY, Gtk::ICON_SIZE_MENU);
break;
} }
} }
//set new statusbartext //set new statusbartext
statusbar .pop( ) ; statusbar .pop() ;
if ( operations .size( ) != 1 ) if ( operations .size() != 1 )
statusbar .push( String::ucompose( _("%1 operations pending"), operations .size( ) ) ); statusbar .push( String::ucompose( _("%1 operations pending"), operations .size() ) );
else else
statusbar .push( _( "1 operation pending" ) ); statusbar .push( _( "1 operation pending" ) );
if ( ! operations .size( ) ) if ( ! operations .size() )
{ {
allow_undo( false ); allow_undo( false );
allow_apply( false ); allow_apply( false );
@ -502,7 +506,7 @@ void Win_GParted::Refresh_Visual( )
//count primary's, check for extended and logic and see if any logical is busy //count primary's, check for extended and logic and see if any logical is busy
any_logic = any_extended = false; any_logic = any_extended = false;
primary_count = 0; primary_count = 0;
for ( unsigned int t = 0 ; t < partitions .size( ) ; t++ ) for ( unsigned int t = 0 ; t < partitions .size() ; t++ )
{ {
if ( partitions[ t ] .partition == copied_partition .partition ) if ( partitions[ t ] .partition == copied_partition .partition )
copied_partition = partitions[ t ] ; copied_partition = partitions[ t ] ;
@ -516,7 +520,7 @@ void Win_GParted::Refresh_Visual( )
case GParted::TYPE_EXTENDED : case GParted::TYPE_EXTENDED :
any_extended = true; any_extended = true;
primary_count++; primary_count++;
any_logic = partitions[ t ] .logicals .size( ) -1 ; any_logic = partitions[ t ] .logicals .size() -1 ;
break; break;
default : default :
@ -525,33 +529,24 @@ void Win_GParted::Refresh_Visual( )
} }
//vbox visual //vbox visual
if ( vbox_visual_disk != NULL ) vbox_visual_disk .load_partitions( partitions, devices[ current_device ] .length ) ;
{
hbox_visual .remove( *vbox_visual_disk );
delete ( vbox_visual_disk );
}
vbox_visual_disk = new VBox_VisualDisk ( partitions, devices[ current_device ] .length ) ;
vbox_visual_disk ->signal_mouse_click.connect( sigc::mem_fun( this, &Win_GParted::mouse_click ) ) ;
hbox_visual .pack_start( *vbox_visual_disk, Gtk::PACK_EXPAND_PADDING ) ;
hbox_visual .show_all_children( ) ;
//treeview details //treeview details
treeview_detail .Load_Partitions( partitions ) ; treeview_detail .Load_Partitions( partitions ) ;
//no partition can be selected after a refresh.. //no partition can be selected after a refresh..
selected_partition .Reset( ) ; selected_partition .Reset() ;
Set_Valid_Operations( ) ; Set_Valid_Operations() ;
} }
bool Win_GParted::Quit_Check_Operations( ) bool Win_GParted::Quit_Check_Operations( )
{ {
if ( operations .size( ) ) if ( operations .size() )
{ {
str_temp = "<span weight=\"bold\" size=\"larger\">" + (Glib::ustring) _( "Quit GParted?" ) + "</span>\n\n" ; str_temp = "<span weight=\"bold\" size=\"larger\">" + (Glib::ustring) _( "Quit GParted?" ) + "</span>\n\n" ;
if ( operations .size( ) != 1 ) if ( operations .size() != 1 )
str_temp += String::ucompose( _("%1 operations are currently pending."), operations .size( ) ) ; str_temp += String::ucompose( _("%1 operations are currently pending."), operations .size() ) ;
else else
str_temp += _("1 operation is currently pending."); str_temp += _("1 operation is currently pending.");
@ -559,7 +554,7 @@ bool Win_GParted::Quit_Check_Operations( )
dialog .add_button( Gtk::Stock::QUIT, Gtk::RESPONSE_CLOSE ); dialog .add_button( Gtk::Stock::QUIT, Gtk::RESPONSE_CLOSE );
dialog .add_button( Gtk::Stock::CANCEL,Gtk::RESPONSE_CANCEL ); dialog .add_button( Gtk::Stock::CANCEL,Gtk::RESPONSE_CANCEL );
if ( dialog .run( ) == Gtk::RESPONSE_CANCEL ) if ( dialog .run() == Gtk::RESPONSE_CANCEL )
return false;//don't close GParted return false;//don't close GParted
} }
@ -703,20 +698,19 @@ void Win_GParted::menu_gparted_refresh_devices( )
pulse = true ;//set to true before creating the thread to prevent _possible_ infinite loop in Show_Pulsebar( ) pulse = true ;//set to true before creating the thread to prevent _possible_ infinite loop in Show_Pulsebar( )
thread = Glib::Thread::create( SigC::slot_class( *this, &Win_GParted::find_devices_thread ), true ); thread = Glib::Thread::create( SigC::slot_class( *this, &Win_GParted::find_devices_thread ), true );
Show_Pulsebar( ) ; Show_Pulsebar() ;
//check if current_device is still available (think about hotpluggable shit like usbdevices) //check if current_device is still available (think about hotpluggable shit like usbdevices)
if ( current_device >= devices .size( ) ) if ( current_device >= devices .size() )
current_device = 0 ; current_device = 0 ;
//show read-only warning if necessary //show read-only warning if necessary
Glib::ustring readonly_paths ; Glib::ustring readonly_paths ;
for ( unsigned int t = 0 ; t < devices .size( ) ; t++ ) for ( unsigned int t = 0 ; t < devices .size() ; t++ )
if ( devices[ t ] .readonly ) if ( devices[ t ] .readonly )
readonly_paths += "\n- " + devices[ t ] .path ; readonly_paths += "\n- " + devices[ t ] .path ;
if ( ! readonly_paths .empty( ) ) if ( ! readonly_paths .empty() )
{ {
str_temp = "<span weight=\"bold\" size=\"larger\">" ; str_temp = "<span weight=\"bold\" size=\"larger\">" ;
str_temp += _("The kernel is unable to re-read the partitiontables on the following devices:") ; str_temp += _("The kernel is unable to re-read the partitiontables on the following devices:") ;
@ -744,32 +738,28 @@ void Win_GParted::menu_gparted_refresh_devices( )
} }
//if no devices were detected we disable some stuff and show a message in the statusbar //if no devices were detected we disable some stuff and show a message in the statusbar
if ( devices .empty( ) ) if ( devices .empty() )
{ {
optionmenu_devices .hide( ) ; optionmenu_devices .hide() ;
menubar_main .items( )[ 2 ] .set_sensitive( false ) ; menubar_main .items()[ 1 ] .set_sensitive( false ) ;
menubar_main .items( )[ 3 ] .set_sensitive( false ) ; menubar_main .items()[ 2 ] .set_sensitive( false ) ;
menubar_main .items()[ 3 ] .set_sensitive( false ) ;
menubar_main .items()[ 4 ] .set_sensitive( false ) ;
toolbar_main .set_sensitive( false ) ; toolbar_main .set_sensitive( false ) ;
optionmenu_devices .set_sensitive( false ) ; optionmenu_devices .set_sensitive( false ) ;
Fill_Label_Device_Info( true ) ; Fill_Label_Device_Info( true ) ;
if ( vbox_visual_disk != NULL ) vbox_visual_disk .clear() ;
{ treeview_detail .Clear() ;
hbox_visual .remove( *vbox_visual_disk );
delete( vbox_visual_disk ) ;
vbox_visual_disk = NULL ;
}
treeview_detail .Clear( ) ;
//hmzz, this is really paranoid, but i think it's the right thing to do ;) //hmzz, this is really paranoid, but i think it's the right thing to do ;)
liststore_operations ->clear( ) ; liststore_operations ->clear( ) ;
close_operationslist( ) ; close_operationslist() ;
operations .clear( ) ; operations .clear() ;
statusbar .pop( ) ; statusbar .pop() ;
statusbar .push( _( "No devices detected" ) ); statusbar .push( _( "No devices detected" ) );
} }
@ -886,7 +876,8 @@ void Win_GParted::mouse_click( GdkEventButton *event, const Partition & partitio
Set_Valid_Operations( ) ; Set_Valid_Operations( ) ;
treeview_detail .Set_Selected( partition ); treeview_detail .Set_Selected( partition );
vbox_visual_disk ->Set_Selected( partition );
vbox_visual_disk .set_selected( partition ) ;
if ( event ->type == GDK_2BUTTON_PRESS && ! pulse ) if ( event ->type == GDK_2BUTTON_PRESS && ! pulse )
activate_info( ) ; activate_info( ) ;