Sets or gets whether the jqxDataTable automatically alternates row colors.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :altRows="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the altRows property.

let altRows = this.$refs.myDataTable.altRows;

Sets or gets whether the jqxDataTable automatically calculates the rows height and wraps the cell text.

<template>
  <JqxDataTable ref="myDataTable"
    :width="450" :source="source" :columns="columns" :autoRowHeight="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the autoRowHeight property.

let autoRowHeight = this.$refs.myDataTable.autoRowHeight;

Sets or gets the height of the aggregates bar. Aggregates bar is displayed after setting showAggregates to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :aggregatesHeight="40" :showAggregates="true"
  />
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName', aggregates: ['count'] },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the aggregatesHeight property.

let aggregatesHeight = this.$refs.myDataTable.aggregatesHeight;

Sets or gets whether the loading html element with animated gif is automatically displayed by the widget during the data binding process.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :autoShowLoadElement="false"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the autoShowLoadElement property.

let autoShowLoadElement = this.$refs.myDataTable.autoShowLoadElement;

Sets or gets the height of the columns header.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :columnsHeight="20"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the columnsHeight property.

let columnsHeight = this.$refs.myDataTable.columnsHeight;

Sets the jqxDataTable's columns.

• text - string property which sets the column header's text.
• dataField - string property which sets the column's bound field. It should be unique and should point to a data field defined in the jqxDataAdapter's dataFields array.
• displayField - string property which sets the column's display field. It should be unique and should point to a data field defined in the jqxDataAdapter's dataFields array.
• sortable - boolean property which determines whether the column is sortable.
• filterable - boolean property which determines whether the column is filterable.
• hidden - boolean property which determines whether the column is visible or hidden.
• columnGroup - string property which determines the name of the column's parent group. It should point to a valid name defined in the columnGroups.
• autoCellHeight - boolean property which determines whether the cell's data wrapping is enabled. This property is set to true by default. When autoRowHeight is enabled and autoCellHeight is set to false, the cell's data will not be wrapped.
• renderer - callback function for custom rendering of the column's header.

  <template>
    <JqxDataTable ref="myDataTable"
      :width="850" :source="source" :columns="columns"
    />
  </template>
  
   
  <script>
    import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
   
    export default {
      components: {
        JqxDataTable
      },
      data: function () {
        return  {
          source: new jqx.dataAdapter(this.source),
          columns: [
            { text: 'Contact Name', datafield: 'ContactName' },
            { text: 'Contact Title', datafield: 'Title' },
            { text: 'City', datafield: 'City' },
            { text: 'Country', datafield: 'Country' }
          ]
        }
      },
      beforeCreate: function () {
        this.source = {
          localdata: [
            [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
            [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
            [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
          ],
          datafields: [
            { name: 'ContactName', type: 'string', map: '0' },
            { name: 'Title', type: 'string', map: '1' },
            { name: 'City', type: 'string', map: '2' },
            { name: 'Country', type: 'string', map: '3' }
          ],
          datatype: 'array'
        };
      }
    }
  </script>
  

Sets the jqxDataTable's column groups.

• parentGroup - string property which determines the parent group's name.
• name - string property which determines the group's name.
• align - string property which determines the column header's alignment. Possible values: 'left', 'center' or 'right'.

<template>
  <JqxDataTable ref="myDataTable"
  :width="850" :source="source" :columns="columns" :columnGroups="columnGroups"/>
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return {
        columnGroups: [
          { text: 'Name', align: 'center', name: 'ContactName' },
          { text: 'City', align: 'center', name: 'City' },
          { text: 'Country', align: 'center', name: 'Country' }
        ],
        columns: [
          { text: 'Contact Name', datafield: 'ContactName', columngroup: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City', columngroup: 'City' },
          { text: 'Country', datafield: 'Country', columngroup: 'Country' }
        ],
        source: new jqx.dataAdapter(this.source)
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          ['Maria Anders', 'Sales Representative', 'Berlin', 'Germany'],
          ['Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico'],
          ['Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico']
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the columnGroups property.

let columnGroups = this.$refs.myDataTable.columnGroups;

Sets or gets the jqxDataTable's columnsResize.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :columnsResize="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the columnsResize property.

let columnsResize = this.$refs.myDataTable.columnsResize;

Sets or gets the jqxDataTable's columnsReorder.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :columnsReorder="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the columnsReorder property.

let columnsReorder = this.$refs.myDataTable.columnsReorder;

Sets or gets whether the jqxDataTable is disabled.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :disabled="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the disabled property.

let disabled = this.$refs.myDataTable.disabled;

Sets or gets whether the jqxDataTable editing is enabled.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :editable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the editable property.

let editable = this.$refs.myDataTable.editable;

Sets or gets the jqxDataTable's edit settings.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :editSettings="editSettings"
    :editable="editable"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        editSettings:  {
          saveOnPageChange: true,
          saveOnBlur: true,
          saveOnSelectionChange: false,
          cancelOnEsc: true,
          saveOnEnter: true,
          editSingleCell: false,
          editOnDoubleClick: true,
          editOnF2: true
        },
        editable:  true,
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Determines the Data Export settings used by jqxDataTable when exportData is called. See also the exportData method.

• columnsHeader - determines whether to export the column's header.
• hiddenColumns - determines whether to export the hidden columns.
• serverURL - determines the URL of the save-file.php.
• characterSet - determines the char set.
• recordsInView - determines whether to export all records or to take also the filtering and sorting into account.
• fileName - determines the file's name. Set this to null if you want to export the data to a local variable.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :exportSettings="exportSettings" :ready="ready"
  />
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        exportSettings: {
          columnsHeader: true,
          hiddenColumns: false,
          serverURL: null,
          characterSet: null,
          recordsInView: true,
          fileName: 'jqxDataTable'
        },
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ],
        ready: () => {
          this.$refs.myDataTable.exportData('html');
        }
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the exportSettings property.

let exportSettings = this.$refs.myDataTable.exportSettings;

Sets or gets whether row highlighting is enabled.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :enableHover="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the enableHover property.

let enableHover = this.$refs.myDataTable.enableHover;

Enables or disables the default text selection of the web browser.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :enableBrowserSelection="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the enableBrowserSelection property.

let enableBrowserSelection = this.$refs.myDataTable.enableBrowserSelection;

Enables/Disables the filtering feature.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :filterable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the filterable property.

let filterable = this.$refs.myDataTable.filterable;

Sets or gets the Filter Element's height.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :filterHeight="35" :filterable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the filterHeight property.

let filterHeight = this.$refs.myDataTable.filterHeight;

Determines the Filter's mode. Possible values: "default", "simple" and "advanced"

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :filterable="true" :filterMode="'advanced'"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the filterMode property.

let filterMode = this.$refs.myDataTable.filterMode;

Sets or gets the jqxDataTable's data groups. Set this property if you want to display the data grouped by a set of column(s).

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :groups=" ['Country'] "
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the groups property.

let groups = this.$refs.myDataTable.groups;

Callback function which allows you to customize the rendering of the group headers.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :groupsRenderer="groupsRenderer"
    :groups=" ['ContactName'] "
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      groupsRenderer: function (value, rowdata, level) {
        return 'First Name: ' + value;
      }
    }
  }
</script>

Sets or gets the jqxDataTable's height.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :height="350"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the height property.

let height = this.$refs.myDataTable.height;

Callback function which is used for initialization of the expanded row's details. The function is called just once when the row is expanded for first time.

• id/key - expanded row's id/key.
• dataRow - the expanded row as a set of Key/Value pairs.
• element - the row's details HTML element as a jQuery selector.
• rowInfo - object which enables you to modify the height of the row details by setting the rowInfo's detailsHeight

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :initRowDetails="initRowDetails"
    :rowDetails="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      initRowDetails: function (id, row, element, rowinfo) {
        const container = document.createElement('div');
        container.innerHTML = 'Some Details...'
        element[0].appendChild(container);
      }
    }
  }
