www/manager6/qemu/HardwareView.js

   1 Ext.define('PVE.qemu.HardwareView', {
   2     extend: 'Proxmox.grid.PendingObjectGrid',
   3     alias: ['widget.PVE.qemu.HardwareView'],
   4
   5     onlineHelp: 'qm_virtual_machines_settings',
   6
   7     renderKey: function(key, metaData, rec, rowIndex, colIndex, store) {
   8         var me = this;
   9         var rows = me.rows;
  10         var rowdef = rows[key] || {};
  11         var iconCls = rowdef.iconCls;
  12         var icon = '';
  13         var txt = rowdef.header || key;
  14
  15         metaData.tdAttr = "valign=middle";
  16
  17         if (rowdef.isOnStorageBus) {
  18             var value = me.getObjectValue(key, '', false);
  19             if (value === '') {
  20                 value = me.getObjectValue(key, '', true);
  21             }
  22             if (value.match(/vm-.*-cloudinit/)) {
  23                 iconCls = 'cloud';
  24                 txt = rowdef.cloudheader;
  25             } else if (value.match(/media=cdrom/)) {
  26                 metaData.tdCls = 'pve-itype-icon-cdrom';
  27                 return rowdef.cdheader;
  28             }
  29         }
  30
  31         if (rowdef.tdCls) {
  32             metaData.tdCls = rowdef.tdCls;
  33         } else if (iconCls) {
  34             icon = "<i class='pve-grid-fa fa fa-fw fa-" + iconCls + "'></i>";
  35             metaData.tdCls += " pve-itype-fa";
  36         }
  37
  38         // only return icons in grid but not remove dialog
  39         if (rowIndex !== undefined) {
  40             return icon + txt;
  41         } else {
  42             return txt;
  43         }
  44     },
  45
  46     initComponent: function() {
  47         var me = this;
  48         var i, confid;
  49
  50         var nodename = me.pveSelNode.data.node;
  51         if (!nodename) {
  52             throw "no node name specified";
  53         }
  54
  55         var vmid = me.pveSelNode.data.vmid;
  56         if (!vmid) {
  57             throw "no VM ID specified";
  58         }
  59
  60         var caps = Ext.state.Manager.get('GuiCap');
  61         var diskCap = caps.vms['VM.Config.Disk'];
  62
  63         var rows = {
  64             memory: {
  65                 header: gettext('Memory'),
  66                 editor: caps.vms['VM.Config.Memory'] ? 'PVE.qemu.MemoryEdit' : undefined,
  67                 never_delete: true,
  68                 defaultValue: '512',
  69                 tdCls: 'pve-itype-icon-memory',
  70                 group: 2,
  71                 multiKey: ['memory', 'balloon', 'shares'],
  72                 renderer: function(value, metaData, record, ri, ci, store, pending) {
  73                     var res = '';
  74
  75                     var max = me.getObjectValue('memory', 512, pending);
  76                     var balloon = me.getObjectValue('balloon', undefined, pending);
  77                     var shares = me.getObjectValue('shares', undefined, pending);
  78
  79                     res = Proxmox.Utils.format_size(max*1024*1024);
  80
  81                     if (balloon !== undefined && balloon > 0) {
  82                         res = Proxmox.Utils.format_size(balloon*1024*1024) + "/" + res;
  83
  84                         if (shares) {
  85                             res += ' [shares=' + shares +']';
  86                         }
  87                     } else if (balloon === 0) {
  88                         res += ' [balloon=0]';
  89                     }
  90                     return res;
  91                 },
  92             },
  93             sockets: {
  94                 header: gettext('Processors'),
  95                 never_delete: true,
  96                 editor: caps.vms['VM.Config.CPU'] || caps.vms['VM.Config.HWType']
  97                     ? 'PVE.qemu.ProcessorEdit' : undefined,
  98                 tdCls: 'pve-itype-icon-processor',
  99                 group: 3,
 100                 defaultValue: '1',
 101                 multiKey: ['sockets', 'cpu', 'cores', 'numa', 'vcpus', 'cpulimit', 'cpuunits'],
 102                 renderer: function(value, metaData, record, rowIndex, colIndex, store, pending) {
 103                     var sockets = me.getObjectValue('sockets', 1, pending);
 104                     var model = me.getObjectValue('cpu', undefined, pending);
 105                     var cores = me.getObjectValue('cores', 1, pending);
 106                     var numa = me.getObjectValue('numa', undefined, pending);
 107                     var vcpus = me.getObjectValue('vcpus', undefined, pending);
 108                     var cpulimit = me.getObjectValue('cpulimit', undefined, pending);
 109                     var cpuunits = me.getObjectValue('cpuunits', undefined, pending);
 110
 111                     var res = Ext.String.format('{0} ({1} sockets, {2} cores)',
 112                         sockets*cores, sockets, cores);
 113
 114                     if (model) {
 115                         res += ' [' + model + ']';
 116                     }
 117
 118                     if (numa) {
 119                         res += ' [numa=' + numa +']';
 120                     }
 121
 122                     if (vcpus) {
 123                         res += ' [vcpus=' + vcpus +']';
 124                     }
 125
 126                     if (cpulimit) {
 127                         res += ' [cpulimit=' + cpulimit +']';
 128                     }
 129
 130                     if (cpuunits) {
 131                         res += ' [cpuunits=' + cpuunits +']';
 132                     }
 133
 134                     return res;
 135                 },
 136             },
 137             bios: {
 138                 header: 'BIOS',
 139                 group: 4,
 140                 never_delete: true,
 141                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.BiosEdit' : undefined,
 142                 defaultValue: '',
 143                 iconCls: 'microchip',
 144                 renderer: PVE.Utils.render_qemu_bios,
 145             },
 146             vga: {
 147                 header: gettext('Display'),
 148                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.DisplayEdit' : undefined,
 149                 never_delete: true,
 150                 iconCls: 'desktop',
 151                 group: 5,
 152                 defaultValue: '',
 153                 renderer: PVE.Utils.render_kvm_vga_driver,
 154             },
 155             machine: {
 156                 header: gettext('Machine'),
 157                 editor: caps.vms['VM.Config.HWType'] ? {
 158                     xtype: 'proxmoxWindowEdit',
 159                     subject: gettext('Machine'),
 160                     width: 350,
 161                     items: [{
 162                         xtype: 'proxmoxKVComboBox',
 163                         name: 'machine',
 164                         value: '__default__',
 165                         fieldLabel: gettext('Machine'),
 166                         comboItems: [
 167                             ['__default__', PVE.Utils.render_qemu_machine('')],
 168                             ['q35', 'q35'],
 169                         ],
 170                     }],
 171 } : undefined,
 172                 iconCls: 'cogs',
 173                 never_delete: true,
 174                 group: 6,
 175                 defaultValue: '',
 176                 renderer: PVE.Utils.render_qemu_machine,
 177             },
 178             scsihw: {
 179                 header: gettext('SCSI Controller'),
 180                 iconCls: 'database',
 181                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.ScsiHwEdit' : undefined,
 182                 renderer: PVE.Utils.render_scsihw,
 183                 group: 7,
 184                 never_delete: true,
 185                 defaultValue: '',
 186             },
 187             vmstate: {
 188                 header: gettext('Hibernation VM State'),
 189                 iconCls: 'download',
 190                 del_extra_msg: gettext('The saved VM state will be permanently lost.'),
 191                 group: 100,
 192             },
 193             cores: {
 194                 visible: false,
 195             },
 196             cpu: {
 197                 visible: false,
 198             },
 199             numa: {
 200                 visible: false,
 201             },
 202             balloon: {
 203                 visible: false,
 204             },
 205             hotplug: {
 206                 visible: false,
 207             },
 208             vcpus: {
 209                 visible: false,
 210             },
 211             cpuunits: {
 212                 visible: false,
 213             },
 214             cpulimit: {
 215                 visible: false,
 216             },
 217             shares: {
 218                 visible: false,
 219             },
 220         };
 221
 222         PVE.Utils.forEachBus(undefined, function(type, id) {
 223             var confid = type + id;
 224             rows[confid] = {
 225                 group: 10,
 226                 iconCls: 'hdd-o',
 227                 editor: 'PVE.qemu.HDEdit',
 228                 never_delete: !caps.vms['VM.Config.Disk'],
 229                 isOnStorageBus: true,
 230                 header: gettext('Hard Disk') + ' (' + confid +')',
 231                 cdheader: gettext('CD/DVD Drive') + ' (' + confid +')',
 232                 cloudheader: gettext('CloudInit Drive') + ' (' + confid + ')',
 233             };
 234         });
 235         for (i = 0; i < PVE.Utils.hardware_counts.net; i++) {
 236             confid = "net" + i.toString();
 237             rows[confid] = {
 238                 group: 15,
 239                 order: i,
 240                 iconCls: 'exchange',
 241                 editor: caps.vms['VM.Config.Network'] ? 'PVE.qemu.NetworkEdit' : undefined,
 242                 never_delete: !caps.vms['VM.Config.Network'],
 243                 header: gettext('Network Device') + ' (' + confid +')',
 244             };
 245         }
 246         rows.efidisk0 = {
 247             group: 20,
 248             iconCls: 'hdd-o',
 249             editor: null,
 250             never_delete: !caps.vms['VM.Config.Disk'],
 251             header: gettext('EFI Disk'),
 252         };
 253         for (i = 0; i < PVE.Utils.hardware_counts.usb; i++) {
 254             confid = "usb" + i.toString();
 255             rows[confid] = {
 256                 group: 25,
 257                 order: i,
 258                 iconCls: 'usb',
 259                 editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.USBEdit' : undefined,
 260                 never_delete: !caps.nodes['Sys.Console'],
 261                 header: gettext('USB Device') + ' (' + confid + ')',
 262             };
 263         }
 264         for (i = 0; i < PVE.Utils.hardware_counts.hostpci; i++) {
 265             confid = "hostpci" + i.toString();
 266             rows[confid] = {
 267                 group: 30,
 268                 order: i,
 269                 tdCls: 'pve-itype-icon-pci',
 270                 never_delete: !caps.nodes['Sys.Console'],
 271                 editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.PCIEdit' : undefined,
 272                 header: gettext('PCI Device') + ' (' + confid + ')',
 273             };
 274         }
 275         for (i = 0; i < PVE.Utils.hardware_counts.serial; i++) {
 276             confid = "serial" + i.toString();
 277             rows[confid] = {
 278                 group: 35,
 279                 order: i,
 280                 tdCls: 'pve-itype-icon-serial',
 281                 never_delete: !caps.nodes['Sys.Console'],
 282                 header: gettext('Serial Port') + ' (' + confid + ')',
 283             };
 284         }
 285         rows.audio0 = {
 286             group: 40,
 287             iconCls: 'volume-up',
 288             editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.AudioEdit' : undefined,
 289             never_delete: !caps.vms['VM.Config.HWType'],
 290             header: gettext('Audio Device'),
 291         };
 292         for (i = 0; i < 256; i++) {
 293             rows["unused" + i.toString()] = {
 294                 group: 99,
 295                 order: i,
 296                 iconCls: 'hdd-o',
 297                 del_extra_msg: gettext('This will permanently erase all data.'),
 298                 editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.HDEdit' : undefined,
 299                 header: gettext('Unused Disk') + ' ' + i.toString(),
 300             };
 301         }
 302         rows.rng0 = {
 303             group: 45,
 304             tdCls: 'pve-itype-icon-die',
 305             editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.RNGEdit' : undefined,
 306             never_delete: !caps.nodes['Sys.Console'],
 307             header: gettext("VirtIO RNG"),
 308         };
 309
 310         var sorterFn = function(rec1, rec2) {
 311             var v1 = rec1.data.key;
 312             var v2 = rec2.data.key;
 313             var g1 = rows[v1].group || 0;
 314             var g2 = rows[v2].group || 0;
 315             var order1 = rows[v1].order || 0;
 316             var order2 = rows[v2].order || 0;
 317
 318             if (g1 - g2 !== 0) {
 319                 return g1 - g2;
 320             }
 321
 322             if (order1 - order2 !== 0) {
 323                 return order1 - order2;
 324             }
 325
 326             if (v1 > v2) {
 327                 return 1;
 328             } else if (v1 < v2) {
 329                 return -1;
 330             } else {
 331                 return 0;
 332             }
 333         };
 334
 335         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 336
 337         var sm = Ext.create('Ext.selection.RowModel', {});
 338
 339         var run_editor = function() {
 340             var rec = sm.getSelection()[0];
 341             if (!rec) {
 342                 return;
 343             }
 344
 345             var rowdef = rows[rec.data.key];
 346             if (!rowdef.editor) {
 347                 return;
 348             }
 349
 350             var editor = rowdef.editor;
 351             if (rowdef.isOnStorageBus) {
 352                 var value = me.getObjectValue(rec.data.key, '', true);
 353                 if (value.match(/vm-.*-cloudinit/)) {
 354                     return;
 355                 } else if (value.match(/media=cdrom/)) {
 356                     editor = 'PVE.qemu.CDEdit';
 357                 } else if (!diskCap) {
 358                     return;
 359                 }
 360             }
 361
 362             var win;
 363
 364             if (Ext.isString(editor)) {
 365                 win = Ext.create(editor, {
 366                     pveSelNode: me.pveSelNode,
 367                     confid: rec.data.key,
 368                     url: '/api2/extjs/' + baseurl,
 369                 });
 370             } else {
 371                 var config = Ext.apply({
 372                     pveSelNode: me.pveSelNode,
 373                     confid: rec.data.key,
 374                     url: '/api2/extjs/' + baseurl,
 375                 }, rowdef.editor);
 376                 win = Ext.createWidget(rowdef.editor.xtype, config);
 377                 win.load();
 378             }
 379
 380             win.show();
 381             win.on('destroy', me.reload, me);
 382         };
 383
 384         var run_resize = function() {
 385             var rec = sm.getSelection()[0];
 386             if (!rec) {
 387                 return;
 388             }
 389
 390             var win = Ext.create('PVE.window.HDResize', {
 391                 disk: rec.data.key,
 392                 nodename: nodename,
 393                 vmid: vmid,
 394             });
 395
 396             win.show();
 397
 398             win.on('destroy', me.reload, me);
 399         };
 400
 401         var run_move = function() {
 402             var rec = sm.getSelection()[0];
 403             if (!rec) {
 404                 return;
 405             }
 406
 407             var win = Ext.create('PVE.window.HDMove', {
 408                 disk: rec.data.key,
 409                 nodename: nodename,
 410                 vmid: vmid,
 411             });
 412
 413             win.show();
 414
 415             win.on('destroy', me.reload, me);
 416         };
 417
 418         var edit_btn = new Proxmox.button.Button({
 419             text: gettext('Edit'),
 420             selModel: sm,
 421             disabled: true,
 422             handler: run_editor,
 423         });
 424
 425         var resize_btn = new Proxmox.button.Button({
 426             text: gettext('Resize disk'),
 427             selModel: sm,
 428             disabled: true,
 429             handler: run_resize,
 430         });
 431
 432         var move_btn = new Proxmox.button.Button({
 433             text: gettext('Move disk'),
 434             selModel: sm,
 435             disabled: true,
 436             handler: run_move,
 437         });
 438
 439         var remove_btn = new Proxmox.button.Button({
 440             text: gettext('Remove'),
 441             defaultText: gettext('Remove'),
 442             altText: gettext('Detach'),
 443             selModel: sm,
 444             disabled: true,
 445             dangerous: true,
 446             RESTMethod: 'PUT',
 447             confirmMsg: function(rec) {
 448                 var warn = gettext('Are you sure you want to remove entry {0}');
 449                 if (this.text === this.altText) {
 450                     warn = gettext('Are you sure you want to detach entry {0}');
 451                 }
 452                 var key = rec.data.key;
 453                 var entry = rows[key];
 454
 455                 var rendered = me.renderKey(key, {}, rec);
 456                 var msg = Ext.String.format(warn, "'" + rendered + "'");
 457
 458                 if (entry.del_extra_msg) {
 459                     msg += '<br>' + entry.del_extra_msg;
 460                 }
 461
 462                 return msg;
 463             },
 464             handler: function(b, e, rec) {
 465                 Proxmox.Utils.API2Request({
 466                     url: '/api2/extjs/' + baseurl,
 467                     waitMsgTarget: me,
 468                     method: b.RESTMethod,
 469                     params: {
 470                         'delete': rec.data.key,
 471                     },
 472                     callback: () => me.reload(),
 473                     failure: function(response, opts) {
 474                         Ext.Msg.alert('Error', response.htmlStatus);
 475                     },
 476                     success: function(response, options) {
 477                         if (b.RESTMethod === 'POST') {
 478                             var upid = response.result.data;
 479                             var win = Ext.create('Proxmox.window.TaskProgress', {
 480                                 upid: upid,
 481                                 listeners: {
 482                                     destroy: () => me.reload(),
 483                                 },
 484                             });
 485                             win.show();
 486                         }
 487                     },
 488                 });
 489             },
 490             listeners: {
 491                 render: function(btn) {
 492                     // hack: calculate an optimal button width on first display
 493                     // to prevent the whole toolbar to move when we switch
 494                     // between the "Remove" and "Detach" labels
 495                     var def = btn.getSize().width;
 496
 497                     btn.setText(btn.altText);
 498                     var alt = btn.getSize().width;
 499
 500                     btn.setText(btn.defaultText);
 501
 502                     var optimal = alt > def ? alt : def;
 503                     btn.setSize({ width: optimal });
 504                 },
 505             },
 506         });
 507
 508         var revert_btn = new PVE.button.PendingRevert({
 509             apiurl: '/api2/extjs/' + baseurl,
 510         });
 511
 512         var efidisk_menuitem = Ext.create('Ext.menu.Item', {
 513             text: gettext('EFI Disk'),
 514             iconCls: 'fa fa-fw fa-hdd-o black',
 515             disabled: !caps.vms['VM.Config.Disk'],
 516             handler: function() {
 517                 let bios = me.rstore.getData().map.bios;
 518                 let usesEFI = bios && (bios.data.value === 'ovmf' || bios.data.pending === 'ovmf');
 519
 520                 var win = Ext.create('PVE.qemu.EFIDiskEdit', {
 521                     url: '/api2/extjs/' + baseurl,
 522                     pveSelNode: me.pveSelNode,
 523                     usesEFI: usesEFI,
 524                 });
 525                 win.on('destroy', me.reload, me);
 526                 win.show();
 527             },
 528         });
 529
 530         let counts = {};
 531         let isAtLimit = (type) => counts[type] >= PVE.Utils.hardware_counts[type];
 532
 533         var set_button_status = function() {
 534             var sm = me.getSelectionModel();
 535             var rec = sm.getSelection()[0];
 536
 537             // en/disable hardwarebuttons
 538             counts = {};
 539             var hasCloudInit = false;
 540             me.rstore.getData().items.forEach(function(item) {
 541                 if (!hasCloudInit && (
 542                     /vm-.*-cloudinit/.test(item.data.value) ||
 543                     /vm-.*-cloudinit/.test(item.data.pending)
 544                 )) {
 545                     hasCloudInit = true;
 546                     return;
 547                 }
 548
 549                 let match = item.id.match(/^([^\d]+)\d+$/);
 550                 let type;
 551                 if (match && PVE.Utils.hardware_counts[match[1]] !== undefined) {
 552                     type = match[1];
 553                 } else {
 554                     return;
 555                 }
 556
 557                 counts[type] = (counts[type] || 0) + 1;
 558             });
 559
 560             // heuristic only for disabling some stuff, the backend has the final word.
 561             const noSysConsolePerm = !caps.nodes['Sys.Console'];
 562             const noVMConfigHWTypePerm = !caps.vms['VM.Config.HWType'];
 563             const noVMConfigNetPerm = !caps.vms['VM.Config.Network'];
 564             const noVMConfigDiskPerm = !caps.vms['VM.Config.Disk'];
 565
 566
 567             me.down('#addusb').setDisabled(noSysConsolePerm || isAtLimit('usb'));
 568             me.down('#addpci').setDisabled(noSysConsolePerm || isAtLimit('hostpci'));
 569             me.down('#addaudio').setDisabled(noVMConfigHWTypePerm || isAtLimit('audio'));
 570             me.down('#addserial').setDisabled(noVMConfigHWTypePerm || isAtLimit('serial'));
 571             me.down('#addnet').setDisabled(noVMConfigNetPerm || isAtLimit('net'));
 572             me.down('#addrng').setDisabled(noSysConsolePerm || isAtLimit('rng'));
 573             efidisk_menuitem.setDisabled(noVMConfigDiskPerm || isAtLimit('efidisk'));
 574             me.down('#addci').setDisabled(noSysConsolePerm || hasCloudInit);
 575
 576             if (!rec) {
 577                 remove_btn.disable();
 578                 edit_btn.disable();
 579                 resize_btn.disable();
 580                 move_btn.disable();
 581                 revert_btn.disable();
 582                 return;
 583             }
 584             var key = rec.data.key;
 585             var value = rec.data.value;
 586             var rowdef = rows[key];
 587
 588             var pending = rec.data.delete || me.hasPendingChanges(key);
 589             var isCDRom = value && !!value.toString().match(/media=cdrom/);
 590             var isUnusedDisk = key.match(/^unused\d+/);
 591             var isUsedDisk = !isUnusedDisk && rowdef.isOnStorageBus && !isCDRom;
 592
 593             var isCloudInit = value && value.toString().match(/vm-.*-cloudinit/);
 594
 595             var isEfi = key === 'efidisk0';
 596
 597             remove_btn.setDisabled(rec.data.delete || rowdef.never_delete === true || (isUnusedDisk && !diskCap));
 598             remove_btn.setText(isUsedDisk && !isCloudInit ? remove_btn.altText : remove_btn.defaultText);
 599             remove_btn.RESTMethod = isUnusedDisk ? 'POST':'PUT';
 600
 601             edit_btn.setDisabled(rec.data.delete || !rowdef.editor || isCloudInit || (!isCDRom && !diskCap));
 602
 603             resize_btn.setDisabled(pending || !isUsedDisk || !diskCap);
 604
 605             move_btn.setDisabled(pending || !(isUsedDisk || isEfi) || !diskCap);
 606
 607             revert_btn.setDisabled(!pending);
 608         };
 609
 610         Ext.apply(me, {
 611             url: '/api2/json/' + 'nodes/' + nodename + '/qemu/' + vmid + '/pending',
 612             interval: 5000,
 613             selModel: sm,
 614             run_editor: run_editor,
 615             tbar: [
 616                 {
 617                     text: gettext('Add'),
 618                     menu: new Ext.menu.Menu({
 619                         cls: 'pve-add-hw-menu',
 620                         items: [
 621                             {
 622                                 text: gettext('Hard Disk'),
 623                                 iconCls: 'fa fa-fw fa-hdd-o black',
 624                                 disabled: !caps.vms['VM.Config.Disk'],
 625                                 handler: function() {
 626                                     var win = Ext.create('PVE.qemu.HDEdit', {
 627                                         url: '/api2/extjs/' + baseurl,
 628                                         pveSelNode: me.pveSelNode,
 629                                     });
 630                                     win.on('destroy', me.reload, me);
 631                                     win.show();
 632                                 },
 633                             },
 634                             {
 635                                 text: gettext('CD/DVD Drive'),
 636                                 iconCls: 'pve-itype-icon-cdrom',
 637                                 disabled: !caps.vms['VM.Config.Disk'],
 638                                 handler: function() {
 639                                     var win = Ext.create('PVE.qemu.CDEdit', {
 640                                         url: '/api2/extjs/' + baseurl,
 641                                         pveSelNode: me.pveSelNode,
 642                                     });
 643                                     win.on('destroy', me.reload, me);
 644                                     win.show();
 645                                 },
 646                             },
 647                             {
 648                                 text: gettext('Network Device'),
 649                                 itemId: 'addnet',
 650                                 iconCls: 'fa fa-fw fa-exchange black',
 651                                 disabled: !caps.vms['VM.Config.Network'],
 652                                 handler: function() {
 653                                     var win = Ext.create('PVE.qemu.NetworkEdit', {
 654                                         url: '/api2/extjs/' + baseurl,
 655                                         pveSelNode: me.pveSelNode,
 656                                         isCreate: true,
 657                                     });
 658                                     win.on('destroy', me.reload, me);
 659                                     win.show();
 660                                 },
 661                             },
 662                             efidisk_menuitem,
 663                             {
 664                                 text: gettext('USB Device'),
 665                                 itemId: 'addusb',
 666                                 iconCls: 'fa fa-fw fa-usb black',
 667                                 disabled: !caps.nodes['Sys.Console'],
 668                                 handler: function() {
 669                                     var win = Ext.create('PVE.qemu.USBEdit', {
 670                                         url: '/api2/extjs/' + baseurl,
 671                                         pveSelNode: me.pveSelNode,
 672                                     });
 673                                     win.on('destroy', me.reload, me);
 674                                     win.show();
 675                                 },
 676                             },
 677                             {
 678                                 text: gettext('PCI Device'),
 679                                 itemId: 'addpci',
 680                                 iconCls: 'pve-itype-icon-pci',
 681                                 disabled: !caps.nodes['Sys.Console'],
 682                                 handler: function() {
 683                                     var win = Ext.create('PVE.qemu.PCIEdit', {
 684                                         url: '/api2/extjs/' + baseurl,
 685                                         pveSelNode: me.pveSelNode,
 686                                     });
 687                                     win.on('destroy', me.reload, me);
 688                                     win.show();
 689                                 },
 690                             },
 691                             {
 692                                 text: gettext('Serial Port'),
 693                                 itemId: 'addserial',
 694                                 iconCls: 'pve-itype-icon-serial',
 695                                 disabled: !caps.vms['VM.Config.Options'],
 696                                 handler: function() {
 697                                     var win = Ext.create('PVE.qemu.SerialEdit', {
 698                                         url: '/api2/extjs/' + baseurl,
 699                                     });
 700                                     win.on('destroy', me.reload, me);
 701                                     win.show();
 702                                 },
 703                             },
 704                             {
 705                                 text: gettext('CloudInit Drive'),
 706                                 itemId: 'addci',
 707                                 iconCls: 'fa fa-fw fa-cloud black',
 708                                 disabled: !caps.nodes['Sys.Console'],
 709                                 handler: function() {
 710                                     var win = Ext.create('PVE.qemu.CIDriveEdit', {
 711                                         url: '/api2/extjs/' + baseurl,
 712                                         pveSelNode: me.pveSelNode,
 713                                     });
 714                                     win.on('destroy', me.reload, me);
 715                                     win.show();
 716                                 },
 717                             },
 718                             {
 719                                 text: gettext('Audio Device'),
 720                                 itemId: 'addaudio',
 721                                 iconCls: 'fa fa-fw fa-volume-up black',
 722                                 disabled: !caps.vms['VM.Config.HWType'],
 723                                 handler: function() {
 724                                     var win = Ext.create('PVE.qemu.AudioEdit', {
 725                                         url: '/api2/extjs/' + baseurl,
 726                                         isCreate: true,
 727                                         isAdd: true,
 728                                     });
 729                                     win.on('destroy', me.reload, me);
 730                                     win.show();
 731                                 },
 732                             },
 733                             {
 734                                 text: gettext("VirtIO RNG"),
 735                                 itemId: 'addrng',
 736                                 iconCls: 'pve-itype-icon-die',
 737                                 disabled: !caps.nodes['Sys.Console'],
 738                                 handler: function() {
 739                                     var win = Ext.create('PVE.qemu.RNGEdit', {
 740                                         url: '/api2/extjs/' + baseurl,
 741                                         isCreate: true,
 742                                         isAdd: true,
 743                                     });
 744                                     win.on('destroy', me.reload, me);
 745                                     win.show();
 746                                 },
 747                             },
 748                         ],
 749                     }),
 750                 },
 751                 remove_btn,
 752                 edit_btn,
 753                 resize_btn,
 754                 move_btn,
 755                 revert_btn,
 756             ],
 757             rows: rows,
 758             sorterFn: sorterFn,
 759             listeners: {
 760                 itemdblclick: run_editor,
 761                 selectionchange: set_button_status,
 762             },
 763         });
 764
 765         me.callParent();
 766
 767         me.on('activate', me.rstore.startUpdate, me.rstore);
 768         me.on('destroy', me.rstore.stopUpdate, me.rstore);
 769
 770         me.mon(me.getStore(), 'datachanged', set_button_status, me);
 771     },
 772 });