[pve-manager.git] / www / manager / lxc / ResourceEdit.js

/*jslint confusion: true */
var labelWidth = 120;

Ext.define('PVE.lxc.MemoryEdit', {
    extend: 'PVE.window.Edit',

    initComponent : function() {
	var me = this;

	Ext.apply(me, {
	    subject: gettext('Memory'),
	    items: Ext.create('PVE.lxc.MemoryInputPanel')
	});

	me.callParent();

	me.load();
    }
});


Ext.define('PVE.lxc.CPUEdit', {
    extend: 'PVE.window.Edit',

    initComponent : function() {
	var me = this;

	Ext.apply(me, {
	    subject: gettext('CPU'),
	    items: Ext.create('PVE.lxc.CPUInputPanel')
	});

	me.callParent();

	me.load();
    }
});

Ext.define('PVE.lxc.MountPointEdit', {
    extend: 'PVE.window.Edit',

    initComponent : function() {
	var me = this;

	var nodename = me.pveSelNode.data.node;
	if (!nodename) {
	    throw "no node name specified";
	}

	var unused = me.confid && me.confid.match(/^unused\d+$/);

	me.create = me.confid ? unused : true;

	var ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
	    confid: me.confid,
	    nodename: nodename,
	    unused: unused,
	    create: me.create
	});

	var subject;
	if (unused) {
	    subject = gettext('Unused Mount Point');
	} else if (me.create) {
	    subject = gettext('Mount Point');
	} else {
	    subject = gettext('Mount Point') + ' (' + me.confid + ')';
	}

	Ext.apply(me, {
	    subject: subject,
	    items: ipanel
	});

	me.callParent();

	me.load({
	    success: function(response, options) {
		ipanel.setVMConfig(response.result.data);
		if (me.confid) {
		    var value = response.result.data[me.confid];
		    var mp = PVE.Parser.parseLxcMountPoint(value);

		    if (!mp) {
			Ext.Msg.alert(gettext('Error'), gettext('Unable to parse mount point options'));
			me.close();
			return;
		    }

		    ipanel.setMountPoint(mp);
		    me.isValid(); // trigger validation
		}
	    }
	});
    }
});

Ext.define('PVE.lxc.CPUInputPanel', {
    extend: 'PVE.panel.InputPanel',
    alias: 'widget.pveLxcCPUInputPanel',

    insideWizard: false,

    initComponent : function() {
	var me = this;

	var items = [
	    {
		xtype: 'numberfield',
		name: 'cpulimit',
		minValue: 0,
		value: '1',
		step: 1,
		fieldLabel: gettext('CPU limit'),
		labelWidth: labelWidth,
		allowBlank: false
	    },
	    {
		xtype: 'numberfield',
		name: 'cpuunits',
		fieldLabel: gettext('CPU units'),
		value: 1024,
		minValue: 8,
		maxValue: 500000,
		labelWidth: labelWidth,
		allowBlank: false
	    }
	];

	if (me.insideWizard) {
	    me.column1 = items;
	} else {
	    me.items = items;
	}
   
	me.callParent();
    }
});

Ext.define('PVE.lxc.MemoryInputPanel', {
    extend: 'PVE.panel.InputPanel',
    alias: 'widget.pveLxcMemoryInputPanel',

    insideWizard: false,

    initComponent : function() {
	var me = this;

	var items = [
	    {
		xtype: 'numberfield',
		name: 'memory',
		minValue: 32,
		maxValue: 512*1024,
		value: '512',
		step: 32,
		fieldLabel: gettext('Memory') + ' (MB)',
		labelWidth: labelWidth,
		allowBlank: false
	    },
	    {
		xtype: 'numberfield',
		name: 'swap',
		minValue: 0,
		maxValue: 128*1024,
		value: '512',
		step: 32,
		fieldLabel: gettext('Swap') + ' (MB)',
		labelWidth: labelWidth,
		allowBlank: false
	    }
	];

	if (me.insideWizard) {
	    me.column1 = items;
	} else {
	    me.items = items;
	}
 
	me.callParent();
    }
});