</script>

Determines whether the incremental search is enabled. The feature allows you to quickly find and select data records by typing when the widget is on focus.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :incrementalSearch="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the incrementalSearch property.

let incrementalSearch = this.$refs.myDataTable.incrementalSearch;

Applies a localization to the jqxDataTable's strings.

{           
        // separator of parts of a date (e.g. '/' in 11/05/1955)
	'/': "/",
	// separator of parts of a time (e.g. ':' in 05:44 PM)
	':': ":",
	// the first day of the week (0 = Sunday, 1 = Monday, etc)
	firstDay: 0,
	days: {
		// full day names
		names: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
		// abbreviated day names
		namesAbbr: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
		// shortest day names
		namesShort: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
	},
	months: {
		// full month names (13 months for lunar calendards -- 13th month should be "" if not lunar)
		names: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", ""],
		// abbreviated month names
		namesAbbr: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ""]
	},
	// AM and PM designators in one of these forms:
	// The usual view, and the upper and lower case versions
	//      [standard,lowercase,uppercase]
	// The culture does not use AM or PM (likely all standard date formats use 24 hour time)
	//      null
	AM: ["AM", "am", "AM"],
	PM: ["PM", "pm", "PM"],
	eras: [
	// eras in reverse chronological order.
	// name: the name of the era in this culture (e.g. A.D., C.E.)
	// start: when the era starts in ticks (gregorian, gmt), null if it is the earliest supported era.
	// offset: offset in years from gregorian calendar
	{ "name": "A.D.", "start": null, "offset": 0 }
	],
	twoDigitYearMax: 2029,
	patterns: {
		// short date pattern
		d: "M/d/yyyy",
		// long date pattern
		D: "dddd, MMMM dd, yyyy",
		// short time pattern
		t: "h:mm tt",
		// long time pattern
		T: "h:mm:ss tt",
		// long date, short time pattern
		f: "dddd, MMMM dd, yyyy h:mm tt",
		// long date, long time pattern
		F: "dddd, MMMM dd, yyyy h:mm:ss tt",
		// month/day pattern
		M: "MMMM dd",
		// month/year pattern
		Y: "yyyy MMMM",
		// S is a sortable format that does not vary by culture
		S: "yyyy\u0027-\u0027MM\u0027-\u0027dd\u0027T\u0027HH\u0027:\u0027mm\u0027:\u0027ss",
		// formatting of dates in MySQL DataBases
		ISO: "yyyy-MM-dd hh:mm:ss",
		ISO2: "yyyy-MM-dd HH:mm:ss",
		d1: "dd.MM.yyyy",
		d2: "dd-MM-yyyy",
		d3: "dd-MMMM-yyyy",
		d4: "dd-MM-yy",
		d5: "H:mm",
		d6: "HH:mm",
		d7: "HH:mm tt",
		d8: "dd/MMMM/yyyy",
		d9: "MMMM-dd",
		d10: "MM-dd",
		d11: "MM-dd-yyyy"
	},
	percentSymbol: "%",
	currencySymbol: "$",
	currencySymbolposition: "before",
	decimalSeparator: '.',
	thousandsSeparator: ',',
	pagerGoToPageString: "Go to page:",
	pagerShowRowsString: "Show rows:",
	pagerRangeString: " of ",
	pagerPreviousButtonString: "previous",
	pagerNextButtonString: "next",
	pagerFirstButtonsSring: "first",
	pagerLastButtonString:"last",
	filterApplyString: "Apply",
	filterCancelString: "Cancel",
	filterClearString: "Clear Filter",
	filterString: "advanced",
	filterSearchString: "Search:",
	filterStringComparisonOperators: ['empty', 'not empty', 'contains', 'contains(match case)',
	   'does not contain', 'does not contain(match case)', 'starts with', 'starts with(match case)',
	   'ends with', 'ends with(match case)', 'equal', 'equal(match case)', 'null', 'not null'],
	filterNumericComparisonOperators: ['equal', 'not equal', 'less than', 'less than or equal', 'greater than', 'greater than or equal', 'null', 'not null'],
	filterDateComparisonOperators: ['equal', 'not equal', 'less than', 'less than or equal', 'greater than', 'greater than or equal', 'null', 'not null'],
	filterbooleanComparisoOoperators: ['equal', 'not equal'],
	validationString: "Entered value is not valid",
	emptyDataString: "No data to display",
	filterSelectString: "Select Filter",
	loadText: "Loading...",
	clearString: "Clear",
	todayString: "Today",
	loadingErrorMessage: "The data is still loading and you cannot set a property or call a method. You can do that once the data binding is completed. jqxDataTable raises the 'bindingComplete' event when the binding is completed."           
};

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :localization="localization"
    :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        localization: {
          pagerGoToPageString: 'Gehe zu:',
          pagerShowRowsString: 'Zeige Zeile:',
          pagerRangeString: ' von ',
          pagerNextButtonString: 'voriger',
          pagerFirstButtonString: 'first',
          pagerLastButtonString: 'last',
          pagerPreviousButtonString: 'nächster'
        },
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the localization property.

