[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.acl.setDisabled(true);
	    me.acl.setValue('Default');
	}

	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);
			me.acl.setDisabled(true);
			me.acl.setValue('Default');
			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.acl = Ext.createWidget('pveKVComboBox', {
	    name: 'acl',
	    fieldLabel: gettext('ACLs'),
	    data: [['Default', 'Default'], ['1', 'On'], ['0', 'Off']],
	    value: 'Default',
	    allowBlank: true
	});

	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
	    },
	    me.acl,
	    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);
17ab437f WB	244	me.acl.setDisabled(true);
17ab437f WB	245	me.acl.setValue('Default');
946eb8cd WB	246	}
	247
	248	me.setValues(mp);
	249	},
	250
	251	setVMConfig: function(vmconfig) {
	252	var me = this;
	253
	254	me.vmconfig = vmconfig;
	255
	256	if (me.mpsel) {
30164175 WB	257	var i;
30164175 WB	258	for (i = 0; i != 8; ++i) {
946eb8cd WB	259	var name = "mp" + i;
	260	if (!Ext.isDefined(vmconfig[name])) {
	261	me.mpsel.setValue(name);
	262	break;
	263	}
	264	}
	265	}
	266
	267	if (me.unusedDisks) {
	268	var disklist = [];
	269	Ext.Object.each(vmconfig, function(key, value) {
	270	if (key.match(/^unused\d+$/)) {
	271	disklist.push([key, value]);
	272	}
	273	});
	274	me.unusedDisks.store.loadData(disklist);
	275	me.unusedDisks.setValue(me.confid);
	276	}
	277	},
	278
	279	setNodename: function(nodename) {
	280	var me = this;
	281	me.hdstoragesel.setNodename(nodename);
	282	me.hdfilesel.setStorage(undefined, nodename);
	283	},
	284
	285	initComponent : function() {
	286	var me = this;
	287
	288	var isroot = me.confid === 'rootfs';
	289
	290	me.mpdata = {};
	291
	292	me.column1 = [];
	293
	294	if (!me.confid \|\| me.unused) {
	295	var names = [];
30164175 WB	296	var i;
30164175 WB	297	for (i = 0; i != 8; ++i) {
946eb8cd WB	298	var name = 'mp' + i;
	299	names.push([name, name]);
	300	}
	301	me.mpsel = Ext.create('PVE.form.KVComboBox', {
	302	name: 'mpsel',
	303	fieldLabel: gettext('Mount Point'),
	304	matchFieldWidth: false,
	305	allowBlank: false,
	306	data: names,
	307	validator: function(value) {
30164175	308	if (!me.rendered) {
946eb8cd	309	return;
30164175 WB	310	}
30164175 WB	311	if (Ext.isDefined(me.vmconfig[value])) {
946eb8cd	312	return "Mount point is already in use.";
30164175	313	}
946eb8cd WB	314	return true;
	315	},
	316	listeners: {
	317	change: function(field, value) {
	318	field.validate();
	319	}
30164175	320	}
946eb8cd WB	321	});
	322	me.column1.push(me.mpsel);
	323	}
	324
	325	// we always have this around, but only visible when creating a new mp
	326	// since this handles per-filesystem capabilities
	327	me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
	328	name: 'storage',
	329	nodename: me.nodename,
	330	fieldLabel: gettext('Storage'),
	331	storageContent: 'rootdir',
	332	allowBlank: false,
	333	autoSelect: true,
	334	hidden: me.unused \|\| !me.create,
	335	listeners: {
	336	change: function(f, value) {
	337	if (me.mpdata.type === 'bind') {
	338	me.quota.setDisabled(true);
	339	me.quota.setValue(false);
17ab437f WB	340	me.acl.setDisabled(true);
17ab437f WB	341	me.acl.setValue('Default');
946eb8cd WB	342	return;
	343	}
	344	var rec = f.store.getById(value);
	345	if (rec.data.type === 'zfs' \|\|
	346	rec.data.type === 'zfspool') {
	347	me.quota.setDisabled(true);
	348	me.quota.setValue(false);
	349	} else {
	350	me.quota.setDisabled(false);
	351	}
30164175	352	if (me.unused \|\| !me.create) {
946eb8cd	353	return;
30164175	354	}
946eb8cd WB	355	if (rec.data.type === 'iscsi') {
	356	me.hdfilesel.setStorage(value);
	357	me.hdfilesel.setDisabled(false);
	358	me.hdfilesel.setVisible(true);
	359	me.hdsizesel.setDisabled(true);
	360	me.hdsizesel.setVisible(false);
	361	} else if (rec.data.type === 'lvm' \|\|
	362	rec.data.type === 'lvmthin' \|\|
	363	rec.data.type === 'rbd' \|\|
	364	rec.data.type === 'sheepdog' \|\|
	365	rec.data.type === 'zfs' \|\|
	366	rec.data.type === 'zfspool') {
	367	me.hdfilesel.setDisabled(true);
	368	me.hdfilesel.setVisible(false);
	369	me.hdsizesel.setDisabled(false);
	370	me.hdsizesel.setVisible(true);
	371	} else {
	372	me.hdfilesel.setDisabled(true);
	373	me.hdfilesel.setVisible(false);
	374	me.hdsizesel.setDisabled(false);
	375	me.hdsizesel.setVisible(true);
	376	}
30164175 WB	377	}
30164175 WB	378	}
946eb8cd WB	379	});
	380	me.column1.push(me.hdstoragesel);
	381
	382	if (me.unused) {
	383	me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
	384	name: 'unusedId',
	385	fieldLabel: gettext('Disk image'),
	386	matchFieldWidth: false,
	387	listConfig: {
	388	width: 350
	389	},
	390	data: [],
	391	allowBlank: false,
	392	listeners: {
	393	change: function(f, value) {
	394	// make sure our buttons are enabled/disabled when switching
	395	// between images on different storages:
	396	var disk = me.vmconfig[value];
	397	var storage = disk.split(':')[0];
	398	me.hdstoragesel.setValue(storage);
30164175 WB	399	}
30164175 WB	400	}
946eb8cd WB	401	});
	402	me.column1.push(me.unusedDisks);
	403	} else if (me.create) {
	404	me.hdfilesel = Ext.create('PVE.form.FileSelector', {
	405	name: 'file',
	406	nodename: me.nodename,
	407	storageContent: 'images',
	408	fieldLabel: gettext('Disk image'),
	409	disabled: true,
	410	hidden: true,
	411	allowBlank: false
	412	});
	413	me.hdsizesel = Ext.createWidget('numberfield', {
	414	name: 'disksize',
	415	minValue: 0.1,
	416	maxValue: 128*1024,
	417	decimalPrecision: 3,
	418	value: '8',
	419	step: 1,
	420	fieldLabel: gettext('Disk size') + ' (GB)',
	421	allowBlank: false
	422	});
	423	me.column1.push(me.hdfilesel);
	424	me.column1.push(me.hdsizesel);
	425	} else {
	426	me.column1.push({
	427	xtype: 'textfield',
	428	disabled: true,
	429	submitValue: false,
	430	fieldLabel: gettext('Disk image'),
	431	name: 'file'
	432	});
	433	}
	434
