/*******************************************************************
 * 
 * Copyright (C) 2013 Kevin Reverchon
 * This file/program is part of gZFS free software
 * See COPYING file for details
 * 
 *******************************************************************/



package gZFS;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.Hashtable;
import java.util.List;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.eclipse.jface.layout.TreeColumnLayout;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.ExpandBar;
import org.eclipse.swt.widgets.ExpandItem;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.ProgressBar;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.wb.swt.SWTResourceManager;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.PieDataset;
import org.jfree. experimental.chart.swt.ChartComposite;

import com.ibm.icu.math.BigDecimal;

public class gui {

	private Logger log = Logger.getLogger(getClass().getPackage().getName()+" "+getClass().getCanonicalName());
	private Composite compositeConfig;
	private Composite compositeZpoolConfig;
	private Composite compositeTabVolConfig;
	private Composite compositeCreateVolFS;
	private Composite compositeIscsi;
	private Composite compositeSnapshot;
	private Composite compositeReplica;
	private Composite compositeWidgetCreateVolFS;
	private Composite compositeWidgetDisks;
	private Composite compositeDisks;


	private Group groupCreateVolFS;
	private Group groupActiveIscsi;
	private Group groupDisks;
	private ScrolledComposite scrolledCreateVol;
	private ScrolledComposite scrolledDisks;
	private ChartComposite chartVolumeComposite = null;
	private ChartComposite chartZpoolProvionedComposite = null;
	private ChartComposite chartZpoolUsedComposite = null;
	private GridData gridDataChart;

	protected Shell shell;
	private zfs zfs = new zfs();
	private zfs zsnap = new zfs();
	private guiTrt guiTrt = new guiTrt();
	private Hashtable<String,Float> dataCharset = new Hashtable<String, Float>();

	private List<Object> zfsList;
	private String keyProp;
	private List<Label> labelsField= new ArrayList<Label>();
	private List<Text> textsField= new ArrayList<Text>();
	private List<Combo> combosField= new ArrayList<Combo>();

	private List<Label> labelsFieldServer= new ArrayList<Label>();
	private List<Text> textsFieldServer= new ArrayList<Text>();
	private List<Combo> combosFieldServer= new ArrayList<Combo>();

	private List<Label> labelsFieldPool= new ArrayList<Label>();
	private List<Text> textsFieldPool = new ArrayList<Text>();
	private List<Combo> combosFieldPool = new ArrayList<Combo>();

	private Combo comboType4CreateVolFS ;
	private Combo comboZpool4CreateVolFS;

	private List<Label> labelsFieldCreateVol= new ArrayList<Label>();
	private List<Text> textsFieldCreateVol = new ArrayList<Text>();
	private List<Combo> combosFieldCreateVol = new ArrayList<Combo>();

	private List<Label> labelsFieldCreateIscsi= new ArrayList<Label>();
	private List<Text> textsFieldCreateIscsi = new ArrayList<Text>();
	private List<Combo> combosFieldCreateIscsi = new ArrayList<Combo>();

	private List<Label> labelsFieldAddIscsi= new ArrayList<Label>();
	private List<Text> textsFieldAddIscsi = new ArrayList<Text>();
	private List<Combo> combosFieldAddIscsi = new ArrayList<Combo>();
	private List<TableColumn> tablecolumnsFieldAddIscsi = new ArrayList<TableColumn>();
	private Table tableIscsiSession;


	private List<Label> labelsFieldSnapshots= new ArrayList<Label>();
	private List<Text> textsFieldSnapshots = new ArrayList<Text>();
	private List<Label> labelsFieldSnapshotsValue= new ArrayList<Label>();
	private List< org.eclipse.swt.widgets.List > listsFieldSnaphots = new ArrayList<org.eclipse.swt.widgets.List >();


	private List<Label> labelsFieldReplica= new ArrayList<Label>();
	private List<Text> textsFieldReplica = new ArrayList<Text>();
	private List<Label> labelsFieldReplicaValue= new ArrayList<Label>();
	private List< org.eclipse.swt.widgets.List > listsFieldReplica = new ArrayList<org.eclipse.swt.widgets.List >();
	private List<Combo> combosFieldReplica = new ArrayList<Combo>();

	private List<Label> labelsFieldZRaid= new ArrayList<Label>();
	private List<Label> labelsFieldDisks= new ArrayList<Label>();

	private Image imageStorage= SWTResourceManager.getImage(gui.class, "/images/storage-32px.png");
	private Image imageServerOnline = SWTResourceManager.getImage(gui.class, "/images/enable-server-icon-32px.png");
	private Image imageServerOffline = SWTResourceManager.getImage(gui.class, "/images/off-server-32px.png");
	private Image imageStorageOnline = SWTResourceManager.getImage(gui.class, "/images/storage-32px.png");
	private Image imageStorageOffline = SWTResourceManager.getImage(gui.class, "/images/storage-offline-32px.png");
	private Image imageFSOnline = SWTResourceManager.getImage(gui.class, "/images/zfs-fs-online-32px.png");
	private Image imageFSOffline = SWTResourceManager.getImage(gui.class, "/images/zfs-fs-offline-32px.png");
	private Image imageStorageServer = SWTResourceManager.getImage(gui.class, "/images/storage-server-32px.png");
	private Image imageSnapshotOnline = SWTResourceManager.getImage(gui.class, "/images/snapshot-32px.png");
	private Image imageSnapshotOffline = SWTResourceManager.getImage(gui.class, "/images/snapshot-offline-32px.png");
	private Image imageHardDisk = SWTResourceManager.getImage(gui.class, "/images/hard-disk-72px.png");
	private Image imageHardDiskOffline = SWTResourceManager.getImage(gui.class, "/images/hard-disk-offline-72px.png");
	private Image imageHardDiskOnline = SWTResourceManager.getImage(gui.class, "/images/hard-disk-online-72px.png");