let localization = this.$refs.myDataTable.localization;

Sets or gets the height of the jqxDataTable's Pager(s). Pager(s) is(are) displayed after setting pageable to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pagerHeight="35" :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pagerHeight property.

let pagerHeight = this.$refs.myDataTable.pagerHeight;

Sets or gets the rows count per page when paging is enabled.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pageSize="15" :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pageSize property.

let pageSize = this.$refs.myDataTable.pageSize;

Sets or gets the jqxDataTable's page size options when paging is enabled and the pagerMode property is set to "advanced".

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pageSizeOptions=" [15, 25, 35] "
    :pageable="true" :pagerMode="'advanced'"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pageSizeOptions property.

let pageSizeOptions = this.$refs.myDataTable.pageSizeOptions;

Determines whether the jqxDataTable is in paging mode.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pageable property.

let pageable = this.$refs.myDataTable.pageable;

Sets or gets the Pager's position. Possible values: 'top', 'bottom' and 'both'

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pagerPosition="'top'"
    :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pagerPosition property.

let pagerPosition = this.$refs.myDataTable.pagerPosition;

Sets or gets the Pager's mode. Possible values: "default" and "advanced"

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pagerMode="'advanced'"
    :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pagerMode property.

let pagerMode = this.$refs.myDataTable.pagerMode;

Sets or gets the count of the buttons displayed on the Pager when pagerMode is set to "default".

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pagerButtonsCount="10"
    :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the pagerButtonsCount property.

let pagerButtonsCount = this.$refs.myDataTable.pagerButtonsCount;

Enables custom rendering of the Pager.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :pagerRenderer="pagerRenderer"
    :pageable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      pagerRenderer: function () {
        // Do something here and return a HTML Element as a result.
      }
    }
  }
</script>

Callback function which is called when the jqxDataTable is rendered and data binding is completed..

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :ready="ready"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      ready: function () {
        alert('Ready!')
      }
    }
  }
</script>