17ab437f WB	435	me.acl = Ext.createWidget('pveKVComboBox', {
	436	name: 'acl',
	437	fieldLabel: gettext('ACLs'),
	438	data: [['Default', 'Default'], ['1', 'On'], ['0', 'Off']],
	439	value: 'Default',
	440	allowBlank: true
	441	});
	442
946eb8cd WB	443	me.quota = Ext.createWidget('pvecheckbox', {
	444	name: 'quota',
	445	defaultValue: 0,
30164175	446	fieldLabel: gettext('Enable quota')
946eb8cd WB	447	});
	448
	449	me.column2 = [
	450	{
	451	xtype: 'pvecheckbox',
	452	name: 'ro',
	453	defaultValue: 0,
	454	fieldLabel: gettext('Read-only'),
30164175	455	hidden: me.insideWizard
946eb8cd	456	},
17ab437f	457	me.acl,
30164175	458	me.quota
946eb8cd WB	459	];
	460
	461	if (!isroot) {
	462	me.column2.push({
	463	xtype: 'textfield',
	464	name: 'mp',
	465	value: '',
69a30784	466	emptyText: gettext('/some/path'),
946eb8cd WB	467	allowBlank: false,
946eb8cd WB	468	hidden: isroot,
30164175	469	fieldLabel: gettext('Path')
946eb8cd	470	});
30164175	471	}
946eb8cd WB	472
	473	me.callParent();
	474	}
	475	});