mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-22 16:36:03 +01:00
336681fc6a
VMstorage page uses the default colours of the controls, hence we only need to set them on the VNCTabView and the linklabel does not need to be public.
657 lines
25 KiB
C#
657 lines
25 KiB
C#
/* Copyright (c) Citrix Systems Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms,
|
|
* with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Collections;
|
|
|
|
using XenAdmin.Core;
|
|
using XenAdmin.Dialogs;
|
|
using XenAPI;
|
|
using XenAdmin.Commands;
|
|
|
|
|
|
namespace XenAdmin.TabPages
|
|
{
|
|
internal partial class VMStoragePage : UserControl
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private readonly ContextMenu _TheContextMenu = new ContextMenu();
|
|
private readonly DataGridViewColumn storageLinkColumn;
|
|
|
|
private VM vm;
|
|
|
|
public VMStoragePage()
|
|
{
|
|
InitializeComponent();
|
|
|
|
_TheContextMenu.MenuItems.Add(AddButton.Text, AddButton_Click);
|
|
|
|
storageLinkColumn = ColumnSRVolume;
|
|
|
|
TitleLabel.ForeColor = Program.HeaderGradientForeColor;
|
|
TitleLabel.Font = Program.HeaderGradientFont;
|
|
dataGridViewStorage.SortCompare += new DataGridViewSortCompareEventHandler(dataGridViewStorage_SortCompare);
|
|
dataGridViewStorage.Sort(ColumnDevicePosition, ListSortDirection.Ascending);
|
|
}
|
|
|
|
void dataGridViewStorage_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
|
|
{
|
|
if (e.Column == ColumnDevicePosition)
|
|
{
|
|
e.SortResult = StringUtility.NaturalCompare(e.CellValue1.ToString(), e.CellValue2.ToString());
|
|
|
|
e.Handled = true;
|
|
}
|
|
else
|
|
{
|
|
e.Handled = false;
|
|
}
|
|
}
|
|
|
|
public VM VM
|
|
{
|
|
set
|
|
{
|
|
Program.AssertOnEventThread();
|
|
|
|
// de-register old listener...
|
|
if (vm != null)
|
|
{
|
|
foreach (VBD vbd in vm.Connection.ResolveAll(vm.VBDs))
|
|
{
|
|
vbd.PropertyChanged -= vbd_PropertyChanged;
|
|
|
|
VDI vdi = vm.Connection.Resolve(vbd.VDI);
|
|
if (vdi == null)
|
|
continue;
|
|
|
|
vdi.PropertyChanged -= vdi_PropertyChanged;
|
|
}
|
|
|
|
vm.PropertyChanged -= vm_PropertyChanged;
|
|
}
|
|
|
|
vm = value;
|
|
multipleDvdIsoList1.VM = vm;
|
|
|
|
if (vm != null)
|
|
vm.PropertyChanged += vm_PropertyChanged;
|
|
|
|
BuildList();
|
|
|
|
// set all columns to be preferred width but allow user to resize.
|
|
foreach (DataGridViewTextBoxColumn col in dataGridViewStorage.Columns)
|
|
{
|
|
if (col != storageLinkColumn)
|
|
{
|
|
col.Width = col.GetPreferredWidth(DataGridViewAutoSizeColumnMode.AllCells, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void vdi_PropertyChanged(object sender1, PropertyChangedEventArgs e)
|
|
{
|
|
// Nothing changing on any of the vdi's will require a rebuild of the list...
|
|
|
|
if (e.PropertyName == "allowed_operations")
|
|
UpdateButtons();
|
|
else
|
|
UpdateData();
|
|
}
|
|
|
|
private void vbd_PropertyChanged(object sender1, PropertyChangedEventArgs e)
|
|
{
|
|
// Only rebuild list if VDIs changed - otherwise just refresh
|
|
|
|
if (e.PropertyName == "VDI" || e.PropertyName == "empty" || e.PropertyName == "device")
|
|
{
|
|
BuildList();
|
|
}
|
|
else if (e.PropertyName == "allowed_operations")
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
else if (e.PropertyName == "currently_attached")
|
|
{
|
|
UpdateButtons();
|
|
UpdateData();
|
|
}
|
|
else
|
|
{
|
|
UpdateData();
|
|
}
|
|
}
|
|
|
|
private void UpdateData()
|
|
{
|
|
try
|
|
{
|
|
dataGridViewStorage.SuspendLayout();
|
|
foreach (DataGridViewRow r in dataGridViewStorage.Rows)
|
|
{
|
|
VBDRow row = r as VBDRow;
|
|
row.UpdateCells();
|
|
}
|
|
dataGridViewStorage.Sort(dataGridViewStorage.SortedColumn,
|
|
dataGridViewStorage.SortOrder == SortOrder.Ascending
|
|
? ListSortDirection.Ascending
|
|
: ListSortDirection.Descending);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.Error("Error updating vm storage list.", e);
|
|
}
|
|
finally
|
|
{
|
|
dataGridViewStorage.ResumeLayout();
|
|
}
|
|
}
|
|
|
|
private void vm_PropertyChanged(object sender1, PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName == "VBDs")
|
|
BuildList();
|
|
else if (e.PropertyName == "power_state" || e.PropertyName == "Locked")
|
|
Program.Invoke(this, UpdateButtons);
|
|
}
|
|
|
|
private void BuildList()
|
|
{
|
|
Program.AssertOnEventThread();
|
|
if (!this.Visible)
|
|
return;
|
|
try
|
|
{
|
|
dataGridViewStorage.SuspendLayout();
|
|
DataGridViewSelectedRowCollection vbdSavedItems = dataGridViewStorage.SelectedRows;
|
|
|
|
dataGridViewStorage.Rows.Clear();
|
|
|
|
if (vm == null)
|
|
return;
|
|
|
|
bool storageLinkColumnVisible = false;
|
|
|
|
List<bool> devices_in_use = new List<bool>();
|
|
foreach (VBD vbd in vm.Connection.ResolveAll(vm.VBDs))
|
|
{
|
|
vbd.PropertyChanged -= new PropertyChangedEventHandler(vbd_PropertyChanged);
|
|
vbd.PropertyChanged += new PropertyChangedEventHandler(vbd_PropertyChanged);
|
|
|
|
if (!vbd.IsCDROM && !vbd.IsFloppyDrive)
|
|
{
|
|
VDI vdi = vm.Connection.Resolve(vbd.VDI);
|
|
if (vdi == null || !vdi.Show(Properties.Settings.Default.ShowHiddenVMs))
|
|
continue;
|
|
|
|
SR sr = vm.Connection.Resolve(vdi.SR);
|
|
if (sr == null || sr.IsToolsSR)
|
|
continue;
|
|
|
|
storageLinkColumnVisible = vdi.sm_config.ContainsKey("SVID");
|
|
|
|
vdi.PropertyChanged -= new PropertyChangedEventHandler(vdi_PropertyChanged);
|
|
vdi.PropertyChanged += new PropertyChangedEventHandler(vdi_PropertyChanged);
|
|
|
|
dataGridViewStorage.Rows.Add(new VBDRow(vbd, vdi, sr));
|
|
|
|
int i;
|
|
if (int.TryParse(vbd.userdevice, out i))
|
|
{
|
|
while (devices_in_use.Count <= i)
|
|
{
|
|
devices_in_use.Add(false);
|
|
}
|
|
devices_in_use[i] = true;
|
|
}
|
|
}
|
|
|
|
//CA-47050: the dnsColumn should be autosized to Fill, but should not become smaller than a minimum
|
|
//width, which is chosen to be the column's contents (including header) width. To find what this is
|
|
//set temporarily the column's autosize mode to AllCells.
|
|
HelpersGUI.ResizeLastGridViewColumn(ColumnDevicePath);
|
|
}
|
|
|
|
|
|
storageLinkColumn.Visible = storageLinkColumnVisible;
|
|
dataGridViewStorage.Sort(dataGridViewStorage.SortedColumn, dataGridViewStorage.SortOrder == SortOrder.Ascending ? ListSortDirection.Ascending : ListSortDirection.Descending);
|
|
|
|
IEnumerable<VBD> vbdsSelected = from VBDRow row in vbdSavedItems select row.VBD;
|
|
foreach (VBDRow row in dataGridViewStorage.Rows)
|
|
{
|
|
row.Selected = vbdsSelected.Contains(row.VBD);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.ErrorFormat("Exception building VM storage list: {0}", e.Message);
|
|
}
|
|
finally
|
|
{
|
|
dataGridViewStorage.ResumeLayout();
|
|
}
|
|
UpdateButtons();
|
|
}
|
|
|
|
private List<VBDRow> SelectedVBDRows
|
|
{
|
|
get
|
|
{
|
|
if (dataGridViewStorage.SelectedRows.Count == 0)
|
|
return null;
|
|
|
|
List<VBDRow> rows = new List<VBDRow>();
|
|
foreach (DataGridViewRow r in dataGridViewStorage.SelectedRows)
|
|
rows.Add(r as VBDRow);
|
|
|
|
return rows;
|
|
}
|
|
}
|
|
|
|
private void TheHeaderListBox_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
private void UpdateButtons()
|
|
{
|
|
AttachVirtualDiskCommand attachCmd = new AttachVirtualDiskCommand(Program.MainWindow, vm);
|
|
AttachButton.Enabled = attachCmd.CanExecute();
|
|
AddButton.Enabled = attachCmd.CanExecute();
|
|
|
|
List<VBDRow> vbdRows = SelectedVBDRows;
|
|
|
|
if (dataGridViewStorage.Rows.Count == 0 || vbdRows == null || vm == null)
|
|
{
|
|
DeactivateButton.Enabled = false;
|
|
DetachDriveButton.Enabled = false;
|
|
DeleteDriveButton.Enabled = false;
|
|
EditButton.Enabled = false;
|
|
MoveButton.Enabled = false;
|
|
return;
|
|
}
|
|
EditButton.Enabled = vbdRows.Count == 1 && !vbdRows[0].VBD.Locked && !vbdRows[0].VDI.Locked;
|
|
|
|
List<SelectedItem> selectedVDIs = new List<SelectedItem>();
|
|
List<SelectedItem> selectedVBDs = new List<SelectedItem>();
|
|
|
|
foreach (VBDRow r in vbdRows)
|
|
{
|
|
selectedVDIs.Add(new SelectedItem(r.VDI));
|
|
selectedVBDs.Add(new SelectedItem(r.VBD));
|
|
}
|
|
DeleteVirtualDiskCommand deleteCmd = new DeleteVirtualDiskCommand(Program.MainWindow, selectedVDIs);
|
|
// User has visibility that this disk in use by this VM. Allow unplug + delete in single step (non default behaviour),
|
|
// but only if we are the only VBD (default behaviour)
|
|
deleteCmd.AllowRunningVMDelete = true;
|
|
if (deleteCmd.CanExecute())
|
|
{
|
|
DeleteButtonContainer.RemoveAll();
|
|
DeleteDriveButton.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
DeleteButtonContainer.SetToolTip(deleteCmd.ToolTipText);
|
|
DeleteDriveButton.Enabled = false;
|
|
}
|
|
|
|
Command activationCmd = null;
|
|
|
|
SelectedItemCollection vbdCol = new SelectedItemCollection(selectedVBDs);
|
|
if (vbdCol.AsXenObjects<VBD>().Find(delegate(VBD vbd) { return !vbd.currently_attached; }) == null)
|
|
{
|
|
// no VBDs are attached so we are deactivating
|
|
DeactivateButton.Text = Messages.DEACTIVATE;
|
|
activationCmd = new DeactivateVBDCommand(Program.MainWindow, selectedVBDs);
|
|
}
|
|
else
|
|
{
|
|
// this is the default cause in the mixed attached/detatched scenario. We try to activate all the selection
|
|
// The command error reports afterwards about the ones which are already attached
|
|
DeactivateButton.Text = Messages.ACTIVATE;
|
|
activationCmd = new ActivateVBDCommand(Program.MainWindow, selectedVBDs);
|
|
}
|
|
|
|
if (activationCmd.CanExecute())
|
|
{
|
|
DeactivateButtonContainer.RemoveAll();
|
|
DeactivateButton.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
DeactivateButtonContainer.SetToolTip(activationCmd.ToolTipText);
|
|
DeactivateButton.Enabled = false;
|
|
}
|
|
|
|
DetachVirtualDiskCommand detachCmd = new DetachVirtualDiskCommand(Program.MainWindow, selectedVDIs, vm);
|
|
if (detachCmd.CanExecute())
|
|
{
|
|
DetachButtonContainer.RemoveAll();
|
|
DetachDriveButton.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
DetachButtonContainer.SetToolTip(detachCmd.ToolTipText);
|
|
DetachDriveButton.Enabled = false;
|
|
}
|
|
|
|
// Move button
|
|
Command moveCmd = MoveMigrateCommand(selectedVDIs);
|
|
if (moveCmd.CanExecute())
|
|
{
|
|
MoveButton.Enabled = true;
|
|
MoveButtonContainer.RemoveAll();
|
|
}
|
|
else
|
|
{
|
|
MoveButton.Enabled = false;
|
|
MoveButtonContainer.SetToolTip(moveCmd.ToolTipText);
|
|
}
|
|
}
|
|
|
|
private Command MoveMigrateCommand(IEnumerable<SelectedItem> selection)
|
|
{
|
|
MoveVirtualDiskCommand moveCmd = new MoveVirtualDiskCommand(Program.MainWindow, selection);
|
|
|
|
if (moveCmd.CanExecute())
|
|
return moveCmd;
|
|
|
|
return new MigrateVirtualDiskCommand(Program.MainWindow, selection);
|
|
}
|
|
|
|
private void AddButton_Click(object sender, EventArgs e)
|
|
{
|
|
var cmd = new AddVirtualDiskCommand(Program.MainWindow, vm);
|
|
if (cmd.CanExecute())
|
|
cmd.Execute();
|
|
|
|
// don't wait for the property change to trigger it, as this can take a while
|
|
UpdateButtons();
|
|
}
|
|
|
|
private void AttachButton_Click(object sender, EventArgs e)
|
|
{
|
|
AttachVirtualDiskCommand cmd = new AttachVirtualDiskCommand(Program.MainWindow, vm);
|
|
if (cmd.CanExecute())
|
|
cmd.Execute();
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
private void MoveButton_Click(object sender, EventArgs e)
|
|
{
|
|
List<VBDRow> rows = SelectedVBDRows;
|
|
if (rows == null)
|
|
return;
|
|
List<SelectedItem> l = new List<SelectedItem>();
|
|
foreach (VBDRow r in rows)
|
|
l.Add(new SelectedItem(r.VDI));
|
|
|
|
Command cmd = MoveMigrateCommand(l);
|
|
if (cmd.CanExecute())
|
|
cmd.Execute();
|
|
}
|
|
|
|
/// <summary>
|
|
/// User has clicked the detach button. Unplug the VBD, then destroy it.
|
|
/// </summary>
|
|
private void DetachButton_Click(object sender, EventArgs e)
|
|
{
|
|
List<VBDRow> rows = SelectedVBDRows;
|
|
if (rows == null)
|
|
return;
|
|
List<SelectedItem> l = new List<SelectedItem>();
|
|
foreach (VBDRow r in rows)
|
|
l.Add(new SelectedItem(r.VDI));
|
|
|
|
DetachVirtualDiskCommand cmd = new DetachVirtualDiskCommand(Program.MainWindow, l, vm);
|
|
if (cmd.CanExecute())
|
|
cmd.Execute();
|
|
}
|
|
|
|
private void DeleteDriveButton_Click(object sender, EventArgs e)
|
|
{
|
|
List<VBDRow> rows = SelectedVBDRows;
|
|
if (rows == null)
|
|
return;
|
|
List<SelectedItem> l = new List<SelectedItem>();
|
|
foreach (VBDRow r in rows)
|
|
l.Add(new SelectedItem(r.VDI));
|
|
|
|
DeleteVirtualDiskCommand cmd = new DeleteVirtualDiskCommand(Program.MainWindow, l);
|
|
// User has visibility that this disk in use by this VM. Allow unplug + delete in single step (non default behaviour),
|
|
// but only if we are the only VBD (default behaviour)
|
|
cmd.AllowRunningVMDelete = true;
|
|
if (cmd.CanExecute())
|
|
cmd.Execute();
|
|
}
|
|
|
|
private void EditButton_Click(object sender, EventArgs e)
|
|
{
|
|
if (vm == null)
|
|
return;
|
|
|
|
List<VBDRow> rows = SelectedVBDRows;
|
|
|
|
if (rows == null)
|
|
return;
|
|
|
|
new PropertiesDialog(rows[0].VDI).ShowDialog(this);
|
|
}
|
|
|
|
private void TheHeaderListBox_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
|
|
{
|
|
if (e.RowIndex >= 0 && EditButton.Enabled == true)
|
|
{
|
|
// If double-click was on data row (not including header), launch the storage edit box
|
|
EditButton_Click(null, null);
|
|
}
|
|
}
|
|
|
|
private void TheHeaderListBox_DataGridView_MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
// Load context menus on right mouse click
|
|
DataGridView.HitTestInfo hitTestInfo;
|
|
if (e.Button == MouseButtons.Right)
|
|
{
|
|
hitTestInfo = dataGridViewStorage.HitTest(e.X, e.Y);
|
|
if (hitTestInfo.Type == DataGridViewHitTestType.Cell)
|
|
{
|
|
if (dataGridViewStorage.Rows.Count >= 0)
|
|
{
|
|
if (!dataGridViewStorage.Rows[hitTestInfo.RowIndex].Selected)
|
|
{
|
|
// Select the row that the user right clicked on (similiar to outlook) if it's not already in the selection
|
|
// (avoids clearing a multiselect if you right click inside it)
|
|
// Check if the CurrentCell is the cell the user right clicked on (but the row is not Selected) [CA-64954]
|
|
// This happens when the grid is initially shown: the current cell is the first cell in the first column, but the row is not selected
|
|
if (dataGridViewStorage.CurrentCell == dataGridViewStorage[hitTestInfo.ColumnIndex, hitTestInfo.RowIndex])
|
|
dataGridViewStorage.Rows[hitTestInfo.RowIndex].Selected = true;
|
|
else
|
|
dataGridViewStorage.CurrentCell = dataGridViewStorage[hitTestInfo.ColumnIndex, hitTestInfo.RowIndex];
|
|
}
|
|
// Update the menus as they are contextual
|
|
PopulateContextMenu();
|
|
// Show the menus. We will always have at least one (Add).
|
|
_TheContextMenu.Show(dataGridViewStorage, new Point(e.X, e.Y));
|
|
}
|
|
}
|
|
}
|
|
} // TheHeaderListBox_DataGridView_MouseUp
|
|
|
|
private void PopulateContextMenu()
|
|
{
|
|
_TheContextMenu.MenuItems.Clear();
|
|
if (AddButton.Visible && AddButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(AddButton.Text, AddButton_Click);
|
|
if (AttachButton.Visible && AttachButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(AttachButton.Text, AttachButton_Click);
|
|
if (DeactivateButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(DeactivateButton.Text, DeactivateButton_Click);
|
|
if (MoveButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(MoveButton.Text, MoveButton_Click);
|
|
if (DeleteDriveButton.Visible && DeleteDriveButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(DeleteDriveButton.Text, DeleteDriveButton_Click);
|
|
if (DetachDriveButton.Visible && DetachDriveButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(DetachDriveButton.Text, DetachButton_Click);
|
|
if (EditButton.Visible && EditButton.Enabled)
|
|
_TheContextMenu.MenuItems.Add(EditButton.Text, EditButton_Click);
|
|
}
|
|
|
|
private void DeactivateButton_Click(object sender, EventArgs e)
|
|
{
|
|
List<VBDRow> rows = SelectedVBDRows;
|
|
if (rows == null)
|
|
return;
|
|
List<SelectedItem> l = new List<SelectedItem>();
|
|
foreach (VBDRow r in rows)
|
|
l.Add(new SelectedItem(r.VBD));
|
|
|
|
SelectedItemCollection col = new SelectedItemCollection(l);
|
|
Command cmd = null;
|
|
if (col.AsXenObjects<VBD>().Find(vbd => !vbd.currently_attached) == null)
|
|
cmd = new DeactivateVBDCommand(Program.MainWindow, l);
|
|
else
|
|
cmd = new ActivateVBDCommand(Program.MainWindow, l);
|
|
|
|
if (cmd.CanExecute())
|
|
cmd.Execute();
|
|
}
|
|
}
|
|
|
|
public class VBDRow : DataGridViewRow
|
|
{
|
|
public readonly VBD VBD;
|
|
|
|
public readonly VDI VDI;
|
|
|
|
public readonly SR SR;
|
|
|
|
/// <summary>
|
|
/// Arguments should never be null
|
|
/// </summary>
|
|
public VBDRow(VBD vbd, VDI vdi, SR sr)
|
|
{
|
|
Debug.Assert(vbd != null && vdi != null && sr != null, "vbd, vdi and sr must be set to a non-null value");
|
|
|
|
VBD = vbd;
|
|
VDI = vdi;
|
|
SR = sr;
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
DataGridViewTextBoxCell c = new DataGridViewTextBoxCell();
|
|
c.Value = CellValue(i);
|
|
Cells.Add(c);
|
|
}
|
|
}
|
|
|
|
public int CompareTo(object o)
|
|
{
|
|
VBDRow r = (VBDRow)o;
|
|
string c1 = this.VBD.userdevice;
|
|
string c2 = r.VBD.userdevice;
|
|
int i1;
|
|
int i2;
|
|
if (int.TryParse(c1, out i1) && int.TryParse(c2, out i2))
|
|
{
|
|
return i1 - i2;
|
|
}
|
|
else
|
|
{
|
|
return c1.CompareTo(c2);
|
|
}
|
|
}
|
|
|
|
private object CellValue(int col)
|
|
{
|
|
switch (col)
|
|
{
|
|
case 0:
|
|
return VBD.userdevice;
|
|
case 1:
|
|
return VDI.Name;
|
|
case 2:
|
|
return VDI.Description;
|
|
case 3:
|
|
return SR.Name;
|
|
case 4:
|
|
string name;
|
|
return VDI.sm_config.TryGetValue("displayname", out name) ? name : "";
|
|
case 5:
|
|
return VDI.SizeText;
|
|
case 6:
|
|
return VBD.read_only ? Messages.YES : Messages.NO;
|
|
case 7:
|
|
return GetPriorityString(VBD.IONice);
|
|
case 8:
|
|
return VBD.currently_attached ? Messages.YES : Messages.NO;
|
|
case 9:
|
|
return VBD.device == "" ? Messages.STORAGE_PANEL_UNKNOWN : string.Format("/dev/{0}", VBD.device);
|
|
default:
|
|
throw new ArgumentException(String.Format("Invalid column number {0} in VBDRenderer.CellValue()", col));
|
|
}
|
|
}
|
|
|
|
public void UpdateCells()
|
|
{
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
Cells[i].Value = CellValue(i);
|
|
}
|
|
}
|
|
|
|
private static string GetPriorityString(int p)
|
|
{
|
|
switch (p)
|
|
{
|
|
case 0:
|
|
return Messages.STORAGE_WORST;
|
|
case 7:
|
|
return Messages.STORAGE_BEST;
|
|
default:
|
|
return p.ToString();
|
|
}
|
|
}
|
|
}
|
|
}
|