Sets or gets whether the jqxDataTable rows have details and can be expanded/collapsed. See the initRowDetails for initialization of the row details.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :initRowDetails="initRowDetails"
    :rowDetails="true"
  />
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      initRowDetails: function (id, row, element, rowinfo) {
        const container = document.createElement('div');
        container.innerHTML = 'Some Details...'
        element[0].appendChild(container);
      }
    }
  }
</script>

Get the rowDetails property.

let rowDetails = this.$refs.myDataTable.rowDetails;

Enables custom rendering of the Toolbar.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :renderToolbar="renderToolbar"
    :showToolbar="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      renderToolbar: function (toolbar) {
        const container = document.createElement('div');
        container.innerHTML = 'Some custom HTML here...';
        toolbar.append(container);
      }
    }
  }
</script>

Get the renderToolbar property.

let renderToolbar = this.$refs.myDataTable.renderToolbar;

Enables custom rendering of the Statusbar.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :renderStatusBar="renderStatusBar"
    :showStatusbar="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      renderStatusBar: function (toolbar) {
        const container = document.createElement('div');
        container.innerHTML = 'Some custom HTML here...';
        toolbar.append(container);
      }
    }
  }
</script>

Get the renderStatusBar property.

let renderStatusBar = this.$refs.myDataTable.renderStatusBar;

Callback function which is called before the rendering of the jqxDataTable's rows.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :rendering="rendering"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      rendering: function () {
        alert('Rendering!');
      }
    }
  }
</script>

Callback function which is called after the rendering of the jqxDataTable's row.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :rendered="rendered"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      rendered: function () {
        alert('Rendered!');
      }
    }
  }
</script>

Sets or gets a value indicating whether widget's elements are aligned to support locales using right-to-left fonts.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :rtl="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the rtl property.

let rtl = this.$refs.myDataTable.rtl;

Determines the jqxDataTable's data source. The source property is expected to point to an instance of jqxDataAdapter. For more information about jqxDataAdapter, visit: jquery-data-adapter.htm. To clear the data source, set the source property to null.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Enables/Disables the sorting feature.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :sortable="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the sortable property.

let sortable = this.$refs.myDataTable.sortable;

Determines whether the jqxDataTable's Aggregates bar is visible.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :showAggregates="true"
  />
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName', aggregates: ['count'] },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the showAggregates property.

let showAggregates = this.$refs.myDataTable.showAggregates;

Determines whether the jqxDataTable's Toolbar is visible.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :showToolbar="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the showToolbar property.

let showToolbar = this.$refs.myDataTable.showToolbar;

Determines whether the jqxDataTable's Statusbar is visible.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :showStatusbar="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the showStatusbar property.

let showStatusbar = this.$refs.myDataTable.showStatusbar;

Sets or gets the height of the Statusbar. Statusbar is displayed after setting showStatusbar to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :statusBarHeight="40"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the statusBarHeight property.

let statusBarHeight = this.$refs.myDataTable.statusBarHeight;

Sets or gets the size of the scrollbars.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :scrollBarSize="20" :height="100"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the scrollBarSize property.

let scrollBarSize = this.$refs.myDataTable.scrollBarSize;

Sets or gets the selection mode. Possible values: "multipleRows", "singleRow" and "custom". In the "custom" mode, rows could be selected/unselected only through the API.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :selectionMode="'singleRow'"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the selectionMode property.

let selectionMode = this.$refs.myDataTable.selectionMode;

Sets or gets whether the Paging, Sorting and Filtering are handled by a Server and jqxDataTable sends Ajax requests to a Server and displays the returned data. When the current page, page size, sort order or sort column is changed, jqxDataTable will automatically perform a new data binding with the updated parameters. For server synchronization after adding, removing, updating rows, see the source property documentation.

• sortdatafield - the sort column's datafield.
• sortorder - the sort order - 'asc', 'desc' or ''.
• pagenum - the current page's number when the paging feature is enabled.
• pagesize - the page's size which represents the number of rows displayed in the view.
• filterscount - the number of filters applied to the jqxDataTable.
• filtervalue - the filter's value. The filtervalue name for the first filter is "filtervalue0", for the second filter is "filtervalue1" and so on.
• filtercondition - the filter's condition. The condition can be any of these: "CONTAINS", "DOES_NOT_CONTAIN", "EQUAL", "EQUAL_CASE_SENSITIVE", NOT_EQUAL","GREATER_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN", "LESS_THAN_OR_EQUAL", "STARTS_WITH", "STARTS_WITH_CASE_SENSITIVE", "ENDS_WITH", "ENDS_WITH_CASE_SENSITIVE", "NULL", "NOT_NULL", "EMPTY", "NOT_EMPTY".
• filterdatafield - the filter column's datafield.
• filteroperator - the filter's operator - 0 for "AND" and 1 for "OR".

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :serverProcessing="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the serverProcessing property.

let serverProcessing = this.$refs.myDataTable.serverProcessing;

Sets or gets the jqxDataTable's columns visibility.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :showHeader="false"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the showHeader property.

let showHeader = this.$refs.myDataTable.showHeader;

Sets the widget's theme.

