www/manager/qemu/Options.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.qemu.Options', {
   3     extend: 'PVE.grid.ObjectGrid',
   4     alias: ['widget.PVE.qemu.Options'],
   5
   6     initComponent : function() {
   7         var me = this;
   8         var i;
   9
  10         var nodename = me.pveSelNode.data.node;
  11         if (!nodename) {
  12             throw "no node name specified";
  13         }
  14
  15         var vmid = me.pveSelNode.data.vmid;
  16         if (!vmid) {
  17             throw "no VM ID specified";
  18         }
  19
  20         var rows = {
  21             name: {
  22                 required: true,
  23                 defaultValue: me.pveSelNode.data.name,
  24                 header: 'Name',
  25                 editor: {
  26                     xtype: 'pveWindowEdit',
  27                     title: 'VM name',
  28                     items: {
  29                         xtype: 'textfield',
  30                         name: 'name',
  31                         value: '',
  32                         fieldLabel: 'VM name',
  33                         allowBlank: true
  34                     }
  35                 }
  36             },
  37             onboot: {
  38                 header: 'Start at boot',
  39                 defaultValue: '',
  40                 renderer: PVE.Utils.format_boolean_with_default,
  41                 editor: {
  42                     xtype: 'pveWindowEdit',
  43                     title: 'Start at boot',
  44                     items: {
  45                         xtype: 'booleanfield',
  46                         name: 'onboot',
  47                         value: '',
  48                         fieldLabel: 'Start at boot'
  49                     }
  50                 }
  51             },
  52             ostype: {
  53                 header: 'OS Type',
  54                 editor: 'PVE.qemu.OSTypeEdit',
  55                 renderer: PVE.Utils.render_kvm_ostype,
  56                 defaultValue: 'other'
  57             },
  58             bootdisk: {
  59                 visible: false
  60             },
  61             boot: {
  62                 header: 'Boot order',
  63                 defaultValue: 'cad',
  64                 editor: 'PVE.qemu.BootOrderEdit',
  65                 renderer: function(order) {
  66                     var i;
  67                     var text = '';
  68                     var bootdisk = me.getObjectValue('bootdisk');
  69                     order = order || 'cad';
  70                     for (i = 0; i < order.length; i++) {
  71                         var sel = order.substring(i, i + 1);
  72                         if (text) {
  73                             text += ', ';
  74                         }
  75                         if (sel === 'c') {
  76                             if (bootdisk) {
  77                                 text += "Disk '" + bootdisk + "'";
  78                             } else {
  79                                 text += "Disk";
  80                             }
  81                         } else if (sel === 'n') {
  82                             text += 'Network';
  83                         } else if (sel === 'a') {
  84                             text += 'Floppy';
  85                         } else if (sel === 'd') {
  86                             text += 'CD-ROM';
  87                         } else {
  88                             text += sel;
  89                         }
  90                     }
  91                     return text;
  92                 }
  93             },
  94             acpi: {
  95                 header: 'ACPI support',
  96                 defaultValue: true,
  97                 renderer: PVE.Utils.format_boolean,
  98                 editor: {
  99                     xtype: 'pveWindowEdit',
 100                     title: 'ACPI support',
 101                     items: {
 102                         xtype: 'pvecheckbox',
 103                         name: 'acpi',
 104                         checked: true,
 105                         uncheckedValue: 0,
 106                         defaultValue: 1,
 107                         deleteDefaultValue: true,
 108                         fieldLabel: 'Enable'
 109                     }
 110                 }
 111             },
 112             kvm: {
 113                 header: 'KVM hardware virtualization',
 114                 defaultValue: true,
 115                 renderer: PVE.Utils.format_boolean,
 116                 editor: {
 117                     xtype: 'pveWindowEdit',
 118                     title: 'KVM hardware virtualization',
 119                     items: {
 120                         xtype: 'pvecheckbox',
 121                         name: 'kvm',
 122                         checked: true,
 123                         uncheckedValue: 0,
 124                         defaultValue: 1,
 125                         deleteDefaultValue: true,
 126                         fieldLabel: 'Enable'
 127                     }
 128                 }
 129             },
 130             freeze: {
 131                 header: 'Freeze CPU at startup',
 132                 defaultValue: false,
 133                 renderer: PVE.Utils.format_boolean,
 134                 editor: {
 135                     xtype: 'pveWindowEdit',
 136                     title: 'Freeze CPU at startup',
 137                     items: {
 138                         xtype: 'pvecheckbox',
 139                         name: 'freeze',
 140                         uncheckedValue: 0,
 141                         defaultValue: 0,
 142                         deleteDefaultValue: true,
 143                         labelWidth: 140,
 144                         fieldLabel: 'Freeze CPU at startup'
 145                     }
 146                 }
 147             },
 148             localtime: {
 149                 header: 'Use local time for RTC',
 150                 defaultValue: false,
 151                 renderer: PVE.Utils.format_boolean,
 152                 editor: {
 153                     xtype: 'pveWindowEdit',
 154                     title: 'Use local time for RTC',
 155                     items: {
 156                         xtype: 'pvecheckbox',
 157                         name: 'localtime',
 158                         uncheckedValue: 0,
 159                         defaultValue: 0,
 160                         deleteDefaultValue: true,
 161                         labelWidth: 140,
 162                         fieldLabel: 'Use local time for RTC'
 163                     }
 164                 }
 165
 166             },
 167             startdate: {
 168                 header: 'RTC start date',
 169                 defaultValue: 'now',
 170                 editor: {
 171                     xtype: 'pveWindowEdit',
 172                     title: 'RTC start date',
 173                     items: {
 174                         xtype: 'pvetextfield',
 175                         name: 'startdate',
 176                         deleteEmpty: true,
 177                         value: 'now',
 178                         fieldLabel: 'RTC start date',
 179                         vtype: 'QemuStartDate',
 180                         allowBlank: true
 181                     }
 182                 }
 183             }
 184         };
 185
 186         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 187
 188         var reload = function() {
 189             me.rstore.load();
 190         };
 191
 192         var run_editor = function() {
 193             var sm = me.getSelectionModel();
 194             var rec = sm.getSelection()[0];
 195             if (!rec) {
 196                 return;
 197             }
 198
 199             var rowdef = rows[rec.data.key];
 200             if (!rowdef.editor) {
 201                 return;
 202             }
 203
 204             var win;
 205             if (Ext.isString(rowdef.editor)) {
 206                 win = Ext.create(rowdef.editor, {
 207                     pveSelNode: me.pveSelNode,
 208                     confid: rec.data.key,
 209                     url: '/api2/extjs/' + baseurl
 210                 });
 211             } else {
 212                 var config = Ext.apply({
 213                     pveSelNode: me.pveSelNode,
 214                     confid: rec.data.key,
 215                     url: '/api2/extjs/' + baseurl
 216                 }, rowdef.editor);
 217                 win = Ext.createWidget(rowdef.editor.xtype, config);
 218                 win.load();
 219             }
 220
 221             win.show();
 222             win.on('destroy', reload);
 223         };
 224
 225         var edit_btn = new Ext.Button({
 226             text: 'Edit',
 227             disabled: true,
 228             handler: run_editor
 229         });
 230
 231         var set_button_status = function() {
 232             var sm = me.getSelectionModel();
 233             var rec = sm.getSelection()[0];
 234
 235             if (!rec) {
 236                 edit_btn.disable();
 237                 return;
 238             }
 239             var rowdef = rows[rec.data.key];
 240             edit_btn.setDisabled(!rowdef.editor);
 241         };
 242
 243         Ext.applyIf(me, {
 244             url: "/api2/json/nodes/" + nodename + "/qemu/" + vmid + "/config",
 245             cwidth1: 150,
 246             tbar: [ edit_btn ],
 247             rows: rows,
 248             listeners: {
 249                 itemdblclick: run_editor,
 250                 selectionchange: set_button_status
 251             }
 252         });
 253
 254         me.callParent();
 255
 256         me.on('show', reload);
 257     }
 258 });
 259