Ext.define('PVE.lxc.MountPointInputPanel', {
    extend: 'PVE.panel.InputPanel',
    alias: 'widget.pveLxcMountPointInputPanel',

    insideWizard: false,

    unused: false, // ADD usused disk imaged

    vmconfig: {}, // used to select usused disks

    onGetValues: function(values) {
	var me = this;

	var confid = me.confid || values.mpsel;

	if (me.unused) {
	    me.mpdata.file = me.vmconfig[values.unusedId];
	    confid = values.mpsel;
	} else if (me.create) {
	    me.mpdata.file = values.storage + ':' + values.disksize;
	}

	if (confid !== 'rootfs') {
	    me.mpdata.mp = values.mp;
	}

	if (values.ro) {
	    me.mpdata.ro = 1;
	} else {
	    delete me.mpdata.ro;
	}

	if (values.quota) {
	    me.mpdata.quota = 1;
	} else {
	    delete me.mpdata.quota;
	}

	if (values.acl === 'Default') {
	    delete me.mpdata.acl;
	} else {
	    me.mpdata.acl = values.acl;
	}

	var res = {};
	res[confid] = PVE.Parser.printLxcMountPoint(me.mpdata);
	return res;
    },

    setMountPoint: function(mp) {
	var me = this;

	me.mpdata = mp;
	if (!Ext.isDefined(me.mpdata.acl)) {
	    me.mpdata.acl = 'Default';
	}

	if (mp.type === 'bind') {
	    me.quota.setDisabled(true);
	    me.quota.setValue(false);
	}

	me.setValues(mp);
    },

    setVMConfig: function(vmconfig) {
	var me = this;

	me.vmconfig = vmconfig;

	if (me.mpsel) {
	    var i;
	    for (i = 0; i != 8; ++i) {
		var name = "mp" + i;
		if (!Ext.isDefined(vmconfig[name])) {
		    me.mpsel.setValue(name);
		    break;
		}
	    }
	}

	if (me.unusedDisks) {
	    var disklist = [];
	    Ext.Object.each(vmconfig, function(key, value) {
		if (key.match(/^unused\d+$/)) {
		    disklist.push([key, value]);
		}
	    });
	    me.unusedDisks.store.loadData(disklist);
	    me.unusedDisks.setValue(me.confid);
	}
    },

    setNodename: function(nodename) {
	var me = this;
	me.hdstoragesel.setNodename(nodename);
	me.hdfilesel.setStorage(undefined, nodename);
    },

    initComponent : function() {
	var me = this;

	var isroot = me.confid === 'rootfs';

	me.mpdata = {};

	me.column1 = [];

	if (!me.confid || me.unused) {
	    var names = [];
	    var i;
	    for (i = 0; i != 8; ++i) {
		var name = 'mp' + i;
		names.push([name, name]);
	    }
	    me.mpsel = Ext.create('PVE.form.KVComboBox', {
		name: 'mpsel',
		fieldLabel: gettext('Mount Point'),
		matchFieldWidth: false,
		allowBlank: false,
		data: names,
		validator: function(value) {
		    if (!me.rendered) {
			return;
		    }
		    if (Ext.isDefined(me.vmconfig[value])) {
			return "Mount point is already in use.";
		    }
		    return true;
		},
		listeners: {
		    change: function(field, value) {
			field.validate();
		    }
		}
	    });
	    me.column1.push(me.mpsel);
	}

	// we always have this around, but only visible when creating a new mp
	// since this handles per-filesystem capabilities
	me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
	    name: 'storage',
	    nodename: me.nodename,
	    fieldLabel: gettext('Storage'),
	    storageContent: 'rootdir',
	    allowBlank: false,
	    autoSelect: true,
	    hidden: me.unused || !me.create,
	    listeners: {
		change: function(f, value) {
		    if (me.mpdata.type === 'bind') {
			me.quota.setDisabled(true);
			me.quota.setValue(false);
			return;
		    }
		    var rec = f.store.getById(value);
		    if (rec.data.type === 'zfs' ||
		        rec.data.type === 'zfspool') {
			me.quota.setDisabled(true);
			me.quota.setValue(false);
		    } else {
			me.quota.setDisabled(false);
		    }
		    if (me.unused || !me.create) {
			return;
		    }
		    if (rec.data.type === 'iscsi') {
			me.hdfilesel.setStorage(value);
			me.hdfilesel.setDisabled(false);
			me.hdfilesel.setVisible(true);
			me.hdsizesel.setDisabled(true);
			me.hdsizesel.setVisible(false);
		    } else if (rec.data.type === 'lvm' ||
			       rec.data.type === 'lvmthin' ||
			       rec.data.type === 'rbd' ||
			       rec.data.type === 'sheepdog' ||
			       rec.data.type === 'zfs' ||
			       rec.data.type === 'zfspool') {
			me.hdfilesel.setDisabled(true);
			me.hdfilesel.setVisible(false);
			me.hdsizesel.setDisabled(false);
			me.hdsizesel.setVisible(true);
		    } else {
			me.hdfilesel.setDisabled(true);
			me.hdfilesel.setVisible(false);
			me.hdsizesel.setDisabled(false);
			me.hdsizesel.setVisible(true);
		    }
		}
	    }
	});
	me.column1.push(me.hdstoragesel);

	if (me.unused) {
	    me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
		name: 'unusedId',
		fieldLabel: gettext('Disk image'),
		matchFieldWidth: false,
		listConfig: {
		    width: 350
		},
		data: [],
		allowBlank: false,
		listeners: {
		    change: function(f, value) {
			// make sure our buttons are enabled/disabled when switching
			// between images on different storages:
			var disk = me.vmconfig[value];
			var storage = disk.split(':')[0];
			me.hdstoragesel.setValue(storage);
		    }
		}
	    });
	    me.column1.push(me.unusedDisks);
	} else if (me.create) {
	    me.hdfilesel = Ext.create('PVE.form.FileSelector', {
		name: 'file',
		nodename: me.nodename,
		storageContent: 'images',
		fieldLabel: gettext('Disk image'),
		disabled: true,
		hidden: true,
		allowBlank: false
	    });
	    me.hdsizesel = Ext.createWidget('numberfield', {
		name: 'disksize',
		minValue: 0.1,
		maxValue: 128*1024,
		decimalPrecision: 3,
		value: '8',
		step: 1,
		fieldLabel: gettext('Disk size') + ' (GB)',
		allowBlank: false
	    });
	    me.column1.push(me.hdfilesel);
	    me.column1.push(me.hdsizesel);
	} else {
	    me.column1.push({
		xtype: 'textfield',
		disabled: true,
		submitValue: false,
		fieldLabel: gettext('Disk image'),
		name: 'file'
	    });
	}

	me.quota = Ext.createWidget('pvecheckbox', {
	    name: 'quota',
	    defaultValue: 0,
	    fieldLabel: gettext('Enable quota')
	});

	me.column2 = [
	    {
		xtype: 'pvecheckbox',
		name: 'ro',
		defaultValue: 0,
		fieldLabel: gettext('Read-only'),
		hidden: me.insideWizard
	    },
	    {
		xtype: 'pveKVComboBox',
		name: 'acl',
		fieldLabel: gettext('ACLs'),
		data: [['Default', 'Default'], ['1', 'On'], ['0', 'Off']],
		value: 'Default',
		allowBlank: true
	    },
	    me.quota
	];

	if (!isroot) {
	    me.column2.push({
		xtype: 'textfield',
		name: 'mp',
		value: '',
		emptyText:  gettext('/some/path'),
		allowBlank: false,
		hidden: isroot,
		fieldLabel: gettext('Path')
	    });
	}

	me.callParent();
    }
});
Commit	Line	Data
30164175	1	/jslint confusion: true /
34782e26 WL	2	var labelWidth = 120;
34782e26 WL	3
9ea5485d WL	4	Ext.define('PVE.lxc.MemoryEdit', {
	5	extend: 'PVE.window.Edit',
	6
	7	initComponent : function() {
	8	var me = this;
	9
	10	Ext.apply(me, {
	11	subject: gettext('Memory'),
	12	items: Ext.create('PVE.lxc.MemoryInputPanel')
	13	});
	14
	15	me.callParent();
	16
	17	me.load();
	18	}
	19	});
	20
	21