• Include the theme's CSS file after jqx.base.css.
  The following code example adds the 'material' theme.

  
  <link rel="stylesheet" href="../../jqwidgets/styles/jqx.base.css" type="text/css" />
  <link rel="stylesheet" href="../../jqwidgets/styles/jqx.material.css" type="text/css" />
  
  

• Set the widget's theme property to 'material' when you initialize it.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :theme="'material'"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Sets or gets the height of the Toolbar. Toolbar is displayed after setting showToolbar to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :toolbarHeight="40" :showToolbar="true"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the toolbarHeight property.

let toolbarHeight = this.$refs.myDataTable.toolbarHeight;

Sets or gets the jqxDataTable's width.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    }
  }
</script>

Get the width property.

let width = this.$refs.myDataTable.width;

This event is triggered when the jqxDataTable binding is completed. *Bind to that event before the jqxDataTable's initialization. Otherwise, if you are populating the widget from a local data source and bind to bindingComplete after the initialization, the event could be already raised when you attach an event handler to it.

Code examples

Bind to the bindingComplete event of jqxDataTable.

<template>
  <div>
    <JqxDataTable ref="myDataTable"
      @bindingComplete="onBindingComplete($event)"
      :width="850" :source="source" :columns="columns"
    />
    <br>
    <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ]
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.updateBoundData();
    },
    onBindingComplete: function (event) {
      alert('do something...');
    }
  }
};
</script>

This is triggered when a cell edit begins. Note: To turn on cell editing, you should set the editSettings property and make sure that its editSingleCell sub property is set to true.

Code examples

Bind to the cellBeginEdit event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @cellBeginEdit="onCellBeginEdit($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.editable = true;
      this.$refs.myDataTable.editSettings = {
                saveOnPageChange: true,
                saveOnBlur: true,
                saveOnSelectionChange: true,
                cancelOnEsc: true,
                saveOnEnter: true,
                editOnDoubleClick: true,
                editOnF2: true,
                editSingleCell: true
            };

    },
    methods: {
      onCellBeginEdit: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a cell edit ends. Note: To turn on cell editing, you should set the editSettings property and make sure that its editSingleCell sub property is set to true.

Code examples

Bind to the cellEndEdit event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @cellEndEdit="onCellEndEdit($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.editable = true;
      this.$refs.myDataTable.editSettings = {
                saveOnPageChange: true,
                saveOnBlur: true,
                saveOnSelectionChange: true,
                cancelOnEsc: true,
                saveOnEnter: true,
                editOnDoubleClick: true,
                editOnF2: true,
                editSingleCell: true
            };

    },
    methods: {
      onCellEndEdit: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This event is triggered when a cell value is changed.

Code examples

Bind to the cellValueChanged event of jqxDataTable.

<template>
  <div>
    <JqxDataTable ref="myDataTable"
      @cellValueChanged="onCellValueChanged($event)"
      :width="850" :source="source" :columns="columns" :editable="true"
    />
    <br>
    <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ]
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.setCellValue(1, 'ContactName', 'New Value');
    },
    onCellValueChanged: function (event) {
      alert('do something...');
    }
  }
};
</script>

This event is triggered when a column is resized.

Code examples

Bind to the columnResized event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @columnResized="onColumnResized($event)"
    :width="850" :source="source" :columns="columns" :columnsResize="true"
  />
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      onColumnResized: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This event is triggered when the column's order is changed.

Code examples

Bind to the columnReordered event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @columnReordered="onColumnReordered($event)"
    :width="850" :source="source" :columns="columns" :columnsReorder="true"
  />
</template>
 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      onColumnReordered: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This event is triggered when the jqxDataTable sort order or sort column is changed.

Code examples

Bind to the sort event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @sort="onSort($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.sortable = true;

    },
    methods: {
      onSort: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This event is triggered when the jqxDataTable's rows filter is changed.

Code examples

Bind to the filter event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @filter="onFilter($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.filterable = true;

    },
    methods: {
      onFilter: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when the jqxDataTable's current page is changed.

Code examples

Bind to the pageChanged event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @pageChanged="onPageChanged($event)"
    :width="850" :source="source" :columns="columns" :pageable="true" :pageSize="2"
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.source),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ]
    };
  },
  beforeCreate: function() {
    this.source = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onPageChanged: function(event) {
      alert("do something...");
    }
  }
};
</script>

This is triggered when the jqxDataTable's page size is changed.

Code examples