	private Color labelTitleBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_TITLE_BACKGROUND_GRADIENT);
	private Color labelFieldBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_WHITE);
	private Color textFieldBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_WHITE);
	private Color groupBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_WHITE);
	private Color compositeBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_WHITE);
	private Color tabFolderBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_TITLE_BACKGROUND_GRADIENT);
	private Color tabFolderForegroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_BLACK);

	private Tree tree;
	private Tree treeZpool;
	private Tree treeSnapshots;
	private TabFolder tabFolderNav;
	private TabFolder tabFolderConfig;
	private TabItem tbtmConfig;
	private TabItem tbtmZpoolConfig;
	private TabItem tbtmSettings;
	private TabItem tbtmCreateVolFS;
	private TabItem tbtmIscsi;
	private TabItem tbtmSnapshot;
	private TabItem tbtmReplica;
	private TabItem tbtmDisks;

	private Font fontTitle ;
	private Font fontSubTitle ;
	private Font fontWidget;
	private List<Object> zpoolList;
	private Button btnConnectServer;
	private Button btnCreateZfsVolFS;
	private Thread thrConnect;
	private Thread thrCheck;
	private Thread thrCreateZFSVol;
	private Thread thrZpool;
	private Thread thrGetallZvol;
	private Thread thrZfsList;
	private guiProgress wPB;


	private String strItemServer ="";
	private String strItemZvolFS ="";
	private int countItem=0;
	private String infoUsedSize="";


	Menu treeZFSMenu;

	/**
	 * Launch the application.
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			gui window = new gui();
			window.open();

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Open the window.
	 */
	public void open() {
		log.setLevel((Level) Level.DEBUG);
		Display display = Display.getDefault();

		createContents(shell);

		shell.open();
		shell.layout();
		wPB = new guiProgress(shell.getDisplay(), shell.getLocation().x, shell.getLocation().y);
		shell.addListener(SWT.Close, new Listener() {
			public void handleEvent(final Event event) {
				zfs.disconnectAllServer();
			}
		});
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch()) {

				display.sleep();	
			}
		}
	}

	/**
	 * Create contents of the window.
	 */
	protected void createContents(Composite parent) {
		shell = new Shell();
		shell.setSize(SWT.MAX, SWT.MAX);
		shell.setText("gZFS : a GUI for ZFS");
		//shell.layout();
		shell.setLayout(new FillLayout(SWT.HORIZONTAL));

		fontTitle = new Font(shell.getDisplay(), "Calibri", 14, SWT.BOLD);
		fontSubTitle = new Font(shell.getDisplay(), "Calibri", 10, SWT.BOLD);
		fontWidget = new Font(shell.getDisplay(), "Calibri", 10, SWT.NONE);
		tabFolderNav = new TabFolder(shell, SWT.UP);
		tabFolderNav.setBounds(0, 0, 200, 200);
		tabFolderNav.setBackground(tabFolderBackgroundColor);
		tabFolderNav.setForeground(tabFolderForegroundColor);

		/******************************************************************************
		 * CREATE TAB : GENERAL
		 ******************************************************************************/

		TabItem tbtmGen = new TabItem(tabFolderNav, SWT.NONE);
		//tbtmGen.setImage(SWTResourceManager.getImage(gui.class, "/images/accept-database-icon.png"));
		tbtmGen.setText("General");


		Composite compositeTabNavGen = new Composite(tabFolderNav, SWT.NONE);
		tbtmGen.setControl(compositeTabNavGen);
		GridLayout gridLayout = new GridLayout();
		compositeTabNavGen.setLayout(gridLayout);
		compositeTabNavGen.setBackground(tabFolderBackgroundColor);

		treeZpool = new Tree(compositeTabNavGen, SWT.BORDER|SWT.V_SCROLL);
		GridData gd_treeZpool = new GridData(GridData.FILL,GridData.FILL, true, true);
		gd_treeZpool.heightHint = 50;
		treeZpool.setLayoutData(gd_treeZpool);
		treeZpool.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {
				//log.debug(treeZpool.getSelection()[0].getText());
				TreeItem root = (TreeItem) event.item;

				if ( root.getParentItem() != null){
					zfs.getServer(root.getParentItem().getData().toString());
					zfs.zpoolGetAll(root.getData().toString());
					refreshInfoZpool();
					refreshDisks();

				}else{
					zfs.getServer(root.getData().toString());
					refreshInfoServer();

				}
			}
		}
				);
		//Init Server List in Tree
		refreshTreeZpoolList();

		Group groupServerConfig= new Group(compositeTabNavGen,SWT.NONE);
		groupServerConfig.setBackground(groupBackgroundColor);
		groupServerConfig.setLayout(new GridLayout());
		GridData gridDataServerConfig=new GridData(GridData.FILL_HORIZONTAL);
		gridDataServerConfig.heightHint=500;
		gridDataServerConfig.minimumHeight=500;
		groupServerConfig.setLayoutData(gridDataServerConfig);

		ScrolledComposite scrolledServerConfig=new ScrolledComposite(groupServerConfig,SWT.V_SCROLL);
		scrolledServerConfig.setLayoutData(new GridData(GridData.FILL_BOTH));
		Composite compositeWidget=new Composite(scrolledServerConfig,SWT.NONE);
		compositeWidget.setBackground(compositeBackgroundColor);
		GridLayout gridLayoutWidget = new GridLayout();
		gridLayoutWidget.numColumns =2;
		compositeWidget.setLayout(gridLayoutWidget);


		GridData gridDataTitleServerConfig = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitleServerConfig.horizontalSpan = 2;
		Label lblTitleServerConfig = new Label(compositeWidget, SWT.CENTER|SWT.BORDER);
		lblTitleServerConfig.setLayoutData(gridDataTitleServerConfig);
		lblTitleServerConfig.setFont(fontTitle);
		lblTitleServerConfig.setBackground(labelTitleBackgroundColor);
		lblTitleServerConfig.setText("Server Configuration");


		String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);
		labelsFieldServer.clear();
		textsFieldServer.clear();	
		combosFieldServer.clear();
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];



			if ( "freeentry".equalsIgnoreCase(zfs.getZserver().zProperties.get(keyProp).getType())){
				Label lbl = new Label(compositeWidget, SWT.NONE);
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zfs.getZserver().zProperties.get(keyProp).getLabelProperty());
				if (keyProp.equals("userPasswd")){
					textsFieldServer.add(new Text(compositeWidget,  SWT.PASSWORD | SWT.BORDER));
				}else{
					textsFieldServer.add(new Text(compositeWidget, SWT.WRAP|SWT.BORDER));	

				}

				textsFieldServer.get(textsFieldServer.size()-1).setBackground(textFieldBackgroundColor);
				textsFieldServer.get(textsFieldServer.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				//textsField.get(textsField.size()-1).setText(zfs.getZserver().zProperties.get(keyProp).getNameProperty());
				textsFieldServer.get(textsFieldServer.size()-1).setData(zfs.getZserver().zProperties.get(keyProp).getNameProperty());

			}else{

				if ( "nofreeentry".equalsIgnoreCase(zfs.getZserver().zProperties.get(keyProp).getType())){
					Label lbl = new Label(compositeWidget, SWT.NONE);
					lbl.setFont(fontWidget);
					lbl.setBackground(labelFieldBackgroundColor);
					lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					lbl.setText(zfs.getZserver().zProperties.get(keyProp).getLabelProperty());

					combosFieldServer.add(new Combo(compositeWidget, SWT.NONE));
					combosFieldServer.get(combosFieldServer.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					combosFieldServer.get(combosFieldServer.size()-1).setData(zfs.getZserver().zProperties.get(keyProp).getNameProperty());
					//combosField.get(combosField.size()-1).setText(zfs.getZserver().zProperties.get(keyProp).getValue());
					String[] keysPermitValue = (String[]) zfs.getZserver().zProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
					for (int cpt=0;cpt <zfs.getZserver().zProperties.get(keyProp).getPermitValue().size();cpt++){
						String keyPermiValue = keysPermitValue[cpt];
						combosFieldServer.get(combosFieldServer.size()-1).add(zfs.getZserver().zProperties.get(keyProp).getPermitValue().get(keyPermiValue).toString());
					}
				}
			}

		}

		Button btnAddServer = new Button(compositeWidget, SWT.NONE);
		btnAddServer.setText("Add ZFS Server");
		btnAddServer.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {

				String[] keysProp = zfs.getZserver().zProperties.keySet().toArray(new String[0]);
				//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
				Arrays.sort(keysProp);

				for (int i = 0; i < keysProp.length; i++) {
					keyProp = keysProp[i];
					for (int cpt=0;cpt<textsFieldServer.size();cpt++){
						if (keyProp.equalsIgnoreCase(textsFieldServer.get(cpt).getData().toString())) {
							log.debug(keyProp+" "+textsFieldServer.get(cpt).getText());
							if (keyProp.equals("userPasswd")){
								zfs.getZserver().zProperties.get(keyProp).setValue("");
							}else{
								zfs.getZserver().zProperties.get(keyProp).setValue(textsFieldServer.get(cpt).getText());	
							}

						}
					}
				}
				zfs.addServer();

				boolean checkExistInTree=false;
				for (int ind=0;ind<treeZpool.getItemCount();ind++){
					log.debug("refreshTreeZpoolList "+treeZpool.getItem(ind).getData().toString()+" "+zfs.getZserver().zProperties.get("serverIP").getValue());
					if ( treeZpool.getItem(ind).getData().toString().equalsIgnoreCase(zfs.getZserver().zProperties.get("serverIP").getValue())){
						checkExistInTree=true;
					}
				}
				if ( ! checkExistInTree ){
					TreeItem rootTreeZvolFS = new TreeItem(treeZpool,SWT.None);
					rootTreeZvolFS.setText(zfs.getZserver().zProperties.get("serverIP").getValue());
					rootTreeZvolFS.setData(zfs.getZserver().zProperties.get("serverIP").getValue());
					rootTreeZvolFS.setImage(imageServerOffline);
				}
			}	
		});

		Button btnRemoveServer = new Button(compositeWidget, SWT.NONE);
		btnRemoveServer.setText("Remove ZFS Server");
		btnRemoveServer.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {
				if ( treeZpool.getParentItem() == null){
					if ( treeZpool.getSelectionCount() !=0){

						zfs.getZserver().zProperties.get("serverIP").setValue(treeZpool.getSelection()[0].getData().toString());
						for (int cptTree=0;cptTree<tree.getItemCount();cptTree++){
							if (tree.getItem(cptTree).getData().equals(zfs.getZserver().zProperties.get("serverIP").getValue())){
								tree.getItem(cptTree).removeAll();
								tree.getItem(cptTree).dispose();
							}
						}
						zfs.removeServer();		
						treeZpool.getSelection()[0].dispose();

					}
				}

			}
		});

		btnConnectServer = new Button(compositeWidget,SWT.NONE);
		GridData gridDataBtnServerConfig = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataBtnServerConfig.horizontalSpan = 2;
		btnConnectServer.setLayoutData(gridDataBtnServerConfig);
		btnConnectServer.setText("Connect");
		btnConnectServer.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {



				if (treeZpool.getSelectionCount() !=0 ){
					final TreeItem root = (TreeItem) treeZpool.getSelection()[0];
					if ( root.getParentItem() ==null ){

						String[] keysProp = zfs.getZserver().zProperties.keySet().toArray(new String[0]);
						//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
						Arrays.sort(keysProp);

						for (int i = 0; i < keysProp.length; i++) {
							keyProp = keysProp[i];
							for (int cpt=0;cpt<textsFieldServer.size();cpt++){
								if (keyProp.equalsIgnoreCase(textsFieldServer.get(cpt).getData().toString())) {
									zfs.getZserver().zProperties.get(keyProp).setValue(textsFieldServer.get(cpt).getText());
								}
							}
						}
						if ( !zfs.getCacheSession().containsKey(zfs.getZserver().zProperties.get("serverIP").getValue()) && zfs.connectServer(zfs.getZserver().zProperties.get("serverIP").getValue(), 22, zfs.getZserver().zProperties.get("userLogin").getValue(), zfs.getZserver().zProperties.get("userPasswd").getValue())){

							thrCheck = new Thread(new Runnable(){
								public void run() {
									Display.getDefault().syncExec(new Runnable() {
										public void run() {
											if (wPB.s.isDisposed()){
												wPB = new guiProgress(shell.getDisplay(), shell.getLocation().x, shell.getLocation().y);
												wPB.open();
											}else{
												wPB.open();
											}
											btnConnectServer.setEnabled(false);
											tabFolderNav.setEnabled(false);
											refreshDisks();
										}
									});
									zfs.checkBinEnv();
									Display.getDefault().syncExec(new Runnable(){
										public void run(){
											log.debug(zfs.getError());

											log.debug(zfs.getZserver().zProperties.get("serverIP").getValue()+" connected");
											if ( zfs.getError().size() ==0){
												zsnap = zfs;

												refreshTreeZpoolList();


											}else{
												String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);
												//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
												Arrays.sort(keysPropError);
												String textBox = "";
												for (int i = 0; i < keysPropError.length; i++) {
													String keyPropError = keysPropError[i];
													textBox = textBox +zfs.getError().get(keyPropError)+".\n";
												}

												MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
												messageBoxInfo.setText("Warning");
												messageBoxInfo.setMessage(textBox);
												messageBoxInfo.open();
												btnConnectServer.setEnabled(true);
												tabFolderNav.setEnabled(true);
												wPB.close();
												zfs.disconnectServer();
											}

										}
									});

								}
							});
							thrCheck.start();
							wPB.close();


						}	
					}

				}

			}
		});

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zfs.getZserver().zProperties.get(keyProp).getType())) {
				Label lbl = new Label(compositeWidget, SWT.NONE);
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zfs.getZserver().zProperties.get(keyProp).getLabelProperty());

				labelsFieldServer.add(new Label(compositeWidget, SWT.NONE));
				labelsFieldServer.get(labelsFieldServer.size()-1).setBackground(labelFieldBackgroundColor);
				labelsFieldServer.get(labelsFieldServer.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				//labelsField.get(labelsField.size()-1).setText(zfs.getZserver().zProperties.get(keyProp).getNameProperty());
				labelsFieldServer.get(labelsFieldServer.size()-1).setData(zfs.getZserver().zProperties.get(keyProp).getNameProperty());
			}
		}

		scrolledServerConfig.setContent(compositeWidget);
		scrolledServerConfig.setExpandVertical(true);
		scrolledServerConfig.setExpandHorizontal(true);
		scrolledServerConfig.setMinSize(compositeWidget.computeSize(SWT.DEFAULT,SWT.DEFAULT));

		TabItem tabItem = new TabItem(tabFolderNav, SWT.NONE);
		tabItem.setText("Volumes and File System");
		tabItem.setData("volandfs");

		compositeTabVolConfig = new Composite(tabFolderNav, SWT.NONE);
		tabItem.setControl(compositeTabVolConfig);
		compositeTabVolConfig.setLayout(new GridLayout());
		compositeTabVolConfig.setBackground(tabFolderBackgroundColor);
		tree = new Tree(compositeTabVolConfig, SWT.BORDER);
		//t.minimumHeight=100;
		GridData gd_tree = new GridData(GridData.FILL,GridData.FILL, true, true);
		gd_tree.heightHint = 500;
		tree.setLayoutData(gd_tree);


		tree.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {

				final TreeItem root = (TreeItem) event.item;
				if ( root.getParentItem() != null){
					wPB = new guiProgress(shell.getDisplay(), shell.getLocation().x, shell.getLocation().y);
					actionClickTree(event);
				}
			}
		});		


		tabFolderConfig = new TabFolder(shell, SWT.UP);
		tabFolderConfig.setBounds(200, 0, 200, 200);
		tabFolderConfig.setBackground(tabFolderBackgroundColor);
		tabFolderConfig.setForeground(tabFolderForegroundColor);
		createTabItemZpoolConfig();
		createTabItemCreateVol();
		createTabItemDisks();
		tabFolderNav.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {
				if (tabFolderNav.getSelection()[0].getText().equalsIgnoreCase("general")){
					thrZpool = new Thread(new Runnable(){
						public void run() {
							Display.getDefault().syncExec(new Runnable() {
								public void run() {
									if (wPB.s.isDisposed()){
										wPB = new guiProgress(shell.getDisplay(), shell.getLocation().x, shell.getLocation().y);
										wPB.open();
									}else{
										wPB.open();
									}

								}
							});

							Display.getDefault().syncExec(new Runnable() {
								public void run() {
									if (!"".equals(zfs.getZpool().zProperties.get("name").getValue())){
										if (treeZpool.getSelection()[0].getParentItem() != null){
											if (treeZpool.getSelectionCount()>0){
												TreeItem zpoolSelect = treeZpool.getSelection()[0];
												treeZpool.select(zpoolSelect);
												zfs.getZserver().zProperties.get("serverIP").setValue(treeZpool.getSelection()[0].getParentItem().getData().toString());
												zfs.zpoolGetAll(zfs.getZpool().zProperties.get("name").getValue());	
											}	
										}

									}
									if ( !tbtmConfig.isDisposed()){
										tbtmConfig.dispose();
										tabFolderConfig.layout();
									}


									if ( !tbtmIscsi.isDisposed()){
										tbtmIscsi.dispose();
										tabFolderConfig.layout();
									}

									if ( !tbtmSnapshot.isDisposed()){
										tbtmSnapshot.dispose();
										tabFolderConfig.layout();
									}
									if ( !tbtmReplica.isDisposed()){
										tbtmReplica.dispose();
										tabFolderConfig.layout();
									}
									createTabItemZpoolConfig();
									refreshInfoZpool();
									compositeZpoolConfig.layout();
									zfs.setZvol();
									createTabItemCreateVol();
									compositeCreateVolFS.layout();

									createTabItemDisks();
									refreshDisks();
									compositeDisks.layout();

									wPB.close();
								}
							});
						}
					});
					thrZpool.start();	
				}
				if (tabFolderNav.getSelection()[0].getText().equalsIgnoreCase("Volumes and File System")){
					thrZfsList = new Thread(new Runnable(){
						public void run() {
							Display.getDefault().syncExec(new Runnable() {
								public void run() {
									if ( !tbtmZpoolConfig.isDisposed()){
										tbtmZpoolConfig.dispose();
										tabFolderConfig.layout();
									}
									if ( !tbtmCreateVolFS.isDisposed()){
										tbtmCreateVolFS.dispose();
										tabFolderConfig.layout();
									}
									if ( !tbtmDisks.isDisposed()){
										tbtmDisks.dispose();
										tabFolderConfig.layout();
									}
									//zfs.setZvol();
									if ( tree.getSelectionCount() >0){

										if (tree.getSelection()[0].getParentItem() != null){
											TreeItem topRoot = tree.getSelection()[0];
											while (topRoot.getParentItem() != null){
												topRoot = topRoot.getParentItem();
											}
											TreeItem treeZfsListItem = tree.getSelection()[0];
											tree.select(treeZfsListItem);
											zfs.getZserver().zProperties.get("serverIP").setValue(topRoot.getText());
											zfs.zfsGetAllVolume(tree.getSelection()[0].getData().toString());	
										}
									}
									createTabItemVolConfig();
									refreshConfigVolume();
									compositeConfig.layout();
									createTabItemIscsi();
									createTabItemSnapshot();
									createTabItemReplica();
								}

							});
						}
					});
					thrZfsList.start();
				}
			}
		});
		tabFolderConfig.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {
				if (tabFolderConfig.getSelection()[0].getText().equalsIgnoreCase("Snapshots")){
					//tabFolderConfig.getItems()[0].s
					treeSnapshots.clearAll(true);
					treeSnapshots.setItemCount(0);
					List<Object> zlistSnapshots = zfs.zfsListSnapshotsByVolFS(zfs.getZvol().zProperties.get("name").getValue());
					for (int i = 0; i < zlistSnapshots.size(); i++) {
						TreeItem root = new TreeItem(treeSnapshots, 0);
						root.setText(zlistSnapshots.get(i).toString());
						root.setData(zlistSnapshots.get(i).toString());
						new TreeItem(root, 0);
					}

				}
			}
		});
	}

	private void createTabItemSettings(){
		/******************************************************************************
		 * CREATE TAB : Settings
		 ******************************************************************************/

		tbtmSettings = new TabItem(tabFolderConfig,SWT.NONE,0);
		tbtmSettings.setText("Server Configuration");
		Composite compositeSettings = new Composite(tabFolderConfig,SWT.NONE);
		tbtmSettings.setControl(compositeSettings);
		GridLayout gridLayout = new GridLayout();
		compositeSettings.setLayout(gridLayout);

	}

	private void createTabItemZpoolConfig(){
		/******************************************************************************
		 * CREATE TAB : SZFS Pool Configuration
		 ******************************************************************************/

		tbtmZpoolConfig = new TabItem(tabFolderConfig,SWT.NONE,0);
		tbtmZpoolConfig.setText("Pool Configuration");
		compositeZpoolConfig = new Composite(tabFolderConfig,SWT.NONE);
		tbtmZpoolConfig.setControl(compositeZpoolConfig);
		GridLayout gridLayout = new GridLayout();
		gridLayout.numColumns=2;
		compositeZpoolConfig.setLayout(gridLayout);
		compositeZpoolConfig.setBackground(tabFolderBackgroundColor);

		Group groupZpoolConfig = new Group(compositeZpoolConfig,SWT.NONE);
		groupZpoolConfig.setBackground(groupBackgroundColor);
		groupZpoolConfig.setLayout(new GridLayout());
		//GridData gridDataZpoolConfig=new GridData(GridData.FILL_HORIZONTAL);
		GridData gridDataZpoolConfig=new GridData(SWT.FILL, SWT.FILL, true, true);
		//gridDataZpoolConfig.heightHint=550;
		//gridDataZpoolConfig.minimumHeight=550;
		gridDataZpoolConfig.horizontalSpan=2;
		groupZpoolConfig.setLayoutData(gridDataZpoolConfig);

		ScrolledComposite scrolledZpoolConfig=new ScrolledComposite(groupZpoolConfig,SWT.V_SCROLL);
		scrolledZpoolConfig.setLayoutData(new GridData(GridData.FILL_BOTH));
		Composite compositeWidget=new Composite(scrolledZpoolConfig,SWT.NONE);
		compositeWidget.setBackground(compositeBackgroundColor);
		GridLayout gridLayoutWidget = new GridLayout();
		gridLayoutWidget.numColumns =2;
		compositeWidget.setLayout(gridLayoutWidget);

		GridData gridDataTitle = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitle.horizontalSpan = 2;
		Label lblTitleInfoZpool = new Label(compositeWidget, SWT.CENTER|SWT.BORDER);
		lblTitleInfoZpool.setLayoutData(gridDataTitle);
		lblTitleInfoZpool.setFont(fontTitle);
		lblTitleInfoZpool.setBackground(labelTitleBackgroundColor);
		lblTitleInfoZpool.setText("ZFS Pool Informations");


		String[] keysProp = (String[]) zfs.getZpool().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);
		labelsFieldPool.clear();
		textsFieldPool.clear();	
		combosFieldPool.clear();

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			Label lbl = new Label(compositeWidget, SWT.NONE);
			lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
			lbl.setText(zfs.getZpool().zProperties.get(keyProp).getLabelProperty());
			lbl.setFont(fontWidget);
			lbl.setBackground(labelFieldBackgroundColor);
			if ( "noupdateable".equalsIgnoreCase(zfs.getZpool().zProperties.get(keyProp).getType())) {
				labelsFieldPool.add(new Label(compositeWidget, SWT.NONE));
				labelsFieldPool.get(labelsFieldPool.size()-1).setBackground(labelFieldBackgroundColor);
				labelsFieldPool.get(labelsFieldPool.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				labelsFieldPool.get(labelsFieldPool.size()-1).setData(zfs.getZpool().zProperties.get(keyProp).getNameProperty());
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZpool().zProperties.get(keyProp).getType())){
					textsFieldPool.add(new Text(compositeWidget, SWT.WRAP|SWT.BORDER));
					textsFieldPool.get(textsFieldPool.size()-1).setBackground(textFieldBackgroundColor);
					textsFieldPool.get(textsFieldPool.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					textsFieldPool.get(textsFieldPool.size()-1).setData(zfs.getZpool().zProperties.get(keyProp).getNameProperty());

				}else{

					if ( "nofreeentry".equalsIgnoreCase(zfs.getZpool().zProperties.get(keyProp).getType())){
						combosFieldPool.add(new Combo(compositeWidget, SWT.NONE));
						combosFieldPool.get(combosFieldPool.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						combosFieldPool.get(combosFieldPool.size()-1).setData(zfs.getZpool().zProperties.get(keyProp).getNameProperty());
						String[] keysPermitValue = (String[])zfs.getZpool().zProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);

						for (int cpt=0;cpt <zfs.getZpool().zProperties.get(keyProp).getPermitValue().size();cpt++){
							String keyPermitValue = keysPermitValue[cpt];
							combosFieldPool.get(combosFieldPool.size()-1).add(zfs.getZpool().zProperties.get(keyProp).getPermitValue().get(keyPermitValue).toString());
						}
					}
				}

			}
		}


		scrolledZpoolConfig.setContent(compositeWidget);
		scrolledZpoolConfig.setExpandVertical(true);
		scrolledZpoolConfig.setExpandHorizontal(true);
		scrolledZpoolConfig.setMinSize(compositeWidget.computeSize(SWT.DEFAULT,SWT.DEFAULT));


	}

	private void createTabItemDisks(){
		/******************************************************************************
		 * CREATE TAB : DISKS ZFS
		 ******************************************************************************/

		tbtmDisks = new TabItem(tabFolderConfig,SWT.NONE,2);
		tbtmDisks.setText("Raid and Disks Configuration");
		compositeDisks = new Composite(tabFolderConfig,SWT.NONE);
		tbtmDisks.setControl(compositeDisks);
		GridLayout gridLayout = new GridLayout();
		gridLayout.numColumns=6;
		compositeDisks.setLayout(gridLayout);
		compositeDisks.setBackground(tabFolderBackgroundColor);






	}



	private void createTabItemVolConfig(){
		/******************************************************************************
		 * CREATE TAB : Config
		 ******************************************************************************/


		tbtmConfig = new TabItem(tabFolderConfig,SWT.NONE,0);
		tbtmConfig.setText("Configuration");
		compositeConfig = new Composite(tabFolderConfig, SWT.NONE);
		//compositeConfig.set
		GridData parentData = new GridData(SWT.FILL, SWT.FILL, true, true);
		compositeConfig.setLayoutData(parentData);
		tbtmConfig.setControl(compositeConfig);
		GridLayout gridLayout = new GridLayout();
		gridLayout.numColumns=2;
		compositeConfig.setLayout(gridLayout);
		compositeConfig.setBackground(tabFolderBackgroundColor);
		Group groupInfoVolFS=new Group(compositeConfig,SWT.NONE);
		groupInfoVolFS.setBackground(groupBackgroundColor);
		groupInfoVolFS.setLayout(new GridLayout());
		GridData gridData=new GridData(GridData.FILL_HORIZONTAL);
		gridData.heightHint=400;
		gridData.horizontalSpan=2;
		groupInfoVolFS.setLayoutData(gridData);

		ScrolledComposite scrolledCreateVol=new ScrolledComposite(groupInfoVolFS,SWT.V_SCROLL);
		scrolledCreateVol.setLayoutData(new GridData(GridData.FILL_BOTH));
		Composite compositeWidget=new Composite(scrolledCreateVol,SWT.NONE);
		compositeWidget.setBackground(compositeBackgroundColor);
		GridLayout gridLayoutWidget = new GridLayout();
		gridLayoutWidget.numColumns =2;
		compositeWidget.setLayout(gridLayoutWidget);

		GridData gridDataTitle = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitle.horizontalSpan = 2;
		Label lblTitleVolConfig = new Label(compositeWidget, SWT.CENTER|SWT.BORDER);
		lblTitleVolConfig.setLayoutData(gridDataTitle);
		lblTitleVolConfig.setFont(fontTitle);
		lblTitleVolConfig.setBackground(labelTitleBackgroundColor);
		lblTitleVolConfig.setText("Volume Parameters Information");

		String[] keysProp = (String[]) zfs.getZvol().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);
		labelsField.clear();
		textsField.clear();
		combosField.clear();
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( ("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && 
					("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) || 
							"volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf())) ) ||
							("filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && 
									("fs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) || 
											"volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) ) )		
											|| ("snapshot".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && "volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()))

					){

				Label lbl = new Label(compositeWidget, SWT.NONE);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zfs.getZvol().zProperties.get(keyProp).getLabelProperty());
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				if ( "noupdateable".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType())) {
					labelsField.add(new Label(compositeWidget, SWT.NONE));
					labelsField.get(labelsField.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					//labelsField.get(labelsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
					labelsField.get(labelsField.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
					labelsField.get(labelsField.size()-1).setBackground(labelFieldBackgroundColor);
				}else{
					if ( "freeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType())){
						textsField.add(new Text(compositeWidget, SWT.WRAP|SWT.BORDER));
						textsField.get(textsField.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						//textsField.get(textsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
						textsField.get(textsField.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
						textsField.get(textsField.size()-1).setBackground(textFieldBackgroundColor);
					}else{

						if ( "nofreeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType())){
							combosField.add(new Combo(compositeWidget, SWT.NONE));
							combosField.get(combosField.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
							combosField.get(combosField.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
							//combosField.get(combosField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
							String[] keysPermitValue = (String[])zfs.getZvol().zProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
							for (int cpt=0;cpt <zfs.getZvol().zProperties.get(keyProp).getPermitValue().size();cpt++){
								String keyPermitValue = keysPermitValue[cpt];
								combosField.get(combosField.size()-1).add(zfs.getZvol().zProperties.get(keyProp).getPermitValue().get(keyPermitValue).toString());
							}
						}
					}
				}
			}
		}
		scrolledCreateVol.setContent(compositeWidget);
		scrolledCreateVol.setExpandVertical(true);
		scrolledCreateVol.setExpandHorizontal(true);
		scrolledCreateVol.setMinSize(compositeWidget.computeSize(SWT.DEFAULT,SWT.DEFAULT));

	}

	private void createTabItemCreateVol(){
		/******************************************************************************
		 * CREATE TAB : Create Volume
		 ******************************************************************************/
		tbtmCreateVolFS = new TabItem(tabFolderConfig, SWT.NONE);
		tbtmCreateVolFS.setText("Create Volume/FileSystem");
		compositeCreateVolFS = new Composite(tabFolderConfig, SWT.NONE);
		tbtmCreateVolFS.setControl(compositeCreateVolFS);
		GridLayout gridLayoutCreateVolFS = new GridLayout();
		gridLayoutCreateVolFS.numColumns =1;
		compositeCreateVolFS.setLayout(gridLayoutCreateVolFS);
		compositeCreateVolFS.setBackground(tabFolderBackgroundColor);



		refreshCreateZfsVolFS();




	}

	private void createTabItemIscsi(){
		/******************************************************************************
		 * CREATE TAB : Add ISCSI Config
		 ******************************************************************************/
		tbtmIscsi = new TabItem(tabFolderConfig, SWT.NONE);
		tbtmIscsi.setText("ISCSI Configuration");
		compositeIscsi = new Composite(tabFolderConfig, SWT.NONE);
		tbtmIscsi.setControl(compositeIscsi);
		GridLayout gridLayoutCreateIscsi = new GridLayout();
		//gridLayoutCreateIscsi.numColumns =2;
		compositeIscsi.setLayout(gridLayoutCreateIscsi);
		compositeIscsi.setBackground(tabFolderBackgroundColor);

		Group groupListSession= new Group(compositeIscsi,SWT.NONE);
		groupListSession.setBackground(groupBackgroundColor);
		groupListSession.setLayout(new GridLayout());
		GridData gridDataListSession=new GridData(GridData.FILL_HORIZONTAL);
		//gridDataServerConfig.heightHint=500;
		//gridDataServerConfig.minimumHeight=500;
		gridDataListSession.heightHint=120;
		groupListSession.setLayoutData(gridDataListSession);

		GridData gridDataTitle = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitle.horizontalSpan = 2;
		Label lblTitleListSession = new Label(groupListSession, SWT.CENTER|SWT.BORDER);
		lblTitleListSession.setLayoutData(gridDataTitle);
		lblTitleListSession.setFont(fontTitle);
		lblTitleListSession.setBackground(labelTitleBackgroundColor);
		lblTitleListSession.setText("ISCSI Session List");

		GridData gd_tableIscsiSession = new GridData(GridData.FILL,GridData.FILL, true, true);
		gd_tableIscsiSession.heightHint = 100;
		gd_tableIscsiSession.horizontalSpan = 2;
		tableIscsiSession = new Table(groupListSession, SWT.BORDER | SWT.FULL_SELECTION | SWT.MULTI);
		tableIscsiSession.setHeaderVisible(true);
		tableIscsiSession.setLinesVisible(true);
		tableIscsiSession.setLayoutData(gd_tableIscsiSession);
		String[] keysProp = (String[]) zfs.getZiscsi().zProperties.keySet().toArray(new String[0]);
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "multinoupdateable".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())){
				log.info("create tab iscsi");
				tablecolumnsFieldAddIscsi.add(new TableColumn(tableIscsiSession, SWT.NONE));
				tablecolumnsFieldAddIscsi.get(tablecolumnsFieldAddIscsi.size()-1).setWidth(150);
				tablecolumnsFieldAddIscsi.get(tablecolumnsFieldAddIscsi.size()-1).setText(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
			}
		}

		Group groupSessionParameters= new Group(compositeIscsi,SWT.NONE);
		groupSessionParameters.setBackground(groupBackgroundColor);
		GridLayout gridLayoutSessionParemeters = new GridLayout();
		gridLayoutSessionParemeters.numColumns =2;
		groupSessionParameters.setLayout(gridLayoutSessionParemeters);

		GridData gridDataSessionParameters=new GridData(GridData.FILL_HORIZONTAL);
		//gridDataSessionParameters.heightHint=250;
		groupSessionParameters.setLayoutData(gridDataSessionParameters);

		GridData gridDataTitleSessionParameters = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitleSessionParameters.horizontalSpan = 2;
		Label lblTitreSessionParameters = new Label(groupSessionParameters, SWT.CENTER|SWT.BORDER);
		lblTitreSessionParameters.setLayoutData(gridDataTitleSessionParameters);
		lblTitreSessionParameters.setFont(fontTitle);
		lblTitreSessionParameters.setBackground(labelTitleBackgroundColor);
		lblTitreSessionParameters.setText("ISCSI Session Parameters");
		keysProp = (String[]) zfs.getZiscsi().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);
		labelsFieldAddIscsi.clear();
		textsFieldAddIscsi.clear();
		combosFieldAddIscsi.clear();

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
				Label lbl = new Label(groupSessionParameters, SWT.NONE);
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zfs.getZiscsi().zProperties.get(keyProp).getLabelProperty());

				labelsFieldAddIscsi.add(new Label(groupSessionParameters, SWT.NONE));
				labelsFieldAddIscsi.get(labelsFieldAddIscsi.size()-1).setBackground(labelFieldBackgroundColor);
				labelsFieldAddIscsi.get(labelsFieldAddIscsi.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				labelsFieldAddIscsi.get(labelsFieldAddIscsi.size()-1).setData(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())){
					Label lbl = new Label(groupSessionParameters, SWT.NONE);
					lbl.setFont(fontWidget);
					lbl.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));
					lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					lbl.setText(zfs.getZiscsi().zProperties.get(keyProp).getLabelProperty());

					textsFieldAddIscsi.add(new Text(groupSessionParameters, SWT.WRAP|SWT.BORDER));
					textsFieldAddIscsi.get(textsFieldAddIscsi.size()-1).setBackground(textFieldBackgroundColor);
					textsFieldAddIscsi.get(textsFieldAddIscsi.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					//textsField.get(textsField.size()-1).setText(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
					textsFieldAddIscsi.get(textsFieldAddIscsi.size()-1).setData(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());

				}else{

					if ( "nofreeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())){
						Label lbl = new Label(groupSessionParameters, SWT.NONE);
						lbl.setFont(fontWidget);
						lbl.setBackground(labelFieldBackgroundColor);
						lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						lbl.setText(zfs.getZiscsi().zProperties.get(keyProp).getLabelProperty());

						combosFieldAddIscsi.add(new Combo(groupSessionParameters, SWT.NONE));
						combosFieldAddIscsi.get(combosFieldAddIscsi.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						combosFieldAddIscsi.get(combosFieldAddIscsi.size()-1).setData(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
						//combosField.get(combosField.size()-1).setText(zfs.getZiscsi().zProperties.get(keyProp).getValue());
						String[] keysPermitValue = (String[]) zfs.getZiscsi().zProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
						for (int cpt=0;cpt <zfs.getZiscsi().zProperties.get(keyProp).getPermitValue().size();cpt++){
							String keyPermitValue = keysPermitValue[cpt];
							combosFieldAddIscsi.get(combosFieldAddIscsi.size()-1).add(zfs.getZiscsi().zProperties.get(keyProp).getPermitValue().get(keyPermitValue).toString());
						}
					}
				}

			}
		}
		Button btnCreateIscsi = new Button(groupSessionParameters, SWT.None);
		btnCreateIscsi.setText("Enable Iscsi");
		btnCreateIscsi.addListener(SWT.Selection, new Listener() {

			public void handleEvent(final Event event) {
				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("")){

					String[] keysProp = (String[]) zfs.getZiscsi().zProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysProp);

					for (int i = 0; i < keysProp.length; i++) {
						keyProp = keysProp[i];
						log.debug("btnCreateIscsi :"+keyProp);
						if ( "noupdateable".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
							for (int indLabel=0;indLabel<labelsFieldAddIscsi.size();indLabel++){
								if ( labelsFieldAddIscsi.get(indLabel).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
									zfs.getZiscsi().zProperties.get(keyProp).setValue(labelsFieldAddIscsi.get(indLabel).getText());
								}
							}
						}else{
							if ( "freeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
								for (int indText=0;indText<textsFieldAddIscsi.size();indText++){
									if ( textsFieldAddIscsi.get(indText).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
										zfs.getZiscsi().zProperties.get(keyProp).setValue(textsFieldAddIscsi.get(indText).getText());
									}
								}

							}else{

								if ( "nofreeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
									for (int indList=0;indList<combosFieldAddIscsi.size();indList++){
										log.debug("first loop"+combosFieldAddIscsi.get(indList).getData()+" "+zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());

										if ( combosFieldAddIscsi.get(indList).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
											zfs.getZiscsi().zProperties.get(keyProp).setValue(combosFieldAddIscsi.get(indList).getText());
											log.debug(zfs.getZiscsi().zProperties.get(keyProp).getMultivalues());
										}
									}
								}
							}
						}
					}
					if ("snapshot".equals(zfs.getZvol().zProperties.get("type").getValue())){
						zfs.getZiscsi().zProperties.get("iomode").setValue("ro");
					}
					zfs.zfsCreateIscsi();

					String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);
					//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysPropError);
					String textBox = "";
					for (int i = 0; i < keysPropError.length; i++) {
						String keyPropError = keysPropError[i];
						textBox = textBox +zfs.getError().get(keyPropError)+".\n";
					}
					if (keysPropError.length>0){
						MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
						messageBoxInfo.setText("Warning");
						messageBoxInfo.setMessage(textBox);
						messageBoxInfo.open();
					}else{
						refreshIscsiSession();
						if ("volume".equals(zfs.getZvol().zProperties.get("type").getValue())){
							tree.getSelection()[0].setImage(imageStorageOnline);
						}else{
							if ("snapshot".equals(zfs.getZvol().zProperties.get("type").getValue())){
								tree.getSelection()[0].setImage(imageSnapshotOnline);
							}
						}

					}

				}	
			}
		});

		Button btnDelIscsi = new Button(groupSessionParameters, SWT.None);
		btnDelIscsi.setText("Disable Iscsi");
		btnDelIscsi.addListener(SWT.Selection, new Listener() {



			public void handleEvent(final Event event) {

				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("")&& !"filesystem".equals(zfs.getZvol().zProperties.get("type").getValue())){
					zfs.zfsDelIscsi();
					String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);
					//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysPropError);
					String textBox = "";
					for (int i = 0; i < keysPropError.length; i++) {
						String keyPropError = keysPropError[i];
						textBox = textBox +zfs.getError().get(keyPropError)+".\n";
					}
					if (keysPropError.length>0){
						MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
						messageBoxInfo.setText("Warning");
						messageBoxInfo.setMessage(textBox);
						messageBoxInfo.open();
					}else{
						refreshIscsiSession();
						if ("volume".equals(zfs.getZvol().zProperties.get("type").getValue())){
							tree.getSelection()[0].setImage(imageStorageOffline);
						}else{
							if ("snapshot".equals(zfs.getZvol().zProperties.get("type").getValue())){
								tree.getSelection()[0].setImage(imageSnapshotOffline);
							}
						}

					}

				}
			}
		});
	}

	/************************************************************************************************************************************
	 * 
	 * Create tabItem Snapshot Config
	 * 
	 ************************************************************************************************************************************/

	private void createTabItemSnapshot(){
		tbtmSnapshot = new TabItem(tabFolderConfig, SWT.NONE);
		tbtmSnapshot.setText("Snapshot Configuration");
		compositeSnapshot = new Composite(tabFolderConfig, SWT.NONE);
		tbtmSnapshot.setControl(compositeSnapshot);
		GridLayout gridLayoutActiveSnapshot = new GridLayout();
		//gridLayoutCreateIscsi.numColumns =2;
		compositeSnapshot.setLayout(gridLayoutActiveSnapshot);
		compositeSnapshot.setBackground(tabFolderBackgroundColor);



		Group groupActiveSnapshot=new Group(compositeSnapshot,SWT.NONE);
		groupActiveSnapshot.setBackground(groupBackgroundColor);
		GridLayout gridLayoutWidgetSnapshot = new GridLayout();
		gridLayoutWidgetSnapshot.numColumns =2;
		groupActiveSnapshot.setLayout(gridLayoutWidgetSnapshot);
		GridData gridDataActiveSnapshot=new GridData(GridData.FILL_HORIZONTAL);
		//gridDataActiveSnapshot.heightHint=500;

		groupActiveSnapshot.setLayoutData(gridDataActiveSnapshot);

		GridData gridDataTitleSnapshots = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitleSnapshots.horizontalSpan = 2;
		Label lblTitreConfigSnapshots = new Label(groupActiveSnapshot, SWT.CENTER|SWT.BORDER);
		lblTitreConfigSnapshots.setLayoutData(gridDataTitleSnapshots);
		lblTitreConfigSnapshots.setFont(fontTitle);
		lblTitreConfigSnapshots.setText("Enable/Disable Snapshot");
		lblTitreConfigSnapshots.setBackground(labelTitleBackgroundColor);

		String[] keysProp = (String[]) zsnap.getZsnapshots().zSchedulerProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		labelsFieldSnapshotsValue.clear();
		labelsFieldSnapshots.clear();
		textsFieldSnapshots.clear();
		listsFieldSnaphots.clear();
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];				

			if ( "noupdateable".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
				Label lbl = new Label(groupActiveSnapshot, SWT.NONE);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getLabelProperty());
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				labelsFieldSnapshots.add(new Label(groupActiveSnapshot, SWT.NONE));
				labelsFieldSnapshots.get(labelsFieldSnapshots.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				//labelsField.get(labelsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
				labelsFieldSnapshots.get(labelsFieldSnapshots.size()-1).setData(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty());
				labelsFieldSnapshots.get(labelsFieldSnapshots.size()-1).setBackground(labelFieldBackgroundColor);
			}else{
				if ( "freeentry".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())){
					Label lbl = new Label(groupActiveSnapshot, SWT.NONE);
					lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					lbl.setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getLabelProperty());
					lbl.setFont(fontWidget);
					lbl.setBackground(labelFieldBackgroundColor);
					textsFieldSnapshots.add(new Text(groupActiveSnapshot,SWT.WRAP| SWT.BORDER));
					textsFieldSnapshots.get(textsFieldSnapshots.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					//textsField.get(textsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
					textsFieldSnapshots.get(textsFieldSnapshots.size()-1).setData(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty());
					textsFieldSnapshots.get(textsFieldSnapshots.size()-1).setBackground(textFieldBackgroundColor);
				}else{

					if ( "nofreeentry".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())){
						Label lbl = new Label(groupActiveSnapshot, SWT.NONE);
						lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						lbl.setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getLabelProperty());
						lbl.setFont(fontWidget);
						lbl.setBackground(labelFieldBackgroundColor);
						labelsFieldSnapshotsValue.add(new Label(groupActiveSnapshot, SWT.BORDER));
						labelsFieldSnapshotsValue.get(labelsFieldSnapshotsValue.size()-1).setData(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty());
						labelsFieldSnapshotsValue.get(labelsFieldSnapshotsValue.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						labelsFieldSnapshotsValue.get(labelsFieldSnapshotsValue.size()-1).setFont(fontWidget);
						labelsFieldSnapshotsValue.get(labelsFieldSnapshotsValue.size()-1).setBackground(labelFieldBackgroundColor);
						listsFieldSnaphots.add(new org.eclipse.swt.widgets.List(groupActiveSnapshot, SWT.WRAP |SWT.BORDER|SWT.V_SCROLL|SWT.MULTI));
						GridData grdData_listSnapshots = new GridData(GridData.FILL, GridData.CENTER, true, false);
						grdData_listSnapshots.heightHint=96;
						grdData_listSnapshots.horizontalSpan=2;
						listsFieldSnaphots.get(listsFieldSnaphots.size()-1).setLayoutData(grdData_listSnapshots);
						listsFieldSnaphots.get(listsFieldSnaphots.size()-1).setData(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty());

						String [] valuePermiValue = zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getPermitValue().values().toArray(new String[0]);
						Arrays.sort(valuePermiValue);
						listsFieldSnaphots.get(listsFieldSnaphots.size()-1).setItems(valuePermiValue);
					}
				}
			}
		}
		Button btnEnableSnapshots = new Button(groupActiveSnapshot, SWT.None);
		btnEnableSnapshots.setText("Enable Snapshots");
		btnEnableSnapshots.addListener(SWT.Selection, new Listener() {
			private List<Object> list4List;

			public void handleEvent(final Event event) {
				zsnap = zfs;

				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("")){

					String[] keysProp = (String[]) zsnap.getZsnapshots().zSchedulerProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysProp);

					for (int i = 0; i < keysProp.length; i++) {
						keyProp = keysProp[i];
						log.debug("btnEnableSnapshot :"+keyProp);
						if ( "noupdateable".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
							for (int indLabel=0;indLabel<labelsFieldSnapshots.size();indLabel++){
								if ( labelsFieldSnapshots.get(indLabel).getData().equals(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty()) ){
									zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).setValue(labelsFieldSnapshots.get(indLabel).getText());

								}
							}
						}else{
							if ( "freeentry".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
								for (int indText=0;indText<textsFieldSnapshots.size();indText++){
									if ( textsFieldSnapshots.get(indText).getData().equals(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty()) ){
										zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).setValue(textsFieldSnapshots.get(indText).getText());
									}
								}

							}else{

								if ( "nofreeentry".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
									for (int indList=0;indList<listsFieldSnaphots.size();indList++){
										log.debug("first loop"+listsFieldSnaphots.get(indList).getData()+" "+zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty());
										if ( listsFieldSnaphots.get(indList).getData().equals(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty()) ){
											list4List = new ArrayList<Object>();
											log.debug("second if "+listsFieldSnaphots.get(indList).getSelection().length);
											for ( int indSelect=0;indSelect<listsFieldSnaphots.get(indList).getSelection().length;indSelect++){
												String[] keysPropPermit = (String[]) zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
												log.debug("second loop keys "+keysPropPermit+" selection in use "+listsFieldSnaphots.get(indList).getSelection()[indSelect]);
												for ( int indPermit=0; indPermit<keysPropPermit.length;indPermit++){
													String keyPropPermit = keysPropPermit[indPermit];
													log.debug("Thirth if "+keyPropPermit+" "+zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getPermitValue().get(keyPropPermit));
													if ( zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getPermitValue().get(keyPropPermit).equals(listsFieldSnaphots.get(indList).getSelection()[indSelect]) ){
														list4List.add(keyPropPermit);

													}
												}
											}

											zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).setMultivalues(list4List);
											log.debug( " "+list4List+ zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getMultivalues());
										}
									}
								}
							}
						}
					}
					zsnap.zfsEnableSnapshots();
					String[] keysPropError = zsnap.getError().keySet().toArray(new String[0]);
					//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysPropError);
					String textBox = "";
					for (int i = 0; i < keysPropError.length; i++) {
						String keyPropError = keysPropError[i];
						textBox = textBox +zsnap.getError().get(keyPropError)+".\n";
					}
					if (keysPropError.length>0){
						MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
						messageBoxInfo.setText("Warning");
						messageBoxInfo.setMessage(textBox);
						messageBoxInfo.open();
					}else{
						for (int indList=0;indList<listsFieldSnaphots.size();indList++){
							listsFieldSnaphots.get(indList).deselectAll();
						}
					}

					refreshConfigSnapshot();
				}
			}
		});
		Button btnDisableSnapshots = new Button(groupActiveSnapshot, SWT.None);
		btnDisableSnapshots.setText("Disable Snapshots");
		btnDisableSnapshots.addListener(SWT.Selection, new Listener() {

			public void handleEvent(final Event event) {
				//zsnap = zfs;
				boolean checkValue=true;
				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("")){

					String[] keysProp = (String[]) zsnap.getZsnapshots().zSchedulerProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysProp);

					for (int i = 0; i < keysProp.length; i++) {
						keyProp = keysProp[i];
						log.debug("btnEnableSnapshot :"+keyProp);
						if ( zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue().equalsIgnoreCase("")){
							checkValue=false;
						}
					}
					if (checkValue == true){
						zsnap.zfsDisableSnapshots();
						refreshConfigSnapshot();

					}
				}

			}
		});

	}

	/************************************************************************************************************************************
	 * 
	 * Create tabItem Replication Config
	 * 
	 ************************************************************************************************************************************/

	private void createTabItemReplica(){
		tbtmReplica = new TabItem(tabFolderConfig, SWT.NONE);
		tbtmReplica.setText("Replication Configuration");
		compositeReplica = new Composite(tabFolderConfig, SWT.NONE);
		tbtmReplica.setControl(compositeReplica);
		GridLayout gridLayoutActiveReplica = new GridLayout();
		//gridLayoutCreateIscsi.numColumns =2;
		compositeReplica.setLayout(gridLayoutActiveReplica);
		compositeReplica.setBackground(tabFolderBackgroundColor);

		Group groupActiveReplica=new Group(compositeReplica,SWT.NONE);
		groupActiveReplica.setBackground(groupBackgroundColor);
		groupActiveReplica.setLayout(new GridLayout());
		GridData gridDataActiveReplica=new GridData(SWT.FILL, SWT.FILL, true, true);
		//gridDataActiveSnapshot.heightHint=500;
		groupActiveReplica.setLayoutData(gridDataActiveReplica);

		ScrolledComposite scrolledReplicaConfig=new ScrolledComposite(groupActiveReplica,SWT.V_SCROLL);
		scrolledReplicaConfig.setLayoutData(new GridData(GridData.FILL_BOTH));
		Composite compositeWidgetReplica=new Composite(scrolledReplicaConfig,SWT.NONE);
		compositeWidgetReplica.setBackground(compositeBackgroundColor);
		GridLayout gridLayoutWidget = new GridLayout();
		gridLayoutWidget.numColumns =2;
		compositeWidgetReplica.setLayout(gridLayoutWidget);

		GridData gridDataTitleReplica = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitleReplica.horizontalSpan = 2;
		Label lblTitreConfigReplica = new Label(compositeWidgetReplica, SWT.CENTER|SWT.BORDER);
		lblTitreConfigReplica.setLayoutData(gridDataTitleReplica);
		lblTitreConfigReplica.setFont(fontTitle);
		lblTitreConfigReplica.setText("Enable/Disable Replication");
		lblTitreConfigReplica.setBackground(labelTitleBackgroundColor);

		String[] keysProp = (String[]) zfs.getZreplicas().zSchedulerProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		labelsFieldReplicaValue.clear();
		labelsFieldReplica.clear();
		textsFieldReplica.clear();
		listsFieldReplica.clear();
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];			

			if ( "nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType()) && (zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() !=null)){
				Label lbl = new Label(compositeWidgetReplica, SWT.NONE);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getLabelProperty());
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				labelsFieldReplicaValue.add(new Label(compositeWidgetReplica, SWT.BORDER));
				labelsFieldReplicaValue.get(labelsFieldReplicaValue.size()-1).setData(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());
				labelsFieldReplicaValue.get(labelsFieldReplicaValue.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				labelsFieldReplicaValue.get(labelsFieldReplicaValue.size()-1).setFont(fontWidget);
				labelsFieldReplicaValue.get(labelsFieldReplicaValue.size()-1).setBackground(labelFieldBackgroundColor);
				listsFieldReplica.add(new org.eclipse.swt.widgets.List(compositeWidgetReplica, SWT.WRAP |SWT.BORDER|SWT.V_SCROLL|SWT.MULTI));
				GridData grdData_listReplicas = new GridData(GridData.FILL, GridData.CENTER, true, false);
				grdData_listReplicas.heightHint=96;
				grdData_listReplicas.horizontalSpan=2;
				listsFieldReplica.get(listsFieldReplica.size()-1).setLayoutData(grdData_listReplicas);
				listsFieldReplica.get(listsFieldReplica.size()-1).setData(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());
				String [] valuePermiValue = zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue().values().toArray(new String[0]);
				Arrays.sort(valuePermiValue);
				listsFieldReplica.get(listsFieldReplica.size()-1).setItems(valuePermiValue);

			}
		}
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];		
			if ( "noupdateable".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())) {
				Label lbl = new Label(compositeWidgetReplica, SWT.NONE);
				lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				lbl.setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getLabelProperty());
				lbl.setFont(fontWidget);
				lbl.setBackground(labelFieldBackgroundColor);
				labelsFieldReplica.add(new Label(compositeWidgetReplica, SWT.NONE));
				labelsFieldReplica.get(labelsFieldReplica.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
				//labelsField.get(labelsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
				labelsFieldReplica.get(labelsFieldReplica.size()-1).setData(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());
				labelsFieldReplica.get(labelsFieldReplica.size()-1).setBackground(labelFieldBackgroundColor);
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())){
					Label lbl = new Label(compositeWidgetReplica, SWT.NONE);
					lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					lbl.setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getLabelProperty());
					lbl.setFont(fontWidget);
					lbl.setBackground(labelFieldBackgroundColor);
					textsFieldReplica.add(new Text(compositeWidgetReplica,SWT.WRAP| SWT.BORDER));
					textsFieldReplica.get(textsFieldReplica.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					//textsField.get(textsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
					textsFieldReplica.get(textsFieldReplica.size()-1).setData(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());
					textsFieldReplica.get(textsFieldReplica.size()-1).setBackground(textFieldBackgroundColor);
				}else{


					if ("nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType()) && zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() ==null){


						Label lbl = new Label(compositeWidgetReplica, SWT.NONE);
						lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						lbl.setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getLabelProperty());
						lbl.setFont(fontWidget);
						lbl.setBackground(labelFieldBackgroundColor);

						combosFieldReplica.add((new Combo(compositeWidgetReplica, SWT.READ_ONLY)));
						GridData grdData_listReplicas = new GridData(GridData.FILL, GridData.CENTER, true, false);
						combosFieldReplica.get(combosFieldReplica.size()-1).setLayoutData(grdData_listReplicas);
						combosFieldReplica.get(combosFieldReplica.size()-1).setData(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());

						log.debug("createTabItemReplica "+keyProp);
						if (keyProp.equalsIgnoreCase("server")){
							lbl = new Label(compositeWidgetReplica, SWT.NONE);
							lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
							lbl.setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getLabelProperty());
							lbl.setFont(fontWidget);
							lbl.setBackground(labelFieldBackgroundColor);

							labelsFieldReplica.add(new Label(compositeWidgetReplica, SWT.NONE));
							labelsFieldReplica.get(labelsFieldReplica.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
							//labelsField.get(labelsField.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
							labelsFieldReplica.get(labelsFieldReplica.size()-1).setData(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());
							labelsFieldReplica.get(labelsFieldReplica.size()-1).setBackground(labelFieldBackgroundColor);
							combosFieldReplica.get(combosFieldReplica.size()-1).addListener(SWT.Selection, new Listener() {

								public void handleEvent(final Event event) {
									final Combo comboSrv = (Combo) event.widget;
									zfs.getServer(comboSrv.getText());
									List zpoolList = zfs.zpoolList();
									String[] keysProp = (String[]) zfs.getZreplicas().zSchedulerProperties.keySet().toArray(new String[0]);
									Arrays.sort(keysProp);

									for (int i = 0; i < keysProp.length; i++) {
										keyProp = keysProp[i];
										if ( "nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())&& zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() ==null) {
											if (keyProp.equalsIgnoreCase("replicapool")){

												for (int indCombo=0;indCombo<combosFieldReplica.size();indCombo++){
													if ( combosFieldReplica.get(indCombo).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
														combosFieldReplica.get(indCombo).removeAll();
														String[] keysPropSrv = (String[]) zfs.getCacheSession().keySet().toArray(new String[0]);
														Arrays.sort(keysPropSrv);
														for (int cptPool=0;cptPool<zpoolList.size();cptPool++){
															combosFieldReplica.get(indCombo).add(zpoolList.get(cptPool).toString());
															log.debug("REFRESHConfig3 : "+zpoolList.get(cptPool).toString());
														}
													}
												}

											}
										}
									}

								}
							});
						}

					}
				}
			}
		}
		Button btnEnableReplicas = new Button(compositeWidgetReplica, SWT.None);
		btnEnableReplicas.setText("Enable Replication");
		btnEnableReplicas.addListener(SWT.Selection, new Listener() {
			private List<Object> list4List;

			public void handleEvent(final Event event) {


				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("")){

					String[] keysProp = (String[]) zfs.getZreplicas().zSchedulerProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysProp);

					for (int i = 0; i < keysProp.length; i++) {
						keyProp = keysProp[i];
						log.debug("btnEnableReplication :"+keyProp);
						if ( "noupdateable".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())) {
							for (int indLabel=0;indLabel<labelsFieldReplica.size();indLabel++){
								if ( labelsFieldReplica.get(indLabel).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
									zfs.getZreplicas().zSchedulerProperties.get(keyProp).setValue(labelsFieldReplica.get(indLabel).getText());

								}
							}
						}else{
							if ( "freeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())) {
								for (int indText=0;indText<textsFieldReplica.size();indText++){
									if ( textsFieldReplica.get(indText).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
										zfs.getZreplicas().zSchedulerProperties.get(keyProp).setValue(textsFieldReplica.get(indText).getText());
									}
								}

							}else{

								if ( "nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType()) && (zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() !=null)){
									for (int indList=0;indList<listsFieldReplica.size();indList++){
										log.debug("first loop"+listsFieldReplica.get(indList).getData()+" "+zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty());
										if ( listsFieldReplica.get(indList).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
											list4List = new ArrayList<Object>();
											log.debug("second if "+listsFieldReplica.get(indList).getSelection().length);
											for ( int indSelect=0;indSelect<listsFieldReplica.get(indList).getSelection().length;indSelect++){
												String[] keysPropPermit = (String[]) zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
												log.debug("second loop keys "+keysPropPermit+" selection in use "+listsFieldReplica.get(indList).getSelection()[indSelect]);
												for ( int indPermit=0; indPermit<keysPropPermit.length;indPermit++){
													String keyPropPermit = keysPropPermit[indPermit];
													log.debug("Thirth if "+keyPropPermit+" "+zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue().get(keyPropPermit));
													if ( zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue().get(keyPropPermit).equals(listsFieldReplica.get(indList).getSelection()[indSelect]) ){
														list4List.add(keyPropPermit);

													}
												}
											}

											zfs.getZreplicas().zSchedulerProperties.get(keyProp).setMultivalues(list4List);
											log.debug( " "+list4List+ zfs.getZreplicas().zSchedulerProperties.get(keyProp).getMultivalues());
										}
									}
								}
								if ( "nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType()) && (zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() ==null)){
									for (int indCombo=0;indCombo<combosFieldReplica.size();indCombo++){
										if ( combosFieldReplica.get(indCombo).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
											zfs.getZreplicas().zSchedulerProperties.get(keyProp).setValue(combosFieldReplica.get(indCombo).getText());
										}
									}
								}
							}
						}
					}
					zfs.getZreplicas().zSchedulerProperties.get("name").setValue(zfs.getZvol().zProperties.get("name").getValue());
					if ( tree.getSelectionCount() >0){

						if (tree.getSelection()[0].getParentItem() != null){
							TreeItem topRoot = tree.getSelection()[0];
							while (topRoot.getParentItem() != null){
								topRoot = topRoot.getParentItem();
							}
							TreeItem treeZfsListItem = tree.getSelection()[0];
							tree.select(treeZfsListItem);
							zfs.getZserver().zProperties.get("serverIP").setValue(topRoot.getText());
						}
					}
					zfs.zfsEnableReplicas();
					String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);
					//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysPropError);
					String textBox = "";
					for (int i = 0; i < keysPropError.length; i++) {
						String keyPropError = keysPropError[i];
						textBox = textBox +zfs.getError().get(keyPropError)+".\n";
					}
					if (keysPropError.length>0){
						MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
						messageBoxInfo.setText("Warning");
						messageBoxInfo.setMessage(textBox);
						messageBoxInfo.open();
					}else{
						for (int indList=0;indList<listsFieldReplica.size();indList++){
							listsFieldReplica.get(indList).deselectAll();
						}
					}

					refreshConfigReplica();
				}
			}
		});
		Button btnDisableReplicas = new Button(compositeWidgetReplica, SWT.None);
		btnDisableReplicas.setText("Disable Replication");
		btnDisableReplicas.addListener(SWT.Selection, new Listener() {

			public void handleEvent(final Event event) {
				//zsnap = zfs;
				boolean checkValue=true;
				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("")){
					zfs.getZreplicas().zSchedulerProperties.get("name").setValue(zfs.getZvol().zProperties.get("name").getValue());
					zfs.zfsDisableReplicas();
					refreshConfigReplica();

				}

			}
		});

		scrolledReplicaConfig.setContent(compositeWidgetReplica);
		scrolledReplicaConfig.setExpandVertical(true);
		scrolledReplicaConfig.setExpandHorizontal(true);
		scrolledReplicaConfig.setMinSize(compositeWidgetReplica.computeSize(SWT.DEFAULT,SWT.DEFAULT));
	}




	public void refreshTreeZFSList(final TreeItem rootTree){

		thrConnect = new Thread(new Runnable() {
			public void run() {
				log.debug("start update ZFS volumes list ....");
				zfsList = zfs.zfsList();

				log.debug(zfsList.size());
				for (int i = 0; i < zfsList.size(); i++) {
					final int ind=i;
					log.debug("refreshTreeZFSList "+zfsList.get(i));
					zfs.zfsGetAllVolume(zfsList.get(i).toString());

					//zfs.zfsGetInfoByProperty(zfsList.get(i).toString(), "type");
					if ("filesystem".equals(zfs.getZvol().zProperties.get("type").getValue())){
						if (!zfs.getZvol().zProperties.get("quota").getValue().isEmpty() && !"none".equalsIgnoreCase(zfs.getZvol().zProperties.get("quota").getValue())){
							infoUsedSize=zfs.getZvol().zProperties.get("usedbydataset").getValue()+"/"+zfs.getZvol().zProperties.get("quota").getValue();
						}else{
							infoUsedSize=zfs.getZvol().zProperties.get("usedbydataset").getValue()+"/"+zfs.getZvol().zProperties.get("available").getValue();	
						}
						
					}else{
						infoUsedSize=zfs.getZvol().zProperties.get("used").getValue()+" / "+zfs.getZvol().zProperties.get("volsize").getValue();
					}
					if ( ("volume".equals(zfs.getZvol().zProperties.get("type").getValue()) && zfs.getIscsiListConfigVol(zfsList.get(i).toString()) && ! "".equalsIgnoreCase(zfs.getZiscsi().zProperties.get("tid").getValue()))
							|| ("filesystem".equals(zfs.getZvol().zProperties.get("type").getValue()) && "yes".equals(zfs.getZvol().zProperties.get("mounted").getValue()))	){
						Display.getDefault().syncExec(new Runnable() {
							public void run() {
								updateItemTreeZfsList(true, zfsList.get(ind).toString(),  rootTree,infoUsedSize,-1);
							}
						});	
					}else{
						Display.getDefault().syncExec(new Runnable() {
							public void run() {
								updateItemTreeZfsList(false, zfsList.get(ind).toString(),  rootTree,infoUsedSize,-1);
							}
						});
					}
				}
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						btnConnectServer.setEnabled(true);
						tabFolderNav.setEnabled(true);
						wPB.close();
					}
				});
			}	

		});
		thrConnect.start();
		log.debug("refreshZFSList");
	}

	public void refreshTreeZpoolList(){

		if (zfs.getCacheSession().containsKey(zfs.getZserver().zProperties.get("serverIP").getValue()) ){
			final TreeItem root = treeZpool.getSelection()[0];
			root.setImage(imageServerOnline);
			log.debug("refreshTreeZpoolList "+" "+keyProp);

			zpoolList = zfs.zpoolList();
			for (int indPool = 0; indPool < zpoolList.size(); indPool++) {
				TreeItem item = new TreeItem(root, 0);
				item.setText(zpoolList.get(indPool).toString());
				item.setImage(imageStorage);
				item.setData(zpoolList.get(indPool).toString());
				//new TreeItem(root, 0);
			}
			boolean checkExistInTree = false;

			for (int ind=0;ind<tree.getItemCount();ind++){
				log.debug("refreshTreeZpoolList "+tree.getItem(ind).getData().toString()+" "+zfs.getZserver().zProperties.get("serverIP").getValue());
				if ( tree.getItem(ind).getData().toString().equalsIgnoreCase(zfs.getZserver().zProperties.get("serverIP").getValue())){
					checkExistInTree=true;
				}
			}
			if ( ! checkExistInTree ){
				TreeItem rootTreeZvolFS = new TreeItem(tree,SWT.None);
				rootTreeZvolFS.setText(zfs.getZserver().zProperties.get("serverIP").getValue());
				rootTreeZvolFS.setData(zfs.getZserver().zProperties.get("serverIP").getValue());
				rootTreeZvolFS.setImage(imageStorageServer);
				refreshTreeZFSList(rootTreeZvolFS);	
			}else{
				btnConnectServer.setEnabled(true);
				tabFolderNav.setEnabled(true);
				wPB.close();
			}
		}else{
			treeZpool.clearAll(true);
			treeZpool.setItemCount(0);
			List<Object> listGetServer = zfs.getListServer();

			for (int i=0;i<listGetServer.size();i++){
				zfs.getServer(listGetServer.get(i).toString());
				final TreeItem root = new TreeItem(treeZpool,SWT.None);
				root.setText(zfs.getZserver().zProperties.get("serverIP").getValue());
				root.setData(zfs.getZserver().zProperties.get("serverIP").getValue());
				root.setImage(imageServerOffline);

			}

		}

	}


	private void refreshInfoServer(){
		String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zfs.getZserver().zProperties.get(keyProp).getType())) {
				for (int indLabel=0;indLabel<labelsFieldServer.size();indLabel++){
					if ( labelsFieldServer.get(indLabel).getData().equals(zfs.getZserver().zProperties.get(keyProp).getNameProperty()) ){
						labelsFieldServer.get(indLabel).setText(zfs.getZserver().zProperties.get(keyProp).getValue());
					}
				}
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZserver().zProperties.get(keyProp).getType())) {
					for (int indText=0;indText<textsFieldServer.size();indText++){
						if ( textsFieldServer.get(indText).getData().equals(zfs.getZserver().zProperties.get(keyProp).getNameProperty()) ){
							textsFieldServer.get(indText).setText(zfs.getZserver().zProperties.get(keyProp).getValue());
						}
					}
				}else{
					if ( "nofreeentry".equalsIgnoreCase(zfs.getZserver().zProperties.get(keyProp).getType())) {
						for (int indCombo=0;indCombo<combosFieldServer.size();indCombo++){
							if ( combosFieldServer.get(indCombo).getData().equals(zfs.getZserver().zProperties.get(keyProp).getNameProperty()) ){
								combosFieldServer.get(indCombo).setText(zfs.getZserver().zProperties.get(keyProp).getValue());
							}
						}
					}
				}
			}
		}
	}

	private void refreshInfoZpool(){

		String[] keysProp = (String[]) zfs.getZpool().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);
		log.debug(keysProp);
		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zfs.getZpool().zProperties.get(keyProp).getType())) {
				for (int indLabel=0;indLabel<labelsFieldPool.size();indLabel++){
					if ( labelsFieldPool.get(indLabel).getData().equals(zfs.getZpool().zProperties.get(keyProp).getNameProperty()) ){
						labelsFieldPool.get(indLabel).setText(zfs.getZpool().zProperties.get(keyProp).getValue());
					}
				}
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZpool().zProperties.get(keyProp).getType())) {
					for (int indText=0;indText<textsFieldPool.size();indText++){
						if ( textsFieldPool.get(indText).getData().equals(zfs.getZpool().zProperties.get(keyProp).getNameProperty()) ){
							textsFieldPool.get(indText).setText(zfs.getZpool().zProperties.get(keyProp).getValue());
						}
					}
				}else{
					if ( "nofreeentry".equalsIgnoreCase(zfs.getZpool().zProperties.get(keyProp).getType())) {
						for (int indCombo=0;indCombo<combosFieldPool.size();indCombo++){
							if ( combosFieldPool.get(indCombo).getData().equals(zfs.getZpool().zProperties.get(keyProp).getNameProperty()) ){
								combosFieldPool.get(indCombo).setText(zfs.getZserver().zProperties.get(keyProp).getValue());
							}
						}
					}
				}
			}
		}

		//Create Chart Provisioned Space
		dataCharset.clear();	
		if ( !zfs.getZpool().zProperties.get("realuseablespace").getValue().equals("")){

			String refUnit =zfs.getZpool().zProperties.get("realuseablespace").getValue().substring(zfs.getZpool().zProperties.get("realuseablespace").getValue().length()-1, zfs.getZpool().zProperties.get("realuseablespace").getValue().length());
			log.debug(refUnit);
			float provisionspace = zfs.convertInReferenceUnit(zfs.getZpool().zProperties.get("provisionspace").getValue(), refUnit);
			float realuseablespace = zfs.convertInReferenceUnit(zfs.getZpool().zProperties.get("realuseablespace").getValue(), refUnit);
			float provisionspaceInPourcent = guiTrt.dataInPourcent(provisionspace,realuseablespace);
			float freespace = realuseablespace - provisionspace;
			float freespaceInPourcent =  guiTrt.dataInPourcent(freespace,realuseablespace);
			this.dataCharset.put("Provisioned Space: "+ zfs.getZpool().zProperties.get("provisionspace").getValue(), provisionspaceInPourcent);
			this.dataCharset.put("Free Space: "+BigDecimal.valueOf(freespace).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue()+refUnit, freespaceInPourcent  );
			//this.dataCharset.put("Free : "+BigDecimal.valueOf(freeVal).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue()+guiTrt.getUnit(), (100-guiTrt.formatChartDataInPourcent(zfs.getZpool().zProperties.get("provisionedspace").getValue(), zfs.getZpool().zProperties.get("realuseablespace").getValue()))) ;
			PieDataset dataset = guiTrt.createDataset(dataCharset);  
			JFreeChart chartVolumeConfig = guiTrt.createChart(dataset, "Provisioned Space on "+zfs.getZpool().zProperties.get("realuseablespace").getValue());
			if ( chartVolumeComposite != null){
				if ( !chartVolumeComposite.isDisposed()){
					chartVolumeComposite.dispose();
				}	
			}

			//Create Grid for Chart
			gridDataChart =new GridData(SWT.FILL, SWT.FILL, true, true);
			//gridDataChart.heightHint = 200;
			//Create Composite for Chart
			chartVolumeComposite= new ChartComposite(compositeZpoolConfig, SWT.BORDER, chartVolumeConfig, true); 
			chartVolumeComposite.setLayoutData(gridDataChart);

			//Create Chart Used Space
			dataCharset.clear();
			log.debug(refUnit);
			float usedspace = zfs.convertInReferenceUnit(zfs.getZvol().zProperties.get("used").getValue(), refUnit);
			float usedspaceInPourcent = guiTrt.dataInPourcent(usedspace,realuseablespace);
			log.debug("usedspace :"+usedspace+" realuseablespace : "+realuseablespace+" usedspaceInPourcent "+usedspaceInPourcent);
			freespace = realuseablespace - usedspace;
			freespaceInPourcent =  guiTrt.dataInPourcent(freespace,realuseablespace);
			log.debug("freespace : "+freespace+" freespaceInPourcent :"+freespaceInPourcent);
			this.dataCharset.put("Used Space: "+ zfs.getZvol().zProperties.get("used").getValue(), usedspaceInPourcent);
			this.dataCharset.put("Free Space: "+BigDecimal.valueOf(freespace).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue()+refUnit, freespaceInPourcent  );
			//this.dataCharset.put("Free : "+BigDecimal.valueOf(freeVal).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue()+guiTrt.getUnit(), (100-guiTrt.formatChartDataInPourcent(zfs.getZpool().zProperties.get("provisionedspace").getValue(), zfs.getZpool().zProperties.get("realuseablespace").getValue()))) ;
			PieDataset datasetUsed = guiTrt.createDataset(dataCharset);  
			JFreeChart chartZpoolUsedSpace = guiTrt.createChart(datasetUsed, "Used Space on "+zfs.getZpool().zProperties.get("realuseablespace").getValue());
			if ( chartZpoolUsedComposite != null){
				if ( !chartZpoolUsedComposite.isDisposed()){
					chartZpoolUsedComposite.dispose();
				}	
			}

			//Create Grid for Chart
			gridDataChart =new GridData(SWT.FILL, SWT.FILL, true, true);
			gridDataChart.heightHint = 200;
			//gridDataChart.horizontalSpan = 2;
			//Create Composite for Chart
			chartZpoolUsedComposite= new ChartComposite(compositeZpoolConfig, SWT.BORDER, chartZpoolUsedSpace, true); 
			chartZpoolUsedComposite.setLayoutData(gridDataChart);


			compositeZpoolConfig.layout();	
		}

	}

	private void  refreshDisks(){
		zfs.getZpoolStatus();
		for ( int cptL=0;cptL<labelsFieldDisks.size();cptL++){
			if ( !labelsFieldDisks.get(cptL).isDisposed()){
				labelsFieldDisks.get(cptL).dispose();	
			}
		}
		for ( int cptL=0;cptL<labelsFieldZRaid.size();cptL++){
			if ( !labelsFieldZRaid.get(cptL).isDisposed()){
				labelsFieldZRaid.get(cptL).dispose();	
			}
		}

		if ( groupDisks != null && !groupDisks.isDisposed()){
			groupDisks.dispose();
		}
		groupDisks = new Group(compositeDisks,SWT.NONE);
		groupDisks.setBackground(groupBackgroundColor);
		groupDisks.setLayout(new GridLayout());

		GridData gridDataDisks=new GridData(SWT.FILL, SWT.FILL, true, true);
		gridDataDisks.horizontalSpan=6;
		groupDisks.setLayoutData(gridDataDisks);

		if (scrolledDisks != null && !scrolledDisks.isDisposed()){
			scrolledDisks.isDisposed();
		}
		scrolledDisks=new ScrolledComposite(groupDisks,SWT.V_SCROLL);
		scrolledDisks.setLayoutData(new GridData(GridData.FILL_BOTH));

		if (compositeWidgetDisks != null && !compositeWidgetDisks.isDisposed()){
			compositeWidgetDisks.isDisposed();
		}
		compositeWidgetDisks=new Composite(scrolledDisks,SWT.NONE);
		compositeWidgetDisks.setBackground(compositeBackgroundColor);
		GridLayout gridLayoutWidgetDisks = new GridLayout();
		gridLayoutWidgetDisks.numColumns =6;
		compositeWidgetDisks.setLayout(gridLayoutWidgetDisks);

		GridData gridDataTitleDisks = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitleDisks.horizontalSpan = 6;
		if (compositeWidgetDisks != null && !compositeWidgetDisks.isDisposed()){
			compositeWidgetDisks.isDisposed();
		}
		Label lblTitleInfoDisks = new Label(compositeWidgetDisks, SWT.CENTER|SWT.BORDER);
		lblTitleInfoDisks.setLayoutData(gridDataTitleDisks);
		lblTitleInfoDisks.setFont(fontTitle);
		lblTitleInfoDisks.setBackground(labelTitleBackgroundColor);
		lblTitleInfoDisks.setText("ZFS Informations Disks");

		String[] keysPropHashDisks = (String[]) zfs.getHashDisks().keySet().toArray(new String[0]);
		Arrays.sort(keysPropHashDisks);
		String[] keysPropHashZraid = (String[]) zfs.getHashZRaid().keySet().toArray(new String[0]);
		Arrays.sort(keysPropHashZraid);
		//Arrays.sort(keysPropHashZraid);
		for (int cptZraid=0;cptZraid<zfs.getHashZRaid().size();cptZraid++){

			String keyPropHashZraid = keysPropHashZraid[cptZraid];
			GridData gridDataLabelZraid = new GridData(GridData.FILL, GridData.CENTER, true, false);
			gridDataLabelZraid.horizontalSpan=6;
			if (zfs.getZpool().zProperties.get("name").getValue().equalsIgnoreCase(zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("poolname").getValue())){
				//			lbl.setText(zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("name").getValue()+" "+zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("raidid").getValue()+zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("raidtype").getValue());
				if ( !"".equals(zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("raidid").getValue())){
					String labelTextZraid="Pool : "+zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("poolname").getValue()+" - "+"Type : "+zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("raidtype").getValue()+ " ID : "+zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("raidid").getValue();
					labelsFieldZRaid.add(new Label(compositeWidgetDisks, SWT.BORDER|SWT.CENTER));
					labelsFieldZRaid.get(labelsFieldZRaid.size()-1).setLayoutData(gridDataLabelZraid);
					labelsFieldZRaid.get(labelsFieldZRaid.size()-1).setFont(fontSubTitle);
					labelsFieldZRaid.get(labelsFieldZRaid.size()-1).setBackground(labelFieldBackgroundColor);
					labelsFieldZRaid.get(labelsFieldZRaid.size()-1).setText(labelTextZraid);
					labelsFieldZRaid.get(labelsFieldZRaid.size()-1).setData(labelTextZraid);
				}


				for (int cpt=0;cpt<keysPropHashDisks.length;cpt++){
					//log.debug("RefreshDisks "+keysPropHashDisks[cpt] );
					String keyPropHashDisks = keysPropHashDisks[cpt];
					if (zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("poolname").getValue().equalsIgnoreCase(zfs.getZpool().zProperties.get("name").getValue())&& zfs.getHashZRaid().get(keyPropHashZraid).zProperties.get("raidid").getValue().equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("raidid").getValue())){

						labelsFieldDisks.add(new Label(compositeWidgetDisks, SWT.NONE));
						labelsFieldDisks.get(labelsFieldDisks.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						labelsFieldDisks.get(labelsFieldDisks.size()-1).setFont(fontWidget);
						labelsFieldDisks.get(labelsFieldDisks.size()-1).setBackground(labelFieldBackgroundColor);

						if (!"0".equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("errorread").getValue()) ||
								!"0".equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("errorwrite").getValue()) ||
								!"0".equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("errorchecksum").getValue())||
								(!"".equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("smarthealthstatus").getValue()) && 
										!"OK".equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get("smarthealthstatus").getValue()))
								){
							labelsFieldDisks.get(labelsFieldDisks.size()-1).setImage(imageHardDiskOffline);	
						}else{
							labelsFieldDisks.get(labelsFieldDisks.size()-1).setImage(imageHardDiskOnline);
						}

						//labelsFieldZRaid.get(labelsFieldZRaid.size()-1).setData(labelTextZraid);
						String[] keysProp = (String[]) zfs.getHashDisks().get(keyPropHashDisks).zProperties.keySet().toArray(new String[0]);
						Arrays.sort(keysProp);
						String valueProp="";

						for (int i = 0; i < keysProp.length; i++) {
							keyProp = keysProp[i];
							if ( "noupdateable".equalsIgnoreCase(zfs.getHashDisks().get(keyPropHashDisks).zProperties.get(keyProp).getType()) ){
								valueProp = valueProp+zfs.getHashDisks().get(keyPropHashDisks).zProperties.get(keyProp).getLabelProperty()+" :"+zfs.getHashDisks().get(keyPropHashDisks).zProperties.get(keyProp).getValue()+"\n";
							}
						}	
						labelsFieldDisks.get(labelsFieldDisks.size()-1).setToolTipText(valueProp);	
						//log.debug(valueProp);
					}

				}	
			}

		}
		scrolledDisks.setContent(compositeWidgetDisks);
		scrolledDisks.setExpandVertical(true);
		scrolledDisks.setExpandHorizontal(true);
		scrolledDisks.setMinSize(compositeWidgetDisks.computeSize(SWT.DEFAULT,SWT.DEFAULT));

		scrolledDisks.layout();
		groupDisks.layout();
		compositeWidgetDisks.layout();
		compositeDisks.layout();
		tabFolderConfig.layout();

	}


	private void  refreshCreateZfsVolFS(){

		String[] keysProp = (String[]) zfs.getZvol().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);
		log.debug("Label SIze "+labelsFieldCreateVol.size());
		for ( int cptL=0;cptL<labelsFieldCreateVol.size();cptL++){
			labelsFieldCreateVol.get(cptL).dispose();	

		}
		for ( int cptL=0;cptL<textsFieldCreateVol.size();cptL++){
			textsFieldCreateVol.get(cptL).dispose();	
		}
		for ( int cptL=0;cptL<combosFieldCreateVol.size();cptL++){
			combosFieldCreateVol.get(cptL).dispose();	
		}
		labelsFieldCreateVol.clear();
		textsFieldCreateVol.clear();
		combosFieldCreateVol.clear();
		if (btnCreateZfsVolFS!=null && !btnCreateZfsVolFS.isDisposed()){
			btnCreateZfsVolFS.dispose();
		}
		if (groupCreateVolFS !=null && !groupCreateVolFS.isDisposed()){
			groupCreateVolFS.dispose();
		}
		if (scrolledCreateVol !=null &&!scrolledCreateVol.isDisposed()){
			scrolledCreateVol.dispose();
		}
		if (compositeWidgetCreateVolFS!=null && !compositeWidgetCreateVolFS.isDisposed()){
			compositeWidgetCreateVolFS.dispose();
		}




		groupCreateVolFS=new Group(compositeCreateVolFS,SWT.NONE);
		groupCreateVolFS.setBackground(groupBackgroundColor);
		groupCreateVolFS.setLayout(new GridLayout());
		//GridData gridData=new GridData(GridData.FILL_HORIZONTAL);
		GridData gridData=new GridData(SWT.FILL, SWT.FILL, true, true);
		//gridData.heightHint=450;
		groupCreateVolFS.setLayoutData(gridData);
		scrolledCreateVol=new ScrolledComposite(groupCreateVolFS,SWT.V_SCROLL);
		scrolledCreateVol.setLayoutData(new GridData(GridData.FILL_BOTH));
		compositeWidgetCreateVolFS=new Composite(scrolledCreateVol,SWT.NONE);
		compositeWidgetCreateVolFS.setBackground(compositeBackgroundColor);
		GridLayout gridLayoutPane = new GridLayout();
		gridLayoutPane.numColumns =2;
		compositeWidgetCreateVolFS.setLayout(gridLayoutPane);

		GridData gridDataTitle = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataTitle.horizontalSpan = 2;
		Label lblTitle = new Label(compositeWidgetCreateVolFS, SWT.CENTER|SWT.BORDER);
		lblTitle.setLayoutData(gridDataTitle);
		lblTitle.setFont(fontTitle);
		lblTitle.setBackground(labelTitleBackgroundColor);
		lblTitle.setText("Create a ZFS Volume or ZFS FileSystem");



		labelsFieldCreateVol.add(new Label(compositeWidgetCreateVolFS, SWT.NONE));
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setBackground(labelFieldBackgroundColor);
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get("type").getLabelProperty());
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get("type").getNameProperty());

		combosFieldCreateVol.add(new Combo(compositeWidgetCreateVolFS, SWT.NONE));
		combosFieldCreateVol.get(combosFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
		combosFieldCreateVol.get(combosFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get("type").getNameProperty());
		String[] keysPermitValue = (String[]) zfs.getZvol().zProperties.get("type").getPermitValue().keySet().toArray(new String[0]);
		for (int cpt=0;cpt <zfs.getZvol().zProperties.get("type").getPermitValue().size();cpt++){
			String keyPermitValue = keysPermitValue[cpt];
			combosFieldCreateVol.get(combosFieldCreateVol.size()-1).add(zfs.getZvol().zProperties.get("type").getPermitValue().get(keyPermitValue).toString());
		}

		combosFieldCreateVol.get(combosFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get("type").getValue());
		//zfs.getZvol().zProperties.get("type").setValue(zfs.getZvol().zProperties.get("type").getPermitValue().get("volume").toString());
		combosFieldCreateVol.get(combosFieldCreateVol.size()-1).addListener(SWT.Selection, new Listener() {

			public void handleEvent(final Event event) {
				final Combo comboType = (Combo) event.widget;


				zfs.getZvol().zProperties.get("type").setValue(comboType.getText());
				refreshCreateZfsVolFS();
				compositeWidgetCreateVolFS.layout();
				compositeCreateVolFS.layout();

				log.debug(combosFieldCreateVol.size());
			}
		});

		labelsFieldCreateVol.add(new Label(compositeWidgetCreateVolFS, SWT.NONE));
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setBackground(labelFieldBackgroundColor);
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get("name").getLabelProperty());
		labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get("name").getNameProperty());

		textsFieldCreateVol.add(new Text(compositeWidgetCreateVolFS, SWT.WRAP|SWT.BORDER));
		textsFieldCreateVol.get(textsFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
		textsFieldCreateVol.get(textsFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get("name").getNameProperty());
		textsFieldCreateVol.get(textsFieldCreateVol.size()-1).setText("");

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			log.debug(keyProp);
			if ( ("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && 
					("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) || 
							"volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf())) ) ||
							("filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && 
									("fs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) || 
											"volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) ) )		
											|| ("snapshot".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && "volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()))

					){
				log.debug("DEBUG : "+ keyProp+ " "+zfs.getZvol().zProperties.get(keyProp).getType());
				if ( "freeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType()) ||keyProp =="volblocksize"){
					labelsFieldCreateVol.add(new Label(compositeWidgetCreateVolFS, SWT.NONE));
					labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setBackground(labelFieldBackgroundColor);
					labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getLabelProperty());
					labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());

					textsFieldCreateVol.add(new Text(compositeWidgetCreateVolFS, SWT.WRAP|SWT.BORDER));
					textsFieldCreateVol.get(textsFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					textsFieldCreateVol.get(textsFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
					textsFieldCreateVol.get(textsFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());

				}else{

					if ( "nofreeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType()) && !"type".equals(keyProp)){
						labelsFieldCreateVol.add(new Label(compositeWidgetCreateVolFS, SWT.NONE));
						labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setBackground(labelFieldBackgroundColor);
						labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getLabelProperty());
						labelsFieldCreateVol.get(labelsFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());

						combosFieldCreateVol.add(new Combo(compositeWidgetCreateVolFS, SWT.NONE));
						combosFieldCreateVol.get(combosFieldCreateVol.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						combosFieldCreateVol.get(combosFieldCreateVol.size()-1).setData(zfs.getZvol().zProperties.get(keyProp).getNameProperty());
						combosFieldCreateVol.get(combosFieldCreateVol.size()-1).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
						keysPermitValue = (String[]) zfs.getZvol().zProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
						for (int cpt=0;cpt <zfs.getZvol().zProperties.get(keyProp).getPermitValue().size();cpt++){
							String keyPermitValue = keysPermitValue[cpt];
							combosFieldCreateVol.get(combosFieldCreateVol.size()-1).add(zfs.getZvol().zProperties.get(keyProp).getPermitValue().get(keyPermitValue).toString());
						}
					}

				}

			}

		}


		scrolledCreateVol.setContent(compositeWidgetCreateVolFS);
		scrolledCreateVol.setExpandVertical(true);
		scrolledCreateVol.setExpandHorizontal(true);
		scrolledCreateVol.setMinSize(compositeWidgetCreateVolFS.computeSize(SWT.DEFAULT,SWT.DEFAULT));


		if (groupActiveIscsi!=null && !groupActiveIscsi.isDisposed() ){
			groupActiveIscsi.dispose();
		}
		if  ("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())){
			groupActiveIscsi=new Group(compositeCreateVolFS,SWT.NONE);
			groupActiveIscsi.setBackground(groupBackgroundColor);
			groupActiveIscsi.setLayout(new GridLayout());
			GridLayout gridLayoutActiveIscsi = new GridLayout();
			gridLayoutActiveIscsi.numColumns =2;
			groupActiveIscsi.setLayout(gridLayoutActiveIscsi);
			//GridData gridDataActiveIscsi=new GridData(GridData.FILL_HORIZONTAL);
			GridData gridDataActiveIscsi=new GridData(SWT.FILL, SWT.FILL, true, true);
			//gridDataActiveIscsi.heightHint=200;
			groupActiveIscsi.setLayoutData(gridDataActiveIscsi);

			GridData gridDataTitleIscsi = new GridData(GridData.FILL, GridData.CENTER, true, false);
			gridDataTitleIscsi.horizontalSpan = 2;
			//Iscsi Section
			Label lblTitleIscsi = new Label(groupActiveIscsi, SWT.CENTER|SWT.BORDER);
			lblTitleIscsi.setLayoutData(gridDataTitleIscsi);
			lblTitleIscsi.setFont(fontTitle);
			lblTitleIscsi.setBackground(labelTitleBackgroundColor);
			lblTitleIscsi.setText("ISCSI Parameters");
			keysProp = (String[]) zfs.getZiscsi().zProperties.keySet().toArray(new String[0]);
			Arrays.sort(keysProp);
			labelsFieldCreateIscsi.clear();
			textsFieldCreateIscsi.clear();
			combosFieldCreateIscsi.clear();
			for (int i = 0; i < keysProp.length; i++) {
				keyProp = keysProp[i];


				if ( "noupdateable".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
					Label lbl = new Label(groupActiveIscsi, SWT.NONE);
					lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					lbl.setText(zfs.getZiscsi().zProperties.get(keyProp).getLabelProperty());
					lbl.setFont(fontWidget);
					lbl.setBackground(labelFieldBackgroundColor);
					labelsFieldCreateIscsi.add(new Label(groupActiveIscsi, SWT.NONE));
					labelsFieldCreateIscsi.get(labelsFieldCreateIscsi.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
					labelsFieldCreateIscsi.get(labelsFieldCreateIscsi.size()-1).setBackground(labelFieldBackgroundColor);
					//labelsField.get(labelsField.size()-1).setText(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
					labelsFieldCreateIscsi.get(labelsFieldCreateIscsi.size()-1).setData(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
				}else{
					if ( "freeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())){
						Label lbl = new Label(groupActiveIscsi, SWT.NONE);
						lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						lbl.setText(zfs.getZiscsi().zProperties.get(keyProp).getLabelProperty());
						lbl.setFont(fontWidget);
						lbl.setBackground(labelFieldBackgroundColor);

						textsFieldCreateIscsi.add(new Text(groupActiveIscsi, SWT.WRAP|SWT.BORDER));
						textsFieldCreateIscsi.get(textsFieldCreateIscsi.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
						textsFieldCreateIscsi.get(textsFieldCreateIscsi.size()-1).setBackground(textFieldBackgroundColor);
						//textsField.get(textsField.size()-1).setText(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
						textsFieldCreateIscsi.get(textsFieldCreateIscsi.size()-1).setData(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());

					}else{

						if ( "nofreeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())){
							Label lbl = new Label(groupActiveIscsi, SWT.NONE);
							lbl.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
							lbl.setText(zfs.getZiscsi().zProperties.get(keyProp).getLabelProperty());
							lbl.setFont(fontWidget);
							lbl.setBackground(labelFieldBackgroundColor);

							combosFieldCreateIscsi.add(new Combo(groupActiveIscsi, SWT.NONE));
							combosFieldCreateIscsi.get(combosFieldCreateIscsi.size()-1).setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
							combosFieldCreateIscsi.get(combosFieldCreateIscsi.size()-1).setData(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());
							//combosField.get(combosField.size()-1).setText(zfs.getZiscsi().zProperties.get(keyProp).getValue());
							keysPermitValue = (String[]) zfs.getZiscsi().zProperties.get(keyProp).getPermitValue().keySet().toArray(new String[0]);
							for (int cpt=0;cpt <zfs.getZiscsi().zProperties.get(keyProp).getPermitValue().size();cpt++){
								String keyPermitValue = keysPermitValue[cpt];
								combosFieldCreateIscsi.get(combosFieldCreateIscsi.size()-1).add(zfs.getZiscsi().zProperties.get(keyProp).getPermitValue().get(keyPermitValue).toString());
							}
						}
					}

				}
				log.debug("DEBUG : "+ keyProp+ " "+zfs.getZiscsi().zProperties.get(keyProp).getType());

			}

		}
		btnCreateZfsVolFS = new Button(compositeCreateVolFS, SWT.None);
		GridData gridDataBtnCreateZfsVolFS = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridDataBtnCreateZfsVolFS.horizontalSpan = 2;
		btnCreateZfsVolFS.setLayoutData(gridDataBtnCreateZfsVolFS);
		btnCreateZfsVolFS.setText("Create Now");
		btnCreateZfsVolFS.addListener(SWT.Selection, new Listener() {

			public void handleEvent(final Event event) {

				for (int indText=0;indText<textsFieldCreateVol.size();indText++){
					if (textsFieldCreateVol.get(indText).getData().toString().equals("name")){
						zfs.getZvol().zProperties.get("name").setValue(textsFieldCreateVol.get(indText).getText());
					}
				}
				if (! zfs.getZvol().zProperties.get("name").getValue().equalsIgnoreCase("") ){
					String[] keysProp = (String[]) zfs.getZvol().zProperties.keySet().toArray(new String[0]);
					Arrays.sort(keysProp);
					for (int i = 0; i < keysProp.length; i++) {
						keyProp = keysProp[i];
						log.debug(keyProp);
						if ( ("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && 
								("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) || 
										"volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf())) ) ||
										("filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && 
												("fs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) || 
														"volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()) ) )		
														|| ("snapshot".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue()) && "volandfs".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getPropertyOf()))

								){
							log.debug("DEBUG : "+ keyProp+ " "+zfs.getZvol().zProperties.get(keyProp).getType());
							if ( "freeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType()) ||keyProp =="volblocksize"){
								for (int indText=0;indText<textsFieldCreateVol.size();indText++){
									if ( textsFieldCreateVol.get(indText).getData().equals(keyProp) ){
										zfs.getZvol().zProperties.get(keyProp).setValue(textsFieldCreateVol.get(indText).getText());
									}
								}
							}else{

								if ( "nofreeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType()) && !"type".equals(keyProp)){
									for (int indCombo=0;indCombo<combosFieldCreateVol.size();indCombo++){
										if ( combosFieldCreateVol.get(indCombo).getData().equals(keyProp) ){
											zfs.getZvol().zProperties.get(keyProp).setValue(combosFieldCreateVol.get(indCombo).getText());
										}
									}
								}
							}
						}
					}

					thrCreateZFSVol = new Thread(new Runnable(){
						public void run() {
							Display.getDefault().syncExec(new Runnable() {
								public void run() {
									if (wPB.s.isDisposed()){
										wPB = new guiProgress(shell.getDisplay(), shell.getLocation().x, shell.getLocation().y);
										wPB.open();
									}else{
										wPB.open();
									}


								}
							});

							zfs.zfsCreateVolFS();
							Display.getDefault().syncExec(new Runnable(){
								public void run(){
									String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);
									//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
									Arrays.sort(keysPropError);
									String textBox = "";
									for (int i = 0; i < keysPropError.length; i++) {
										String keyPropError = keysPropError[i];
										textBox = textBox +zfs.getError().get(keyPropError)+".\n";
									}
									if (keysPropError.length>0){
										MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
										messageBoxInfo.setText("Warning");
										messageBoxInfo.setMessage(textBox);
										messageBoxInfo.open();
										wPB.close();
									}else{
										if ("volume".equals(zfs.getZvol().zProperties.get("type").getValue())||
												"snapshot".equals(zfs.getZvol().zProperties.get("type").getValue())){

											String[] keysProp = (String[]) zfs.getZiscsi().zProperties.keySet().toArray(new String[0]);
											Arrays.sort(keysProp);

											for (int i = 0; i < keysProp.length; i++) {
												keyProp = keysProp[i];
												log.debug("btnCreateIscsi :"+keyProp);
												if ( "noupdateable".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
													for (int indLabel=0;indLabel<labelsFieldCreateIscsi.size();indLabel++){
														if ( labelsFieldCreateIscsi.get(indLabel).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
															zfs.getZiscsi().zProperties.get(keyProp).setValue(labelsFieldCreateIscsi.get(indLabel).getText());
														}
													}
												}else{
													if ( "freeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
														for (int indText=0;indText<textsFieldCreateIscsi.size();indText++){
															if ( textsFieldCreateIscsi.get(indText).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
																zfs.getZiscsi().zProperties.get(keyProp).setValue(textsFieldCreateIscsi.get(indText).getText());
															}
														}

													}else{

														if ( "nofreeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
															for (int indList=0;indList<combosFieldCreateIscsi.size();indList++){
																log.debug("first loop"+combosFieldCreateIscsi.get(indList).getData()+" "+zfs.getZiscsi().zProperties.get(keyProp).getNameProperty());

																if ( combosFieldCreateIscsi.get(indList).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
																	zfs.getZiscsi().zProperties.get(keyProp).setValue(combosFieldCreateIscsi.get(indList).getText());
																	log.debug(zfs.getZiscsi().zProperties.get(keyProp).getMultivalues());
																}
															}
														}
													}
												}
											}
											if ("snapshot".equals(zfs.getZvol().zProperties.get("type").getValue())){
												zfs.getZiscsi().zProperties.get("iomode").setValue("ro");
											}
											zfs.getZiscsi().zProperties.get("name").setValue(zfs.getZpool().zProperties.get("name").getValue()+"/"+zfs.getZvol().zProperties.get("name").getValue());
											zfs.zfsCreateIscsi();
											keysPropError = zfs.getError().keySet().toArray(new String[0]);
											//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
											Arrays.sort(keysPropError);
											textBox = "";
											for (int i = 0; i < keysPropError.length; i++) {
												String keyPropError = keysPropError[i];
												textBox = textBox +zfs.getError().get(keyPropError)+".\n";
											}
											if (keysPropError.length>0){
												MessageBox messageBoxInfo = new MessageBox(shell, SWT.DIALOG_TRIM);
												messageBoxInfo.setText("Warning");
												messageBoxInfo.setMessage("ZFS Volume created but ISCSI Configuration is failed.\n"+textBox);
												messageBoxInfo.open();
												wPB.close();
											}
										}


										int indRoot=0;
										int indItem=0;
										for (int indT=0;indT<tree.getItemCount();indT++){
											if (tree.getItem(indT).getData().toString().equals(zfs.getZserver().zProperties.get("serverIP").getValue())){
												for (int indTreeVolFS=0;indTreeVolFS<tree.getItem(indT).getItemCount();indTreeVolFS++){
													if (tree.getItem(indT).getItem(indTreeVolFS).getData().toString().compareTo(zfs.getZpool().zProperties.get("name").getValue()+"/"+zfs.getZvol().zProperties.get("name").getValue()) >0){
														if (zfs.getError().size()>0){
															updateItemTreeZfsList(false, zfs.getZpool().zProperties.get("name").getValue()+"/"+zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), null ,indTreeVolFS);
														}else{
															updateItemTreeZfsList(true, zfs.getZpool().zProperties.get("name").getValue()+"/"+zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), null ,indTreeVolFS);
														}
														indRoot=indT;
														indItem=indTreeVolFS;
														break;
													}
												}
												if ( indItem==0){
													int indTreeVolFS=tree.getItem(indT).getItemCount();
													if (zfs.getError().size()>0){
														updateItemTreeZfsList(false, zfs.getZpool().zProperties.get("name").getValue()+"/"+zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), null ,indTreeVolFS);
													}else{
														updateItemTreeZfsList(true, zfs.getZpool().zProperties.get("name").getValue()+"/"+zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), null ,indTreeVolFS);
													}
													indRoot=indT;
													indItem=indTreeVolFS;
												}
												tree.layout();
											}
										}

										log.debug("Create Vol ISCI "+zfs.getZvol().zProperties.get("type").getValue());
										compositeTabVolConfig.layout();
										wPB.close();

										refreshCreateZfsVolFS();
									}
								}
							});
						}
					});
					thrCreateZFSVol.start();
				}
			}
		});
		compositeCreateVolFS.layout();
	}

	private void refreshIscsiSession(){


		zfs.getIscsiListConfigVol(zfs.getZvol().zProperties.get("name").getValue());	
		log.debug("refreshIscsiSesiont : "+zfs.getZiscsi().zProperties.get("sid").getMultivalues().size());



		tableIscsiSession.removeAll();
		for (int i=0;i<zfs.getZiscsi().zProperties.get("sid").getMultivalues().size();i++){
			TableItem item = new TableItem(tableIscsiSession, SWT.NONE);
			item.setText(0, zfs.getZiscsi().zProperties.get("sid").getMultivalues().get(i).toString());
			item.setText(1, zfs.getZiscsi().zProperties.get("sessionIP").getMultivalues().get(i).toString());

		}
		String[] keysProp = (String[]) zfs.getZiscsi().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
				for (int indLabel=0;indLabel<labelsFieldAddIscsi.size();indLabel++){
					if ( labelsFieldAddIscsi.get(indLabel).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
						labelsFieldAddIscsi.get(indLabel).setText(zfs.getZiscsi().zProperties.get(keyProp).getValue());
					}
				}
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
					for (int indText=0;indText<textsFieldAddIscsi.size();indText++){
						if ( textsFieldAddIscsi.get(indText).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
							textsFieldAddIscsi.get(indText).setText(zfs.getZiscsi().zProperties.get(keyProp).getValue());
						}
					}

				}else{

					if ( "nofreeentry".equalsIgnoreCase(zfs.getZiscsi().zProperties.get(keyProp).getType())) {
						for (int indCombo=0;indCombo<combosFieldAddIscsi.size();indCombo++){
							if ( combosFieldAddIscsi.get(indCombo).getData().equals(zfs.getZiscsi().zProperties.get(keyProp).getNameProperty()) ){
								combosFieldAddIscsi.get(indCombo).setText(zfs.getZiscsi().zProperties.get(keyProp).getValue());
							}
						}
					}
				}
			}
		}
	}

	private void refreshConfigSnapshot(){

		zsnap = zfs;
		zsnap.getZsnapshotConfig();
		String[] keysProp = (String[]) zsnap.getZsnapshots().zSchedulerProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
				for (int indLabel=0;indLabel<labelsFieldSnapshots.size();indLabel++){
					if ( labelsFieldSnapshots.get(indLabel).getData().equals(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty()) ){
						labelsFieldSnapshots.get(indLabel).setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());
						log.debug("REFRESHConfig 1: ");
					}
				}
			}else{
				if ( "freeentry".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
					for (int indText=0;indText<textsFieldSnapshots.size();indText++){
						if ( textsFieldSnapshots.get(indText).getData().equals(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty()) ){
							textsFieldSnapshots.get(indText).setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());
							log.debug("REFRESHConfig2 : ");
						}
					}

				}else{

					if ( "nofreeentry".equalsIgnoreCase(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getType())) {
						for (int indCombo=0;indCombo<listsFieldSnaphots.size();indCombo++){
							if ( listsFieldSnaphots.get(indCombo).getData().equals(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getNameProperty()) ){
								//listsFieldSnaphots.get(indCombo).setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());
								labelsFieldSnapshotsValue.get(indCombo).setText("Current values : "+zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());
								log.debug("REFRESHConfig3 : "+zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());

							}
						}
					}
				}
			}
		}
	}

	private void refreshConfigReplica(){

		//zsnap = zfs;
		zfs.getZreplicaConfig();
		String[] keysProp = (String[]) zfs.getZreplicas().zSchedulerProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		for (int i = 0; i < keysProp.length; i++) {
			keyProp = keysProp[i];
			if ( "noupdateable".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())) {
				for (int indLabel=0;indLabel<labelsFieldReplica.size();indLabel++){
					if ( labelsFieldReplica.get(indLabel).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
						labelsFieldReplica.get(indLabel).setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
						log.debug("REFRESHConfig 1: ");
					}
				}
			}else{
				if ( "freeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())) {
					for (int indText=0;indText<textsFieldReplica.size();indText++){
						if ( textsFieldReplica.get(indText).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
							textsFieldReplica.get(indText).setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
							log.debug("REFRESHConfig2 : ");
						}
					}

				}else{

					if ( "nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())&& zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() !=null) {
						for (int indCombo=0;indCombo<listsFieldReplica.size();indCombo++){
							if ( listsFieldReplica.get(indCombo).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
								//listsFieldSnaphots.get(indCombo).setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());
								labelsFieldReplicaValue.get(indCombo).setText("Current values : "+zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
								log.debug("REFRESHConfig3 : "+zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());

							}
						}
					}
					if ( "nofreeentry".equalsIgnoreCase(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getType())&& zfs.getZreplicas().zSchedulerProperties.get(keyProp).getPermitValue() ==null) {
						for (int indCombo=0;indCombo<combosFieldReplica.size();indCombo++){

							if (keyProp.equalsIgnoreCase("server")){
								for (int indLabel=0;indLabel<labelsFieldReplica.size();indLabel++){
									if ( labelsFieldReplica.get(indLabel).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
										labelsFieldReplica.get(indLabel).setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
										log.debug("REFRESHConfig 1: ");
									}
								}

								if ( combosFieldReplica.get(indCombo).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
									combosFieldReplica.get(indCombo).removeAll();
									String[] keysPropSrv = (String[]) zfs.getCacheSession().keySet().toArray(new String[0]);
									Arrays.sort(keysPropSrv);
									for (int cptSrv=0;cptSrv<keysPropSrv.length;cptSrv++){
										String keyPropSrv=keysPropSrv[cptSrv];
										combosFieldReplica.get(indCombo).add(keyPropSrv);
									}
									//listsFieldSnaphots.get(indCombo).setText(zsnap.getZsnapshots().zSchedulerProperties.get(keyProp).getValue());
									//combosFieldReplica.get(indCombo).setText("Current values : "+zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
									log.debug("REFRESHConfig3 : "+zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
									combosFieldReplica.get(indCombo).setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
								}
							}else{
								if ( combosFieldReplica.get(indCombo).getData().equals(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getNameProperty()) ){
									combosFieldReplica.get(indCombo).setText(zfs.getZreplicas().zSchedulerProperties.get(keyProp).getValue());
								}
							}
						}

					}
				}
			}
		}
	}



	private void refreshConfigVolume(){

		String[] keysProp = (String[]) zfs.getZvol().zProperties.keySet().toArray(new String[0]);
		Arrays.sort(keysProp);

		if ( "snapshot".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())) {
			for (int i=0;i<keysProp.length;i++){
				keyProp = keysProp[i];
				for (int indLabel=0;indLabel<labelsField.size();indLabel++){
					if ( labelsField.get(indLabel).getData().equals(zfs.getZvol().zProperties.get(keyProp).getNameProperty()) ){
						labelsField.get(indLabel).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
					}
				}
			}
		}else{
			for (int i=0;i<keysProp.length;i++){
				keyProp = keysProp[i];
				if ( "noupdateable".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType())) {
					for (int indLabel=0;indLabel<labelsField.size();indLabel++){
						if ( labelsField.get(indLabel).getData().equals(zfs.getZvol().zProperties.get(keyProp).getNameProperty())){
							labelsField.get(indLabel).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
						}

					}
				}else{
					if ( "freeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType())) {
						for (int indText=0;indText<textsField.size();indText++){
							if ( textsField.get(indText).getData().equals(zfs.getZvol().zProperties.get(keyProp).getNameProperty()) ){
								textsField.get(indText).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
							}
						}

					}else{

						if ( "nofreeentry".equalsIgnoreCase(zfs.getZvol().zProperties.get(keyProp).getType())) {
							for (int indCombo=0;indCombo<combosField.size();indCombo++){
								if ( combosField.get(indCombo).getData().equals(zfs.getZvol().zProperties.get(keyProp).getNameProperty()) ){
									combosField.get(indCombo).setText(zfs.getZvol().zProperties.get(keyProp).getValue());
								}
							}
						}
					}
				}
			}
			Button btnSaveChange = new Button(compositeConfig,SWT.WRAP|SWT.BORDER);
			GridData gridDataBtnSaveChanges = new GridData(GridData.FILL, GridData.CENTER, true, false);
			//gridDataChart.heightHint = 250;
			//gridDataChart.horizontalSpan = 2;
			btnSaveChange.setText("Save Changes");
			btnSaveChange.setLayoutData(gridDataBtnSaveChanges);
			Button btnDestroyVolFS = new Button(compositeConfig,SWT.WRAP|SWT.BORDER);
			GridData gridDataBtnDestroyVolFS = new GridData(GridData.FILL, GridData.CENTER, true, false);
			btnSaveChange.setEnabled(false);
			//gridDataChart.heightHint = 250;
			//gridDataChart.horizontalSpan = 2;
			btnDestroyVolFS.setText("Delete");
			btnDestroyVolFS.setLayoutData(gridDataBtnDestroyVolFS);
			btnDestroyVolFS.addListener(SWT.Selection, new Listener() {

				public void handleEvent(final Event event) {
					log.debug("btnDestroyVolFS.addListener :"+zfs.getZvol().zProperties.get("name").getValue()+" "+zfs.getZvol().zProperties.get("type").getValue());
					destroyVolFS();
				}
			});

			guiTrt=new guiTrt();
			//create Chart
			if ( "volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())) {
				guiTrt.formatChartValue(zfs.getZvol().zProperties.get("volsize").getValue(), zfs.getZvol().zProperties.get("usedbydataset").getValue(), zfs.getZvol().zProperties.get("usedbysnapshots").getValue());	
			}else{
				if ( "filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())) {
					guiTrt.formatChartValue(zfs.getZvol().zProperties.get("available").getValue(), zfs.getZvol().zProperties.get("usedbydataset").getValue(), zfs.getZvol().zProperties.get("usedbysnapshots").getValue());
				}
			}

			dataCharset.clear();
			this.dataCharset.put("Used By Data : "+zfs.getZvol().zProperties.get("usedbydataset").getValue(), guiTrt.getZfsUsedByData()) ;
			this.dataCharset.put("Used By Snapshots : "+zfs.getZvol().zProperties.get("usedbysnapshots").getValue(), guiTrt.getZfsUsedBySnapshots()) ;
			this.dataCharset.put("Free : "+BigDecimal.valueOf(guiTrt.getZfsFree()).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue()+guiTrt.getUnit(), guiTrt.getZfsFreePourcent()) ;
			PieDataset dataset = guiTrt.createDataset(dataCharset); 
			JFreeChart chartVolumeConfig =null;
			if ( "filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())){
				if (!zfs.getZvol().zProperties.get("quota").getValue().isEmpty() && !"none".equalsIgnoreCase(zfs.getZvol().zProperties.get("quota").getValue())){
					chartVolumeConfig = guiTrt.createChart(dataset, "Total FileSystem Quota : "+zfs.getZvol().zProperties.get("quota").getValue());
				}else{
					chartVolumeConfig = guiTrt.createChart(dataset, "Total FileSystem size : "+zfs.getZvol().zProperties.get("available").getValue());	
				}
				
			}else{
				chartVolumeConfig = guiTrt.createChart(dataset, "Total Volume size : "+zfs.getZvol().zProperties.get("volsize").getValue());	
			}
			
			if ( chartVolumeComposite != null){
				if ( !chartVolumeComposite.isDisposed()){
					chartVolumeComposite.dispose();
				}	
			}

			//Create Grid for Chart
			//gridDataChart = new GridData(GridData.FILL, GridData.CENTER, true, false);
			gridDataChart = new GridData(SWT.FILL, SWT.FILL, true, true);
			//gridDataChart.heightHint = 275;
			//gridDataChart.heightHint =compositeConfig.
			gridDataChart.horizontalSpan = 2;
			//Create Composite for Chart
			if (chartVolumeConfig != null){
				chartVolumeComposite= new ChartComposite(compositeConfig, SWT.BORDER, chartVolumeConfig, true); 
				chartVolumeComposite.setLayoutData(gridDataChart);
				chartVolumeComposite.layout();	
			}
			
			compositeConfig.layout();
		}

	}

	public void updateItemTreeZfsList(Boolean statusIscsi, String itemData,  TreeItem rootTree, String infoUsedSize, int indexTree){
		TreeItem root;
		if (indexTree ==-1){
			root = new TreeItem(rootTree, SWT.None);
		}else{
			root = new TreeItem(rootTree,SWT.None, indexTree);
		}
		root.setText(itemData+" ("+infoUsedSize+")");


		if (statusIscsi){
			if ("filesystem".equals(zfs.getZvol().zProperties.get("type").getValue())){
				root.setImage(imageFSOnline);
			}else{
				root.setImage(imageStorageOnline);	
			}

		}else{
			if ("filesystem".equals(zfs.getZvol().zProperties.get("type").getValue())){
				root.setImage(imageFSOffline);
			}else{
				root.setImage(imageStorageOffline);	
			}

		}
		root.setData(itemData);	
		//Set Object Zvol to empty
		zfs.setZvol();	
		zfs.setZiscsi();
	}


	public void actionClickTree(Event evt){
		final TreeItem root = (TreeItem) evt.item;
		strItemServer ="";
		strItemZvolFS="";
		countItem=0;
		thrGetallZvol = new Thread(new Runnable() {

			public void run() {
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						wPB.open();

					}
				});


				Display.getDefault().syncExec(new Runnable() {
					public void run() {

						if ( root.getParentItem() != null){

							final TreeItem parentRoot = root.getParentItem();
							if ( parentRoot.getParentItem() != null){
								strItemServer=parentRoot.getParentItem().getData().toString();

							}else{
								strItemServer=root.getParentItem().getData().toString();

							}

							strItemZvolFS=root.getData().toString();
							log.debug(strItemZvolFS);
							countItem=root.getItemCount();
							if (countItem <1){
								root.clearAll(true);
								root.setItemCount(0);
							}
						}
					}
				});
				if (!strItemServer.equalsIgnoreCase("")){
					zfs.getServer(strItemServer);
					zfs.zfsGetAllVolume(strItemZvolFS);

					if ( countItem <1 && !zfs.getZvol().zProperties.get("type").getValue().equalsIgnoreCase("snapshot")){
						final List<Object> zlistSnapshots = zfs.zfsListSnapshotsByVolFS(strItemZvolFS);

						Display.getDefault().syncExec(new Runnable() {
							public void run() {

								for (int i = 0; i < zlistSnapshots.size(); i++) {
									TreeItem item = new TreeItem(root, 0);
									item.setText(zlistSnapshots.get(i).toString());
									item.setData(zlistSnapshots.get(i).toString());
									if ( zfs.getIscsiListConfigVol(zlistSnapshots.get(i).toString()) && ! "".equalsIgnoreCase(zfs.getZiscsi().zProperties.get("tid").getValue())){
										item.setImage(imageSnapshotOnline);
									}else{
										item.setImage(imageSnapshotOffline);
									}

								}
							}
						});
					}

					Display.getDefault().syncExec(new Runnable(){
						public void run(){
							if ( !tbtmConfig.isDisposed()){
								tbtmConfig.dispose();
								tabFolderConfig.layout();
							}
							createTabItemVolConfig();
							refreshConfigVolume();


							if (! zfs.getZvol().zProperties.get("type").getValue().equalsIgnoreCase("snapshot")){
								if (tbtmSnapshot.isDisposed()){
									createTabItemSnapshot();
								}
								refreshConfigSnapshot();

							}else{
								if ( !tbtmSnapshot.isDisposed()){
									tbtmSnapshot.dispose();	
								}

							}
							tabFolderConfig.setSelection(tbtmConfig);
							refreshIscsiSession();
							refreshConfigReplica();
							tabFolderConfig.layout();
							wPB.close();
							menuTreeZFS();
							tree.setMenu(treeZFSMenu);


						}
					});

				}
			}
		});

		thrGetallZvol.start();
	}


	public void menuTreeZFS(){
		if (treeZFSMenu != null && !treeZFSMenu.isDisposed()){
			treeZFSMenu.dispose();
		}
		treeZFSMenu = new Menu(shell, SWT.POP_UP);
		MenuItem refreshZFSMenu = new MenuItem(treeZFSMenu, SWT.PUSH);
		refreshZFSMenu.setText("Refresh"); 
		refreshZFSMenu.addListener(SWT.Selection, new Listener() {
			public void handleEvent(final Event event) {

				tree.getSelection()[0].removeAll();
				wPB = new guiProgress(shell.getDisplay(), shell.getLocation().x, shell.getLocation().y);
				TreeItem itemSelected = tree.getSelection()[0];
				while (itemSelected.getParentItem()!=null){
					itemSelected=itemSelected.getParentItem();
				}
				itemSelected.removeAll();
				refreshTreeZFSList(itemSelected);


			}
		});

		if ("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())||
				"filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())){
			MenuItem snapshotVolFS = new MenuItem(treeZFSMenu, SWT.PUSH);
			snapshotVolFS.setText("Launch Snapshoting"); 
			snapshotVolFS.addListener(SWT.Selection, new Listener() {
				public void handleEvent(final Event event) {
					zfs.zfsSnapshots();
					String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);

					Arrays.sort(keysPropError);
					String textBox = "";
					for (int i = 0; i < keysPropError.length; i++) {
						String keyPropError = keysPropError[i];
						textBox = textBox +zfs.getError().get(keyPropError)+".\n";
					}
					if (keysPropError.length>0){
						MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
						messageBoxError.setText("Warning");
						messageBoxError.setMessage(textBox);
						messageBoxError.open();
					}
				}
			});	
			
/*Pour le moment je desactive cette fonctionnalite : j'ai un probleme car je ne sais pas encore comment recuperer la main. Et je me pose la question sur l'utilite 
 * 			MenuItem replicaVol = new MenuItem(treeZFSMenu, SWT.PUSH);
			replicaVol.setText("Launch Replication"); 
			replicaVol.addListener(SWT.Selection, new Listener() {
				public void handleEvent(final Event event) {
					zfs.zfsReplicas();
					String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);

					Arrays.sort(keysPropError);
					String textBox = "";
					for (int i = 0; i < keysPropError.length; i++) {
						String keyPropError = keysPropError[i];
						textBox = textBox +zfs.getError().get(keyPropError)+".\n";
					}
					if (keysPropError.length>0){
						MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
						messageBoxError.setText("Warning");
						messageBoxError.setMessage(textBox);
						messageBoxError.open();
					}
				}
			});	*/
		}

		if ("volume".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())||
				"filesystem".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())||
				"snapshot".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())){

			MenuItem removeVolFS = new MenuItem(treeZFSMenu, SWT.PUSH);
			removeVolFS.setText("Remove "+zfs.getZvol().zProperties.get("name").getValue()); 
			removeVolFS.addListener(SWT.Selection, new Listener() {
				public void handleEvent(final Event event) {
					destroyVolFS();
				}
			});
		}
		if("snapshot".equalsIgnoreCase(zfs.getZvol().zProperties.get("type").getValue())){
			MenuItem cloneSnapshpt = new MenuItem(treeZFSMenu, SWT.PUSH);
			cloneSnapshpt.setText("Clone "+zfs.getZvol().zProperties.get("name").getValue()); 
			cloneSnapshpt.addListener(SWT.Selection, new Listener() {
				public void handleEvent(final Event event) {
					zfs.zfsClone();
					if ( zfs.getError().size()>0){

					}else{
						int indRoot=0;
						int indItem=0;
						if ("filesystem".equals(zfs.getZvol().zProperties.get("type").getValue())){
							infoUsedSize=zfs.getZvol().zProperties.get("usedbydataset").getValue()+"/"+zfs.getZvol().zProperties.get("available").getValue();
						}else{
							infoUsedSize=zfs.getZvol().zProperties.get("used").getValue()+" / "+zfs.getZvol().zProperties.get("volsize").getValue();
						}
						for (int indT=0;indT<tree.getItemCount();indT++){
							if (tree.getItem(indT).getData().toString().equals(zfs.getZserver().zProperties.get("serverIP").getValue())){
								for (int indTreeVolFS=0;indTreeVolFS<tree.getItem(indT).getItemCount();indTreeVolFS++){
									if (tree.getItem(indT).getItem(indTreeVolFS).getData().toString().compareTo(zfs.getZvol().zProperties.get("name").getValue()) >0){
										if (zfs.getError().size()>0){
											updateItemTreeZfsList(false,zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), infoUsedSize ,indTreeVolFS);
										}else{
											updateItemTreeZfsList(true, zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), infoUsedSize ,indTreeVolFS);
										}
										indRoot=indT;
										indItem=indTreeVolFS;
										break;
									}
								}
								if ( indItem==0){
									int indTreeVolFS=tree.getItem(indT).getItemCount();
									if (zfs.getError().size()>0){
										updateItemTreeZfsList(false,zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), infoUsedSize ,indTreeVolFS);
									}else{
										updateItemTreeZfsList(true,zfs.getZvol().zProperties.get("name").getValue(), tree.getItem(indT), infoUsedSize ,indTreeVolFS);
									}
									indRoot=indT;
									indItem=indTreeVolFS;
								}
								tree.layout();
							}
						}
					}
				}
			});
		}

	}

	public void destroyVolFS(){
		if ( !"".equals(zfs.getZvol().zProperties.get("name").getValue())){
			MessageBox messageBoxConfirm = new MessageBox(shell, SWT.YES|SWT.NO);
			messageBoxConfirm.setText("Warning");
			String textBoxConfirm="Remove : "+zfs.getZvol().zProperties.get("name").getValue()+" ?";
			messageBoxConfirm.setMessage(textBoxConfirm);
			int answerIDConfirm= messageBoxConfirm.open();
			if (answerIDConfirm == SWT.YES){
				if ("filesystem".equals(zfs.getZvol().zProperties.get("type").getValue())){
					if ("yes".equals(zfs.getZvol().zProperties.get("mounted").getValue()) ){
						MessageBox messageBoxInfo = new MessageBox(shell, SWT.YES|SWT.NO);
						messageBoxInfo.setText("Warning");
						String textBox=zfs.getZvol().zProperties.get("name").getValue()+" is mounted\n Do you want umount it ?";
						messageBoxInfo.setMessage(textBox);
						int answerID= messageBoxInfo.open();
						if (answerID == SWT.YES){
							zfs.zfsUmountFS();
							String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);
							//String[] keysProp = (String[]) zfs.getZserver().zProperties.keySet().toArray(new String[0]);
							Arrays.sort(keysPropError);
							textBox = "";
							for (int i = 0; i < keysPropError.length; i++) {
								String keyPropError = keysPropError[i];
								textBox = textBox +zfs.getError().get(keyPropError)+".\n";
							}
							if (keysPropError.length>0){
								MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
								messageBoxError.setText("Warning");
								messageBoxError.setMessage(textBox);
								messageBoxError.open();
							}else{
								zfs.zfsDestroyVolFS();
								keysPropError = zfs.getError().keySet().toArray(new String[0]);

								Arrays.sort(keysPropError);
								textBox = "";
								for (int i = 0; i < keysPropError.length; i++) {
									String keyPropError = keysPropError[i];
									textBox = textBox +zfs.getError().get(keyPropError)+".\n";
								}
								if (keysPropError.length>0){
									MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
									messageBoxError.setText("Warning");
									messageBoxError.setMessage(textBox);
									messageBoxError.open();
								}else{
									tree.getSelection()[0].clearAll(true);
									tree.getSelection()[0].dispose();
									tree.layout();
									zfs.setZvol();
									if ( !tbtmConfig.isDisposed()){
										tbtmConfig.dispose();
										tabFolderConfig.layout();
									}
									createTabItemVolConfig();
									refreshConfigVolume();
									tabFolderConfig.layout();

								}
							}
						}
					}else{
						zfs.zfsDestroyVolFS();
						String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);

						Arrays.sort(keysPropError);
						String textBox = "";
						for (int i = 0; i < keysPropError.length; i++) {
							String keyPropError = keysPropError[i];
							textBox = textBox +zfs.getError().get(keyPropError)+".\n";
						}
						if (keysPropError.length>0){
							MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
							messageBoxError.setText("Warning");
							messageBoxError.setMessage(textBox);
							messageBoxError.open();
						}else{
							tree.getSelection()[0].clearAll(true);
							tree.getSelection()[0].dispose();
							tree.layout();
							zfs.setZvol();
							if ( !tbtmConfig.isDisposed()){
								tbtmConfig.dispose();
								tabFolderConfig.layout();
							}
							createTabItemVolConfig();
							refreshConfigVolume();
							tabFolderConfig.layout();

							if (! zfs.getZvol().zProperties.get("type").getValue().equalsIgnoreCase("snapshot")){
								//refreshInfoSnapshot();
								refreshConfigSnapshot();
							}
							tabFolderConfig.setSelection(tbtmConfig);
							refreshIscsiSession();
						}
					}
				}else{
					if ( "volume".equals(zfs.getZvol().zProperties.get("type").getValue())){
						zfs.zfsDelIscsi();
						String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);

						Arrays.sort(keysPropError);
						String textBox = "";
						for (int i = 0; i < keysPropError.length; i++) {
							String keyPropError = keysPropError[i];
							textBox = textBox +zfs.getError().get(keyPropError)+".\n";
						}
						if (keysPropError.length>0){
							MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
							messageBoxError.setText("Warning");
							messageBoxError.setMessage(textBox);
							messageBoxError.open();
						}else{
							zfs.zfsDestroyVolFS();
							keysPropError = zfs.getError().keySet().toArray(new String[0]);

							Arrays.sort(keysPropError);
							textBox = "";
							for (int i = 0; i < keysPropError.length; i++) {
								String keyPropError = keysPropError[i];
								textBox = textBox +zfs.getError().get(keyPropError)+".\n";
							}
							if (keysPropError.length>0){
								MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
								messageBoxError.setText("Warning");
								messageBoxError.setMessage(textBox);
								messageBoxError.open();
							}else{
								zfs.zfsDisableSnapshots();
								tree.getSelection()[0].clearAll(true);
								tree.getSelection()[0].dispose();
								tree.layout();
								zfs.setZvol();
								if ( !tbtmConfig.isDisposed()){
									tbtmConfig.dispose();
									tabFolderConfig.layout();
								}
								createTabItemVolConfig();
								refreshConfigVolume();
								tabFolderConfig.layout();

								if (! zfs.getZvol().zProperties.get("type").getValue().equalsIgnoreCase("snapshot")){
									refreshConfigSnapshot();
								}
								tabFolderConfig.setSelection(tbtmConfig);
								refreshIscsiSession();
							}
						}
					}else{
						if ( "snapshot".equals(zfs.getZvol().zProperties.get("type").getValue())){
							zfs.zfsDelIscsi();
							String[] keysPropError = zfs.getError().keySet().toArray(new String[0]);

							Arrays.sort(keysPropError);
							String textBox = "";
							for (int i = 0; i < keysPropError.length; i++) {
								String keyPropError = keysPropError[i];
								textBox = textBox +zfs.getError().get(keyPropError)+".\n";
							}
							if (keysPropError.length>0){
								MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
								messageBoxError.setText("Warning");
								messageBoxError.setMessage(textBox);
								messageBoxError.open();
							}else{
								zfs.zfsDestroyVolFS();
								keysPropError = zfs.getError().keySet().toArray(new String[0]);

								Arrays.sort(keysPropError);
								textBox = "";
								for (int i = 0; i < keysPropError.length; i++) {
									String keyPropError = keysPropError[i];
									textBox = textBox +zfs.getError().get(keyPropError)+".\n";
								}
								if (keysPropError.length>0){
									MessageBox messageBoxError = new MessageBox(shell, SWT.DIALOG_TRIM);
									messageBoxError.setText("Warning");
									messageBoxError.setMessage(textBox);
									messageBoxError.open();
								}else{
									zfs.zfsDisableSnapshots();
									tree.getSelection()[0].clearAll(true);
									tree.getSelection()[0].dispose();
									tree.layout();
									zfs.setZvol();
									if ( !tbtmConfig.isDisposed()){
										tbtmConfig.dispose();
										tabFolderConfig.layout();
									}
									createTabItemVolConfig();
									refreshConfigVolume();
									tabFolderConfig.layout();

									if (! zfs.getZvol().zProperties.get("type").getValue().equalsIgnoreCase("snapshot")){
										refreshConfigSnapshot();
									}
									tabFolderConfig.setSelection(tbtmConfig);
									refreshIscsiSession();
								}
							}
						}


					}

				}	
			}


		}
	}



}