/ext-4.1.0_b3/docs/source/RowModel.html

https://bitbucket.org/srogerf/javascript · HTML · 525 lines · 469 code · 56 blank · 0 comment · 0 complexity · 24cbe55692c5b9f292ca3fa208f76505 MD5 · raw file

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  5. <title>The source code</title>
  6. <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  7. <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  8. <style type="text/css">
  9. .highlight { display: block; background-color: #ddd; }
  10. </style>
  11. <script type="text/javascript">
  12. function highlight() {
  13. document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14. }
  15. </script>
  16. </head>
  17. <body onload="prettyPrint(); highlight();">
  18. <pre class="prettyprint lang-js"><span id='Ext-selection-RowModel'>/**
  19. </span> * Implements row based navigation via keyboard.
  20. *
  21. * Must synchronize across grid sections.
  22. */
  23. Ext.define('Ext.selection.RowModel', {
  24. extend: 'Ext.selection.Model',
  25. alias: 'selection.rowmodel',
  26. requires: ['Ext.util.KeyNav'],
  27. <span id='Ext-selection-RowModel-property-deltaScroll'> /**
  28. </span> * @private
  29. * Number of pixels to scroll to the left/right when pressing
  30. * left/right keys.
  31. */
  32. deltaScroll: 5,
  33. <span id='Ext-selection-RowModel-cfg-enableKeyNav'> /**
  34. </span> * @cfg {Boolean} enableKeyNav
  35. *
  36. * Turns on/off keyboard navigation within the grid.
  37. */
  38. enableKeyNav: true,
  39. <span id='Ext-selection-RowModel-cfg-ignoreRightMouseSelection'> /**
  40. </span> * @cfg {Boolean} [ignoreRightMouseSelection=true]
  41. * True to ignore selections that are made when using the right mouse button if there are
  42. * records that are already selected. If no records are selected, selection will continue
  43. * as normal
  44. */
  45. ignoreRightMouseSelection: true,
  46. constructor: function(){
  47. this.addEvents(
  48. <span id='Ext-selection-RowModel-event-beforedeselect'> /**
  49. </span> * @event beforedeselect
  50. * Fired before a record is deselected. If any listener returns false, the
  51. * deselection is cancelled.
  52. * @param {Ext.selection.RowModel} this
  53. * @param {Ext.data.Model} record The deselected record
  54. * @param {Number} index The row index deselected
  55. */
  56. 'beforedeselect',
  57. <span id='Ext-selection-RowModel-event-beforeselect'> /**
  58. </span> * @event beforeselect
  59. * Fired before a record is selected. If any listener returns false, the
  60. * selection is cancelled.
  61. * @param {Ext.selection.RowModel} this
  62. * @param {Ext.data.Model} record The selected record
  63. * @param {Number} index The row index selected
  64. */
  65. 'beforeselect',
  66. <span id='Ext-selection-RowModel-event-deselect'> /**
  67. </span> * @event deselect
  68. * Fired after a record is deselected
  69. * @param {Ext.selection.RowModel} this
  70. * @param {Ext.data.Model} record The deselected record
  71. * @param {Number} index The row index deselected
  72. */
  73. 'deselect',
  74. <span id='Ext-selection-RowModel-event-select'> /**
  75. </span> * @event select
  76. * Fired after a record is selected
  77. * @param {Ext.selection.RowModel} this
  78. * @param {Ext.data.Model} record The selected record
  79. * @param {Number} index The row index selected
  80. */
  81. 'select'
  82. );
  83. this.views = [];
  84. this.callParent(arguments);
  85. },
  86. bindComponent: function(view) {
  87. var me = this;
  88. me.views = me.views || [];
  89. me.views.push(view);
  90. me.bindStore(view.getStore(), true);
  91. view.on({
  92. itemmousedown: me.onRowMouseDown,
  93. scope: me
  94. });
  95. if (me.enableKeyNav) {
  96. me.initKeyNav(view);
  97. }
  98. },
  99. initKeyNav: function(view) {
  100. var me = this;
  101. if (!view.rendered) {
  102. view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
  103. return;
  104. }
  105. // view.el has tabIndex -1 to allow for
  106. // keyboard events to be passed to it.
  107. view.el.set({
  108. tabIndex: -1
  109. });
  110. // Drive the KeyNav off the View's itemkeydown event so that beforeitemkeydown listeners may veto
  111. me.keyNav = new Ext.util.KeyNav({
  112. target: view,
  113. eventName: 'itemkeydown',
  114. processEvent: function(view, record, node, index, event) {
  115. event.recordIndex = index;
  116. return event;
  117. },
  118. up: me.onKeyUp,
  119. down: me.onKeyDown,
  120. right: me.onKeyRight,
  121. left: me.onKeyLeft,
  122. pageDown: me.onKeyPageDown,
  123. pageUp: me.onKeyPageUp,
  124. home: me.onKeyHome,
  125. end: me.onKeyEnd,
  126. scope: me
  127. });
  128. view.el.on(Ext.EventManager.getKeyEvent(), me.onKeyPress, me);
  129. },
  130. // Returns the number of rows currently visible on the screen or
  131. // false if there were no rows. This assumes that all rows are
  132. // of the same height and the first view is accurate.
  133. getRowsVisible: function() {
  134. var rowsVisible = false,
  135. view = this.views[0],
  136. row = view.getNode(0),
  137. rowHeight, gridViewHeight;
  138. if (row) {
  139. rowHeight = Ext.fly(row).getHeight();
  140. gridViewHeight = view.el.getHeight();
  141. rowsVisible = Math.floor(gridViewHeight / rowHeight);
  142. }
  143. return rowsVisible;
  144. },
  145. // go to last visible record in grid.
  146. onKeyEnd: function(e) {
  147. var me = this,
  148. last = me.store.getAt(me.store.getCount() - 1);
  149. if (last) {
  150. if (e.shiftKey) {
  151. me.selectRange(last, me.lastFocused || 0);
  152. me.setLastFocused(last);
  153. } else if (e.ctrlKey) {
  154. me.setLastFocused(last);
  155. } else {
  156. me.doSelect(last);
  157. }
  158. }
  159. },
  160. // go to first visible record in grid.
  161. onKeyHome: function(e) {
  162. var me = this,
  163. first = me.store.getAt(0);
  164. if (first) {
  165. if (e.shiftKey) {
  166. me.selectRange(first, me.lastFocused || 0);
  167. me.setLastFocused(first);
  168. } else if (e.ctrlKey) {
  169. me.setLastFocused(first);
  170. } else {
  171. me.doSelect(first, false);
  172. }
  173. }
  174. },
  175. // Go one page up from the lastFocused record in the grid.
  176. onKeyPageUp: function(e) {
  177. var me = this,
  178. rowsVisible = me.getRowsVisible(),
  179. selIdx,
  180. prevIdx,
  181. prevRecord,
  182. currRec;
  183. if (rowsVisible) {
  184. selIdx = e.recordIndex;
  185. prevIdx = selIdx - rowsVisible;
  186. if (prevIdx &lt; 0) {
  187. prevIdx = 0;
  188. }
  189. prevRecord = me.store.getAt(prevIdx);
  190. if (e.shiftKey) {
  191. currRec = me.store.getAt(selIdx);
  192. me.selectRange(prevRecord, currRec, e.ctrlKey, 'up');
  193. me.setLastFocused(prevRecord);
  194. } else if (e.ctrlKey) {
  195. e.preventDefault();
  196. me.setLastFocused(prevRecord);
  197. } else {
  198. me.doSelect(prevRecord);
  199. }
  200. }
  201. },
  202. // Go one page down from the lastFocused record in the grid.
  203. onKeyPageDown: function(e) {
  204. var me = this,
  205. rowsVisible = me.getRowsVisible(),
  206. selIdx,
  207. nextIdx,
  208. nextRecord,
  209. currRec;
  210. if (rowsVisible) {
  211. selIdx = e.recordIndex;
  212. nextIdx = selIdx + rowsVisible;
  213. if (nextIdx &gt;= me.store.getCount()) {
  214. nextIdx = me.store.getCount() - 1;
  215. }
  216. nextRecord = me.store.getAt(nextIdx);
  217. if (e.shiftKey) {
  218. currRec = me.store.getAt(selIdx);
  219. me.selectRange(nextRecord, currRec, e.ctrlKey, 'down');
  220. me.setLastFocused(nextRecord);
  221. } else if (e.ctrlKey) {
  222. // some browsers, this means go thru browser tabs
  223. // attempt to stop.
  224. e.preventDefault();
  225. me.setLastFocused(nextRecord);
  226. } else {
  227. me.doSelect(nextRecord);
  228. }
  229. }
  230. },
  231. // Select/Deselect based on pressing Spacebar.
  232. // Assumes a SIMPLE selectionmode style
  233. onKeyPress: function(e) {
  234. if (e.getKey() === e.SPACE) {
  235. e.stopEvent();
  236. var me = this,
  237. record = me.lastFocused;
  238. if (record) {
  239. if (me.isSelected(record)) {
  240. me.doDeselect(record, false);
  241. } else {
  242. me.doSelect(record, true);
  243. }
  244. }
  245. }
  246. },
  247. // Navigate one record up. This could be a selection or
  248. // could be simply focusing a record for discontiguous
  249. // selection. Provides bounds checking.
  250. onKeyUp: function(e) {
  251. var me = this,
  252. view = me.views[0],
  253. idx = me.store.indexOf(me.lastFocused),
  254. record;
  255. if (idx &gt; 0) {
  256. // needs to be the filtered count as thats what
  257. // will be visible.
  258. record = me.store.getAt(idx - 1);
  259. if (e.shiftKey &amp;&amp; me.lastFocused) {
  260. if (me.isSelected(me.lastFocused) &amp;&amp; me.isSelected(record)) {
  261. me.doDeselect(me.lastFocused, true);
  262. me.setLastFocused(record);
  263. } else if (!me.isSelected(me.lastFocused)) {
  264. me.doSelect(me.lastFocused, true);
  265. me.doSelect(record, true);
  266. } else {
  267. me.doSelect(record, true);
  268. }
  269. } else if (e.ctrlKey) {
  270. me.setLastFocused(record);
  271. } else {
  272. me.doSelect(record);
  273. //view.focusRow(idx - 1);
  274. }
  275. }
  276. // There was no lastFocused record, and the user has pressed up
  277. // Ignore??
  278. //else if (this.selected.getCount() == 0) {
  279. //
  280. // this.doSelect(record);
  281. // //view.focusRow(idx - 1);
  282. //}
  283. },
  284. // Navigate one record down. This could be a selection or
  285. // could be simply focusing a record for discontiguous
  286. // selection. Provides bounds checking.
  287. onKeyDown: function(e) {
  288. var me = this,
  289. view = me.views[0],
  290. idx = me.store.indexOf(me.lastFocused),
  291. record;
  292. // needs to be the filtered count as thats what
  293. // will be visible.
  294. if (idx + 1 &lt; me.store.getCount()) {
  295. record = me.store.getAt(idx + 1);
  296. if (me.selected.getCount() === 0) {
  297. if (!e.ctrlKey) {
  298. me.doSelect(record);
  299. } else {
  300. me.setLastFocused(record);
  301. }
  302. //view.focusRow(idx + 1);
  303. } else if (e.shiftKey &amp;&amp; me.lastFocused) {
  304. if (me.isSelected(me.lastFocused) &amp;&amp; me.isSelected(record)) {
  305. me.doDeselect(me.lastFocused, true);
  306. me.setLastFocused(record);
  307. } else if (!me.isSelected(me.lastFocused)) {
  308. me.doSelect(me.lastFocused, true);
  309. me.doSelect(record, true);
  310. } else {
  311. me.doSelect(record, true);
  312. }
  313. } else if (e.ctrlKey) {
  314. me.setLastFocused(record);
  315. } else {
  316. me.doSelect(record);
  317. //view.focusRow(idx + 1);
  318. }
  319. }
  320. },
  321. scrollByDeltaX: function(delta) {
  322. var view = this.views[0],
  323. section = view.up(),
  324. hScroll = section.horizontalScroller;
  325. if (hScroll) {
  326. hScroll.scrollByDeltaX(delta);
  327. }
  328. },
  329. onKeyLeft: function(e) {
  330. this.scrollByDeltaX(-this.deltaScroll);
  331. },
  332. onKeyRight: function(e) {
  333. this.scrollByDeltaX(this.deltaScroll);
  334. },
  335. // Select the record with the event included so that
  336. // we can take into account ctrlKey, shiftKey, etc
  337. onRowMouseDown: function(view, record, item, index, e) {
  338. view.focus(false, Ext.isIE ? 200 : false);
  339. if (!this.allowRightMouseSelection(e)) {
  340. return;
  341. }
  342. this.selectWithEvent(record, e);
  343. },
  344. <span id='Ext-selection-RowModel-method-allowRightMouseSelection'> /**
  345. </span> * Checks whether a selection should proceed based on the ignoreRightMouseSelection
  346. * option.
  347. * @private
  348. * @param {Ext.EventObject} e The event
  349. * @return {Boolean} False if the selection should not proceed
  350. */
  351. allowRightMouseSelection: function(e) {
  352. var disallow = this.ignoreRightMouseSelection &amp;&amp; e.button !== 0;
  353. if (disallow) {
  354. disallow = this.hasSelection();
  355. }
  356. return !disallow;
  357. },
  358. // Allow the GridView to update the UI by
  359. // adding/removing a CSS class from the row.
  360. onSelectChange: function(record, isSelected, suppressEvent, commitFn) {
  361. var me = this,
  362. views = me.views,
  363. viewsLn = views.length,
  364. store = me.store,
  365. rowIdx = store.indexOf(record),
  366. eventName = isSelected ? 'select' : 'deselect',
  367. i = 0;
  368. if ((suppressEvent || me.fireEvent('before' + eventName, me, record, rowIdx)) !== false &amp;&amp;
  369. commitFn() !== false) {
  370. for (; i &lt; viewsLn; i++) {
  371. if (isSelected) {
  372. views[i].onRowSelect(rowIdx, suppressEvent);
  373. } else {
  374. views[i].onRowDeselect(rowIdx, suppressEvent);
  375. }
  376. }
  377. if (!suppressEvent) {
  378. me.fireEvent(eventName, me, record, rowIdx);
  379. }
  380. }
  381. },
  382. // Provide indication of what row was last focused via
  383. // the gridview.
  384. onLastFocusChanged: function(oldFocused, newFocused, supressFocus) {
  385. var views = this.views,
  386. viewsLn = views.length,
  387. store = this.store,
  388. rowIdx,
  389. i = 0;
  390. if (oldFocused) {
  391. rowIdx = store.indexOf(oldFocused);
  392. if (rowIdx != -1) {
  393. for (; i &lt; viewsLn; i++) {
  394. views[i].onRowFocus(rowIdx, false);
  395. }
  396. }
  397. }
  398. if (newFocused) {
  399. rowIdx = store.indexOf(newFocused);
  400. if (rowIdx != -1) {
  401. for (i = 0; i &lt; viewsLn; i++) {
  402. views[i].onRowFocus(rowIdx, true, supressFocus);
  403. }
  404. }
  405. }
  406. this.callParent();
  407. },
  408. onEditorTab: function(editingPlugin, e) {
  409. var me = this,
  410. view = me.views[0],
  411. record = editingPlugin.getActiveRecord(),
  412. header = editingPlugin.getActiveColumn(),
  413. position = view.getPosition(record, header),
  414. direction = e.shiftKey ? 'left' : 'right';
  415. do {
  416. position = view.walkCells(position, direction, e, me.preventWrap);
  417. } while(position &amp;&amp; !view.headerCt.getHeaderAtIndex(position.column).getEditor())
  418. if (position) {
  419. editingPlugin.startEditByPosition(position);
  420. }
  421. },
  422. selectByPosition: function(position) {
  423. var record = this.store.getAt(position.row);
  424. this.select(record);
  425. },
  426. <span id='Ext-selection-RowModel-method-selectNext'> /**
  427. </span> * Selects the record immediately following the currently selected record.
  428. * @param {Boolean} [keepExisting] True to retain existing selections
  429. * @param {Boolean} [suppressEvent] Set to false to not fire a select event
  430. * @return {Boolean} `true` if there is a next record, else `false`
  431. */
  432. selectNext: function(keepExisting, suppressEvent) {
  433. var me = this,
  434. store = me.store,
  435. selection = me.getSelection(),
  436. record = selection[selection.length - 1],
  437. index = store.indexOf(record) + 1,
  438. success;
  439. if(index === store.getCount() || index === 0) {
  440. success = false;
  441. } else {
  442. me.doSelect(index, keepExisting, suppressEvent);
  443. success = true;
  444. }
  445. return success;
  446. },
  447. <span id='Ext-selection-RowModel-method-selectPrevious'> /**
  448. </span> * Selects the record that precedes the currently selected record.
  449. * @param {Boolean} [keepExisting] True to retain existing selections
  450. * @param {Boolean} [suppressEvent] Set to false to not fire a select event
  451. * @return {Boolean} `true` if there is a previous record, else `false`
  452. */
  453. selectPrevious: function(keepExisting, suppressEvent) {
  454. var me = this,
  455. selection = me.getSelection(),
  456. record = selection[0],
  457. index = me.store.indexOf(record) - 1,
  458. success;
  459. if(index &lt; 0) {
  460. success = false;
  461. } else {
  462. me.doSelect(index, keepExisting, suppressEvent);
  463. success = true
  464. }
  465. return success;
  466. }
  467. });</pre>
  468. </body>
  469. </html>