Bind to the pageSizeChanged event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @pageSizeChanged="onPageSizeChanged($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.pageable = true;
      this.$refs.myDataTable.pagerMode = 'advance';
      this.$refs.myDataTable.pageSizeOptions = [2, 4, 8];

    },
    methods: {
      onPageSizeChanged: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row is clicked.

Code examples

Bind to the rowClick event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @rowClick="onRowClick($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      onRowClick: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row is double-clicked.

Code examples

Bind to the rowDoubleClick event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @rowDoubleClick="onRowDoubleClick($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      onRowDoubleClick: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row is selected.

Code examples

Bind to the rowSelect event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @rowSelect="onRowSelect($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      onRowSelect: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row is unselected.

Code examples

Bind to the rowUnselect event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @rowUnselect="onRowUnselect($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    methods: {
      onRowUnselect: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row edit begins.

Code examples

Bind to the rowBeginEdit event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @rowBeginEdit="onRowBeginEdit($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.editable = true;

    },
    methods: {
      onRowBeginEdit: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row edit ends.

Code examples

Bind to the rowEndEdit event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable" @rowEndEdit="onRowEndEdit($event)"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.editable = true;

    },
    methods: {
      onRowEndEdit: function (event) {
        alert('do something...');
      }
    }
  }
</script>

This is triggered when a row is expanded.

Code examples

Bind to the rowExpand event of jqxDataTable.

<template>
  <div>
    <JqxDataTable ref="myDataTable"
      @rowExpand="onRowExpand($event)"
      :width="850" :source="source" :columns="columns"
      :rowDetails="true" :initRowDetails="initRowDetails" 
    />
    <br>
    <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";

export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      initRowDetails: (id, row, element, rowinfo) => {
        rowinfo.detailsHeight = 48;
        element.html("<strong>Details</strong><br/>Row Index: " + id);
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onRowExpand: function(event) {
      alert("do something...");
    },
    onClick: function(event) {
      this.$refs.myDataTable.showDetails(1);
    }
  }
};
</script>

This is triggered when a row is collapsed.

Code examples

Bind to the rowCollapse event of jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable"
    @rowCollapse="onRowCollapse($event)"
    :width="850" :source="source" :columns="columns" :ready="ready"
    :rowDetails="true" :initRowDetails="initRowDetails"    
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.source),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      initRowDetails: (id, row, element, rowinfo) => {
        rowinfo.detailsHeight = 48;
        element.text("Row Details: " + id);
      },
      ready: () => {
        this.$refs.myDataTable.showDetails(1);
      }
    };
  },
  beforeCreate: function() {
    this.source = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
    methods: {
      onRowCollapse: function (event) {
        alert('do something...');
      }
    }
};
</script>

Adds a new row. For synchronization with a server, please look also the jqxDataAdapter plug-in's help documentation.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.addRow(null,{ 'ContactName': 'Added Name', 'Title': 'Added Title', 'City': 'Added City', 'Country': 'Added Country' },'first');
    }
  }
</script>

Adds a new filter.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :filterable="true" :ready="ready"
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        let filtertype = "stringfilter";
        let filtergroup = new jqx.filter();
        let filter_or_operator = 1;
        // set filter's value.
        let filtervalue = "er";
        // set filter's condition.
        let filtercondition = "contains";
        // create new filter.
        let filter = filtergroup.createfilter(
          filtertype,
          filtervalue,
          filtercondition
        );
        // add the filter to the filter group.
        filtergroup.addfilter(filter_or_operator, filter);
        // add the filters.
        this.$refs.myDataTable.addFilter("ContactName", filtergroup);
        // apply the filters.
        this.$refs.myDataTable.applyFilters();
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  }
};
</script>

Applies the added/removed filters.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :filterable="true" :ready="ready"
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        let filtertype = "stringfilter";
        let filtergroup = new jqx.filter();
        let filter_or_operator = 1;
        // set filter's value.
        let filtervalue = "er";
        // set filter's condition.
        let filtercondition = "contains";
        // create new filter.
        let filter = filtergroup.createfilter(
          filtertype,
          filtervalue,
          filtercondition
        );
        // add the filter to the filter group.
        filtergroup.addfilter(filter_or_operator, filter);
        // add the filters.
        this.$refs.myDataTable.addFilter("ContactName", filtergroup);

        let filtergroup2 = new jqx.filter();
        filtervalue = "Ottawa";
        let filter2 = filtergroup.createfilter(filtertype, filtervalue, filtercondition);
        filtergroup2.addfilter(filter_or_operator, filter2);
        this.$refs.myDataTable.addFilter("City", filtergroup2);
        // apply the filters.
        this.$refs.myDataTable.applyFilters();
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  }
};
</script>

Begins an update and stops all refreshes.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.beginUpdate();
    }
  }
</script>

Begins a row edit operation when editable is set to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.beginRowEdit(0);
    }
  }
</script>

Begins a cell edit operation when editable is set to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.beginCellEdit(0,'ContactName');
    }
  }
</script>

Clears the selection.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.clearSelection();
    }
  }
</script>

Clears the filters.

<template>
  <div>
    <JqxDataTable ref="myDataTable"
      :width="850" :source="source" :columns="columns" :filterable="true" :ready="ready"
    />
    <br>
    <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";

export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        let filtertype = "stringfilter";
        let filtergroup = new jqx.filter();
        let filter_or_operator = 1;
        // set filter's value.
        let filtervalue = "er";
        // set filter's condition.
        let filtercondition = "contains";
        // create new filter.
        let filter = filtergroup.createfilter(
          filtertype,
          filtervalue,
          filtercondition
        );
        // add the filter to the filter group.
        filtergroup.addfilter(filter_or_operator, filter);
        // add the filters.
        this.$refs.myDataTable.addFilter("ContactName", filtergroup);
        // apply the filters.
        this.$refs.myDataTable.applyFilters();
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.clearFilters();
    }
  }
};
</script>