34782e26 WL	22	Ext.define('PVE.lxc.CPUEdit', {
	23	extend: 'PVE.window.Edit',
	24
9ea5485d WL	25	initComponent : function() {
	26	var me = this;
	27
	28	Ext.apply(me, {
	29	subject: gettext('CPU'),
	30	items: Ext.create('PVE.lxc.CPUInputPanel')
	31	});
	32
	33	me.callParent();
	34
	35	me.load();
	36	}
	37	});
	38
946eb8cd WB	39	Ext.define('PVE.lxc.MountPointEdit', {
	40	extend: 'PVE.window.Edit',
	41
	42	initComponent : function() {
	43	var me = this;
	44
	45	var nodename = me.pveSelNode.data.node;
	46	if (!nodename) {
	47	throw "no node name specified";
	48	}
	49
	50	var unused = me.confid && me.confid.match(/^unused\d+$/);
	51
	52	me.create = me.confid ? unused : true;
	53
	54	var ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
	55	confid: me.confid,
	56	nodename: nodename,
	57	unused: unused,
30164175	58	create: me.create
946eb8cd WB	59	});
	60
	61	var subject;
	62	if (unused) {
	63	subject = gettext('Unused Mount Point');
	64	} else if (me.create) {
	65	subject = gettext('Mount Point');
	66	} else {
	67	subject = gettext('Mount Point') + ' (' + me.confid + ')';
	68	}
	69
	70	Ext.apply(me, {
	71	subject: subject,
30164175	72	items: ipanel
946eb8cd WB	73	});
	74
	75	me.callParent();
	76
	77	me.load({
	78	success: function(response, options) {
	79	ipanel.setVMConfig(response.result.data);
	80	if (me.confid) {
	81	var value = response.result.data[me.confid];
	82	var mp = PVE.Parser.parseLxcMountPoint(value);
	83
	84	if (!mp) {
	85	Ext.Msg.alert(gettext('Error'), gettext('Unable to parse mount point options'));
	86	me.close();
	87	return;
	88	}
	89
	90	ipanel.setMountPoint(mp);
	91	me.isValid(); // trigger validation
	92	}
	93	}
	94	});
	95	}
	96	});
	97
9ea5485d WL	98	Ext.define('PVE.lxc.CPUInputPanel', {
	99	extend: 'PVE.panel.InputPanel',
	100	alias: 'widget.pveLxcCPUInputPanel',
	101
	102	insideWizard: false,
	103
34782e26 WL	104	initComponent : function() {
	105	var me = this;
	106
451bd04c DM	107	var items = [
	108	{
	109	xtype: 'numberfield',
	110	name: 'cpulimit',
	111	minValue: 0,
	112	value: '1',
	113	step: 1,
	114	fieldLabel: gettext('CPU limit'),
	115	labelWidth: labelWidth,
	116	allowBlank: false
	117	},
	118	{
	119	xtype: 'numberfield',
	120	name: 'cpuunits',
	121	fieldLabel: gettext('CPU units'),
	122	value: 1024,
	123	minValue: 8,
	124	maxValue: 500000,
	125	labelWidth: labelWidth,
	126	allowBlank: false
	127	}
	128	];
	129
30164175	130	if (me.insideWizard) {
451bd04c DM	131	me.column1 = items;
	132	} else {
	133	me.items = items;
	134	}
	135
34782e26	136	me.callParent();
34782e26 WL	137	}
	138	});
	139
9ea5485d WL	140	Ext.define('PVE.lxc.MemoryInputPanel', {
	141	extend: 'PVE.panel.InputPanel',
	142	alias: 'widget.pveLxcMemoryInputPanel',
	143
	144	insideWizard: false,
34782e26 WL	145
	146	initComponent : function() {
	147	var me = this;
	148
451bd04c DM	149	var items = [
	150	{
	151	xtype: 'numberfield',
	152	name: 'memory',
	153	minValue: 32,
	154	maxValue: 512*1024,
	155	value: '512',
	156	step: 32,
cdac4112	157	fieldLabel: gettext('Memory') + ' (MB)',
451bd04c DM	158	labelWidth: labelWidth,
	159	allowBlank: false
	160	},
	161	{
	162	xtype: 'numberfield',
	163	name: 'swap',
	164	minValue: 0,
	165	maxValue: 128*1024,
	166	value: '512',
	167	step: 32,
cdac4112	168	fieldLabel: gettext('Swap') + ' (MB)',
451bd04c DM	169	labelWidth: labelWidth,
	170	allowBlank: false
	171	}
	172	];
	173
	174	if (me.insideWizard) {
	175	me.column1 = items;
	176	} else {
	177	me.items = items;
	178	}
	179
34782e26	180	me.callParent();
34782e26 WL	181	}
34782e26 WL	182	});
946eb8cd WB	183
	184	Ext.define('PVE.lxc.MountPointInputPanel', {
	185	extend: 'PVE.panel.InputPanel',
	186	alias: 'widget.pveLxcMountPointInputPanel',
	187
	188	insideWizard: false,
	189
	190	unused: false, // ADD usused disk imaged
	191
	192	vmconfig: {}, // used to select usused disks
	193
	194	onGetValues: function(values) {
	195	var me = this;
	196
	197	var confid = me.confid \|\| values.mpsel;
	198
	199	if (me.unused) {
	200	me.mpdata.file = me.vmconfig[values.unusedId];
	201	confid = values.mpsel;
	202	} else if (me.create) {
	203	me.mpdata.file = values.storage + ':' + values.disksize;
	204	}
	205
30164175	206	if (confid !== 'rootfs') {
946eb8cd	207	me.mpdata.mp = values.mp;
30164175	208	}
946eb8cd	209
30164175	210	if (values.ro) {
946eb8cd	211	me.mpdata.ro = 1;
30164175	212	} else {
946eb8cd	213	delete me.mpdata.ro;
30164175	214	}
946eb8cd	215
30164175	216	if (values.quota) {
946eb8cd	217	me.mpdata.quota = 1;
30164175	218	} else {
946eb8cd	219	delete me.mpdata.quota;
30164175	220	}
946eb8cd	221
30164175	222	if (values.acl === 'Default') {
946eb8cd	223	delete me.mpdata.acl;
30164175	224	} else {
946eb8cd	225	me.mpdata.acl = values.acl;
30164175	226	}
946eb8cd WB	227
	228	var res = {};
	229	res[confid] = PVE.Parser.printLxcMountPoint(me.mpdata);
	230	return res;
	231	},
	232
	233	setMountPoint: function(mp) {
	234	var me = this;
	235
	236	me.mpdata = mp;
30164175 WB	237	if (!Ext.isDefined(me.mpdata.acl)) {
30164175 WB	238	me.mpdata.acl = 'Default';
946eb8cd WB	239	}
	240
	241	if (mp.type === 'bind') {
	242	me.quota.setDisabled(true);
	243	me.quota.setValue(false);
	244	}
	245
	246	me.setValues(mp);
	247	},
	248
	249	setVMConfig: function(vmconfig) {
	250	var me = this;
	251
	252	me.vmconfig = vmconfig;
	253
	254	if (me.mpsel) {
30164175 WB	255	var i;
30164175 WB	256	for (i = 0; i != 8; ++i) {
946eb8cd WB	257	var name = "mp" + i;
	258	if (!Ext.isDefined(vmconfig[name])) {
	259	me.mpsel.setValue(name);
	260	break;
	261	}
	262	}
	263	}
	264
	265	if (me.unusedDisks) {
	266	var disklist = [];
	267	Ext.Object.each(vmconfig, function(key, value) {
	268	if (key.match(/^unused\d+$/)) {
	269	disklist.push([key, value]);
	270	}
	271	});
	272	me.unusedDisks.store.loadData(disklist);
	273	me.unusedDisks.setValue(me.confid);
	274	}
	275	},
	276
	277	setNodename: function(nodename) {
	278	var me = this;
	279	me.hdstoragesel.setNodename(nodename);
	280	me.hdfilesel.setStorage(undefined, nodename);
	281	},
	282
	283	initComponent : function() {
	284	var me = this;
	285
	286	var isroot = me.confid === 'rootfs';
	287
	288	me.mpdata = {};
	289
	290	me.column1 = [];
	291
	292	if (!me.confid \|\| me.unused) {
	293	var names = [];
30164175 WB	294	var i;
30164175 WB	295	for (i = 0; i != 8; ++i) {
946eb8cd WB	296	var name = 'mp' + i;
	297	names.push([name, name]);
	298	}
	299	me.mpsel = Ext.create('PVE.form.KVComboBox', {
	300	name: 'mpsel',
	301	fieldLabel: gettext('Mount Point'),
	302	matchFieldWidth: false,
	303	allowBlank: false,
	304	data: names,
	305	validator: function(value) {
30164175	306	if (!me.rendered) {
946eb8cd	307	return;
30164175 WB	308	}
30164175 WB	309	if (Ext.isDefined(me.vmconfig[value])) {
946eb8cd	310	return "Mount point is already in use.";
30164175	311	}
946eb8cd WB	312	return true;
	313	},
	314	listeners: {
	315	change: function(field, value) {
	316	field.validate();
	317	}
30164175	318	}
946eb8cd WB	319	});
	320	me.column1.push(me.mpsel);
	321	}
	322
	323	// we always have this around, but only visible when creating a new mp
	324	// since this handles per-filesystem capabilities
	325	me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
	326	name: 'storage',
	327	nodename: me.nodename,
	328	fieldLabel: gettext('Storage'),
	329	storageContent: 'rootdir',
	330	allowBlank: false,
	331	autoSelect: true,
	332	hidden: me.unused \|\| !me.create,
	333	listeners: {
	334	change: function(f, value) {
	335	if (me.mpdata.type === 'bind') {
	336	me.quota.setDisabled(true);
	337	me.quota.setValue(false);
	338	return;
	339	}
	340	var rec = f.store.getById(value);
	341	if (rec.data.type === 'zfs' \|\|
	342	rec.data.type === 'zfspool') {
	343	me.quota.setDisabled(true);
	344	me.quota.setValue(false);
	345	} else {
	346	me.quota.setDisabled(false);
	347	}
30164175	348	if (me.unused \|\| !me.create) {
946eb8cd	349	return;
30164175	350	}
946eb8cd WB	351	if (rec.data.type === 'iscsi') {
	352	me.hdfilesel.setStorage(value);
	353	me.hdfilesel.setDisabled(false);
	354	me.hdfilesel.setVisible(true);
	355	me.hdsizesel.setDisabled(true);
	356	me.hdsizesel.setVisible(false);
	357	} else if (rec.data.type === 'lvm' \|\|
	358	rec.data.type === 'lvmthin' \|\|
	359	rec.data.type === 'rbd' \|\|
	360	rec.data.type === 'sheepdog' \|\|
	361	rec.data.type === 'zfs' \|\|
	362	rec.data.type === 'zfspool') {
	363	me.hdfilesel.setDisabled(true);
	364	me.hdfilesel.setVisible(false);
	365	me.hdsizesel.setDisabled(false);
	366	me.hdsizesel.setVisible(true);
	367	} else {
	368	me.hdfilesel.setDisabled(true);
	369	me.hdfilesel.setVisible(false);
	370	me.hdsizesel.setDisabled(false);
	371	me.hdsizesel.setVisible(true);
	372	}
30164175 WB	373	}
30164175 WB	374	}
946eb8cd WB	375	});
	376	me.column1.push(me.hdstoragesel);
	377
	378	if (me.unused) {
	379	me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
	380	name: 'unusedId',
	381	fieldLabel: gettext('Disk image'),
	382	matchFieldWidth: false,
	383	listConfig: {
	384	width: 350
	385	},
	386	data: [],
	387	allowBlank: false,
	388	listeners: {
	389	change: function(f, value) {
	390	// make sure our buttons are enabled/disabled when switching
	391	// between images on different storages:
	392	var disk = me.vmconfig[value];
	393	var storage = disk.split(':')[0];
	394	me.hdstoragesel.setValue(storage);
30164175 WB	395	}
30164175 WB	396	}
946eb8cd WB	397	});
	398	me.column1.push(me.unusedDisks);
	399	} else if (me.create) {
	400	me.hdfilesel = Ext.create('PVE.form.FileSelector', {
	401	name: 'file',
	402	nodename: me.nodename,
	403	storageContent: 'images',
	404	fieldLabel: gettext('Disk image'),
	405	disabled: true,
	406	hidden: true,
	407	allowBlank: false
	408	});
	409	me.hdsizesel = Ext.createWidget('numberfield', {
	410	name: 'disksize',
	411	minValue: 0.1,
	412	maxValue: 128*1024,
	413	decimalPrecision: 3,
	414	value: '8',
	415	step: 1,
	416	fieldLabel: gettext('Disk size') + ' (GB)',
	417	allowBlank: false
	418	});
	419	me.column1.push(me.hdfilesel);
	420	me.column1.push(me.hdsizesel);
	421	} else {
	422	me.column1.push({
	423	xtype: 'textfield',
	424	disabled: true,
	425	submitValue: false,
	426	fieldLabel: gettext('Disk image'),
	427	name: 'file'
	428	});
	429	}
	430
	431	me.quota = Ext.createWidget('pvecheckbox', {
	432	name: 'quota',
	433	defaultValue: 0,
30164175	434	fieldLabel: gettext('Enable quota')
946eb8cd WB	435	});
	436
	437	me.column2 = [
	438	{
	439	xtype: 'pvecheckbox',
	440	name: 'ro',
	441	defaultValue: 0,
	442	fieldLabel: gettext('Read-only'),
30164175	443	hidden: me.insideWizard
946eb8cd WB	444	},
	445	{
	446	xtype: 'pveKVComboBox',
	447	name: 'acl',
	448	fieldLabel: gettext('ACLs'),
	449	data: [['Default', 'Default'], ['1', 'On'], ['0', 'Off']],
	450	value: 'Default',
30164175	451	allowBlank: true
946eb8cd	452	},
30164175	453	me.quota
946eb8cd WB	454	];
	455
	456	if (!isroot) {
	457	me.column2.push({
	458	xtype: 'textfield',
	459	name: 'mp',
	460	value: '',
69a30784	461	emptyText: gettext('/some/path'),
946eb8cd WB	462	allowBlank: false,
946eb8cd WB	463	hidden: isroot,
30164175	464	fieldLabel: gettext('Path')
946eb8cd	465	});
30164175	466	}
946eb8cd WB	467
	468	me.callParent();
	469	}
	470	});