Clears the jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.clear();
    }
  }
</script>

Destroys jqxDataTable and removes it from the DOM.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.destroy();
    }
  }
</script>

Deletes a row. For synchronization with a server, please look also the jqxDataAdapter plug-in's help documentation.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.deleteRow(0);
    }
  }
</script>

Ends the update and resumes all refreshes.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.endUpdate();
    }
  }
</script>

Moves the vertical scrollbar to a row index.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :height="100"
    :source="source" :columns="columns"
    :ready="ready"
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        this.$refs.myDataTable.ensureRowVisible(2); 
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  }
};
</script>

Ends a row edit when editable is set to true.
Invoke the endRowEdit method:
".endRowEdit(0)"

Invoke the endRowEdit method and cancel changes:
".endRowEdit(0, true)"

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.endRowEdit(0);
    }
  }
</script>

Ends a cell edit operation when editable is set to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
    :editable="true" :ready="ready"
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable    
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        this.$refs.myDataTable.beginCellEdit(0, 'ContactName');

        setTimeout(() => {
          this.$refs.myDataTable.endCellEdit(0, 'ContactName');
        }, 1000);
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  }
};
</script>

Exports jqxDataTable's data to Excel, HTML, XML, JSON, CSV or TSV. See also the exportSettings property

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.exportData('xls');
    }
  }
</script>

Focus jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.focus();
    }
  }
</script>

Gets a property value of a column.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.getColumnProperty('ContactName','width');
    }
  }
</script>

Navigates to a page when pageable is set to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
    :pageable="true" :pageSize="2" :ready="ready"
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        this.$refs.myDataTable.goToPage(1);
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  }
};
</script>

Navigates to a previous page when pageable is set to true.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
    :pageable="true" :pageSize="2" :ready="ready"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        this.$refs.myDataTable.goToPage(1);
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.goToPrevPage();    
    }
  }
};
</script>

Navigates to a next page when pageable is set to true.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
    :pageable="true" :pageSize="2"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ]
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.goToNextPage();      
    }
  }
};
</script>

Returns an array of selected rows.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.getSelection();
    }
  }
</script>

Returns an array of all rows loaded in the widget.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.getRows();
    }
  }
</script>

Returns an array of all rows displayed in the view. This method takes into account the Sorting Order and returns the Filtered Set of Rows, if Filtering is applied. The method is different from getRows, because getRows returns a Rows array in their data binding order and that array is not affected by filtering and sorting.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.getView();
    }
  }
</script>

Returns a value of a cell.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.getCellValue(1,'ContactName');
    }
  }
</script>

Hides a column.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.hideColumn('ContactName');
    }
  }
</script>

Hides the details of a row.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :ready="ready"
    :rowDetails="true" :initRowDetails="initRowDetails" 
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      initRowDetails: (id, row, element, rowinfo) => {
        rowinfo.detailsHeight = 48;
        element.html("<strong>Details</strong><br/>Row Index: " + id);
      },
      ready: () => {
        this.$refs.myDataTable.showDetails(1);
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      const value = this.$refs.myDataTable.hideDetails(1);
    }
  }
};
</script>

Returns whether the binding is completed and if the result is true, this means that you can invoke methods and set properties. Otherwise, if the binding is not completed and you try to set a property or invoke a method, the widget will throw an exception.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.isBindingCompleted();
    }
  }
</script>

Locks a row i.e editing of the row would be disabled.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.lockRow(0);
    }
  }
</script>

Performs a layout and updates the HTML elements position and size.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.refresh();
    }
  }
</script>

Renders jqxDataTable.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.render();
    }
  }
</script>

Removes a filter.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :filterable="true" :ready="ready"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: false },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
          let filtertype = "stringfilter";
          let filtergroup = new jqx.filter();
          let filter_or_operator = 1;
          // set filter's value.
          let filtervalue = "er";
          // set filter's condition.
          let filtercondition = "contains";
          // create new filter.
          let filter = filtergroup.createfilter(
            filtertype,
            filtervalue,
            filtercondition
          );
          // add the filter to the filter group.
          filtergroup.addfilter(filter_or_operator, filter);
          // add the filters.
          this.$refs.myDataTable.addFilter("ContactName", filtergroup);
          // apply the filters.
          this.$refs.myDataTable.applyFilters();
      }
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"],
        ["Andrew Nodier", "Accounting Manager", "Ottawa", "Canada"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {      
      this.$refs.myDataTable.removeFilter("ContactName");
      this.$refs.myDataTable.applyFilters();
    }
  }
};
</script>

Scrolls to a position.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.scrollOffset(10,0);
    }
  }
</script>

Sets a property of a column. See the columns property for more information.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.setColumnProperty('ContactName','hidden',true);
    }
  }
</script>

Shows a column.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";
export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName", hidden: true },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.showColumn('ContactName');
    }
  }
};
</script>

Selects a row.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.selectRow(1);
    }
  }
</script>

Shows a row details.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :ready="ready"
    :rowDetails="true" :initRowDetails="initRowDetails"    
  />
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";

export default {
  components: {
    JqxDataTable
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.source),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      initRowDetails: (id, row, element, rowinfo) => {
        rowinfo.detailsHeight = 48;
        element.text("Row Details: " + id);
      },
      ready: () => {
        this.$refs.myDataTable.showDetails(1);
      }
    };
  },
  beforeCreate: function() {
    this.source = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  }
};
</script>

Sets a value of a cell.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.setCellValue(1,'ContactName','New Value');
    }
  }
</script>

Sorts a column, if sortable is set to true.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.sortable = true;

      this.$refs.myDataTable.sortBy('ContactName','asc');
    }
  }
</script>

Gets a boolean value which determines whether jqxDataTable is in update state i.e the beginUpdate method was called and the endUpdate method is not called yet.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      const value = this.$refs.myDataTable.updating();
    }
  }
</script>

Performs a data bind and updates jqxDataTable with the new data.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";

export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.dataSource),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
    };
  },
  beforeCreate: function() {
    this.dataSource = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.dataSource.localdata = [
        ["Nancy	Wilson", "Owner", "Rome", "Italy"],
        ["Cheryl Nodier", "Sales Representative", "Prague", "Czech Republic"],
        ["Guylene Bjorn", "Owner", "Paris", "France"],
        ["Regina Murphy", "Sales Representative", "Lisbon", "Portugal"]
      ];
      
      this.$refs.myDataTable.updateBoundData();
    }
  }
};
</script>

Unselects a row.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :ready="ready"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";

export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.source),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        this.$refs.myDataTable.selectRow(1);
      }
    };
  },
  beforeCreate: function() {
    this.source = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.unselectRow(1);
    }
  }
};
</script>

Updates the row's data. For synchronization with a server, please look also the jqxDataAdapter plug-in's help documentation.

<template>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns"
  />
</template>

 
<script>
  import JqxDataTable from 'jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue';
 
  export default {
    components: {
      JqxDataTable
    },
    data: function () {
      return  {
        source: new jqx.dataAdapter(this.source),
        columns: [
          { text: 'Contact Name', datafield: 'ContactName' },
          { text: 'Contact Title', datafield: 'Title' },
          { text: 'City', datafield: 'City' },
          { text: 'Country', datafield: 'Country' }
        ]
      }
    },
    beforeCreate: function () {
      this.source = {
        localdata: [
          [ 'Maria Anders', 'Sales Representative', 'Berlin', 'Germany' ],
          [ 'Ana Trujillo', 'Owner', 'Mxico D.F.', 'Mexico' ],
          [ 'Antonio Moreno', 'Owner', 'Mxico D.F.', 'Mexico' ]
        ],
        datafields: [
          { name: 'ContactName', type: 'string', map: '0' },
          { name: 'Title', type: 'string', map: '1' },
          { name: 'City', type: 'string', map: '2' },
          { name: 'Country', type: 'string', map: '3' }
        ],
        datatype: 'array'
      };
    },
    mounted: function () {
      this.$refs.myDataTable.updateRow(1,{});
    }
  }
</script>

Unlocks a row.

<template>
  <div>
  <JqxDataTable ref="myDataTable"
    :width="850" :source="source" :columns="columns" :ready="ready"
  />
  <br>
  <JqxButton @click="onClick($event)" :width="60" :height="20">Click</JqxButton>
  </div>
</template>
 
<script>
import JqxDataTable from "jqwidgets-scripts/jqwidgets-vue/vue_jqxdatatable.vue";
import JqxButton from "jqwidgets-scripts/jqwidgets-vue/vue_jqxbuttons.vue";

export default {
  components: {
    JqxDataTable,
    JqxButton
  },
  data: function() {
    return {
      source: new jqx.dataAdapter(this.source),
      columns: [
        { text: "Contact Name", datafield: "ContactName" },
        { text: "Contact Title", datafield: "Title" },
        { text: "City", datafield: "City" },
        { text: "Country", datafield: "Country" }
      ],
      ready: () => {
        this.$refs.myDataTable.lockRow(1);
      }
    };
  },
  beforeCreate: function() {
    this.source = {
      localdata: [
        ["Maria Anders", "Sales Representative", "Berlin", "Germany"],
        ["Ana Trujillo", "Owner", "Mxico D.F.", "Mexico"],
        ["Antonio Moreno", "Owner", "Mxico D.F.", "Mexico"]
      ],
      datafields: [
        { name: "ContactName", type: "string", map: "0" },
        { name: "Title", type: "string", map: "1" },
        { name: "City", type: "string", map: "2" },
        { name: "Country", type: "string", map: "3" }
      ],
      datatype: "array"
    };
  },
  methods: {
    onClick: function(event) {
      this.$refs.myDataTable.unlockRow(1);
    }
  }
};
</script>