/lib/AXGrid.js

https://github.com/qnotes/axisj · JavaScript · 5901 lines · 4830 code · 596 blank · 475 comment · 1954 complexity · d0c9e6b5b68a6b1fcf7cf76c261b08b1 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /**

    2. 

  2.  * AXGrid

    3. 

  3.  * @class AXGrid

    4. 

  4.  * @extends AXJ

    5. 

  5.  * @version v1.65

    6. 

  6.  * @author tom@axisj.com

    7. 

  7.  * @logs

    8. 

  8.  "2012-12-24 오전 11:51:26",

    9. 

  9.  "2013-01-08 오전 10:53:46 50% 진행중 - tom",

    10. 

  10.  "2013-01-22 오후 10:20:01 99% 완료 - tom",

    11. 

  11.  "2013-02-11 오후 12:21:55 editor value function 구문 적용 - tom",

    12. 

  12.  "2013-02-15 오후 7:04:03 list length 가 1일때 setEditor 버그 수정 - tom",

    13. 

  13.  "2013-02-16 오후 1:12:17 휠 스크롤 제어 예외 처리 - tom",

    14. 

  14.  "2013-02-16 오후 10:37:55 reloadList 추가 - tom",

    15. 

  15.  "2013-04-08 오후 9:48:53 getCheckedListWithIndex 추가 - tom",

    16. 

  16.  "2013-05-09 오후 1:56:53 setFocus 추가 - tom",

    17. 

  17.  "2013-06-17 오후 12:52:04 setFocus 스크롤 자동이동 기능 보강 /  focusMove 추가 - tom ",

    18. 

  18.  "2013-06-21 오전 10:34:04 fitToWidth 속성 추가 & marker bugfix - tom",

    19. 

  19.  "2013-06-25 오후 5:23:29 getSelectedItem 추가 / 버그픽스 - tom",

    20. 

  20.  "2013-06-28 오전 11:32:33 wheel 버그픽스 - tom",

    21. 

  21.  "2013-07-04 오후 1:12:34 tooltip 속성 추가 - tom",

    22. 

  22.  "2013-07-17 오후 4:27:34 페이지 변경시 서버 2중 호출 버그 픽스",

    23. 

  23.  "2013-07-21 오후 10:15:09 wheel 버그픽스 - tom",

    24. 

  24.  "2013-07-24 오전 10:17:05 page 선언안함 버그픽스 - tom",

    25. 

  25.  "2013-09-04 오후 2:49:54 AXConfig에서 설정값 바인딩 구조로 변경 처리 - tom",

    26. 

  26.  "2013-09-23 오후 4:07:58 printList에서 리스트가 없을때 this.redrawGrid() 호출 추가 - root",

    27. 

  27.  "2013-09-24 오전 12:49:34 setList 선언전에 append 안되는 문제와 목록없음 표시 처리 문제 보강 / body > onscrollend 함수 지원 - tom",

    28. 

  28.  "2013-09-29 오전 12:41:29 colGroup width:'*' 옵션추가 / colHeadAlign 우선순위 조정 - tom",

    29. 

  29.  "2013-09-30 오전 1:40:22 colMap 함수정리 - tom",

    30. 

  30.  "2013-10-18 오전 8:30:50 dblclick 이벤트 개선 / click(index) 메서드 추가 - tom",

    31. 

  31.  "2013-10-23 오후 2:48:24 formatter radio 지원 - tom",

    32. 

  32.  "2013-10-24 오후 10:01:27 colGroup formatter - displayLabel:true 옵션추가 - tom",

    33. 

  33.  "2013-10-28 오전 9:37:26 page count 버그 픽스 / $ 키워드 제거 - tom",

    34. 

  34.  "2013-11-13 오전 10:09:14 tom : fitToWidth 창 최대화 최소화 버그 픽스",

    35. 

  35.  "2013-11-18 오후 1:34:35 tom : grid owidth 버그 픽스",

    36. 

  36.  "2013-12-09 오후 4:26:45 tom : setList 후 그리드 스크롤포지션 문제 해결",

    37. 

  37.  "2013-12-11 오후 9:31:45 tom : ajax setList 그리드 스크롤포지션 문제 해결",

    38. 

  38.  "2013-12-19 오후 3:30 tom : height=auto 일 경우 scrollTop 되는 현상 해결",

    39. 

  39.  "2013-12-24 오후 2:30:25 tom : 버그픽스",

    40. 

  40.  "2013-12-27 오전 11:56:44 tom marker bugfix",

    41. 

  41.  "2013-12-30 오후 11:00:00 tom : colGroup sort:false 기능 추가 및 버그 픽스",

    42. 

  42.  "2014-01-01 오후 8:55:17 tom : editor validate 액션버그 픽스",

    43. 

  43.  "2014-01-03 오후 3:31:09 tom : gridBodyClick 이벤트함수 수정",

    44. 

  44.  "2014-01-10 오후 5:08:30 tom : listCountMSG 설정 기능 추가",

    45. 

  45.  "2014-02-04 오전 10:13:38 tom : setList 메소드 호출 할 때 pageNo : 1 로 변경 기능 추가",

    46. 

  46.  "2014-02-06 오후 7:59:54 tom : jQuery 독립 우회 코드 변경",

    47. 

  47.  "2014-02-12 오전 11:31:41 tom : 불필요한 node 제거, * 설정시 헤드 너비 오차 문제 해결",

    48. 

  48.  "2014-02-14 오전 11:10:45 tom : setEditor 후 selector 키컨트롤 이벤트 방지, editor 안에 onkeyup 메소드 추가",

    49. 

  49.  "2014-02-14 오후 12:42:32 tom : appendList메소드 index를 지정 하지 않으면 맨 마지막으로 추가 되도록 변경",

    50. 

  50.  "2014-02-25 오전 11:24:29 tom : formatter 함수 this에 .value, .key 속성 추가",

    51. 

  51.  "2014-03-05 오후 12:17:26 tom : editor.response 에서 validate 후 editor 사라지도록 기능 변경, editorForm Item 중복되지 않도록 수정",

    52. 

  52.  "2014-03-05 오후 5:13:45 tom : 열 리사이즈했을 때 스크롤 위치 버그픽스",

    53. 

  53.  "2014-03-06 오후 8:22:00 tom : 열 리사이즈 후 컬럼 숨기기 표시 하시 액션 너비 변경 버그픽스",

    54. 

  54.  "2014-03-12 오후 3:04:11 root : 그리드 헤드 체크 박스 클릭시 disable 된 row 는 체크 하지않도록 변경",

    55. 

  55.  "2014-03-20 오전 11:16:51 tom : printList 실행 할 때 editor 활성화 되었으면 에디터 비 활성화",

    56. 

  56.  "2014-03-28 오전 8:18:54 tom : click 메소드 호출시 callBack 버그 픽스",

    57. 

  57.  "2014-03-31 오전 2:07:24 tom : init 에서 printList 호출 제거 / body.marker.addClass 속성 추가",

    58. 

  58.  "2014-03-31 오후 4:14:34 tom : scroll 영역 조정 ",

    59. 

  59.  "2014-04-01 오후 7:10:34 tom : .each for 로 변경/ changeGridView 메소드 추가",

    60. 

  60.  "2014-04-20 tom : listLoadingDisplay 실행할 때 가능하면 스크롤바의 위치를 맨위로 이동 시키기",

    61. 

  61.  "2014-04-22 tom : setList 호출시 onError 속성 추가",

    62. 

  62.  "2014-04-25 tom : setData 메소드 추가",

    63. 

  63.  "2014-04-28 tom : mobile 에서 터치무브 버그 픽스",

    64. 

  64.  "2014-04-28 tom : config.emptyListMSG 에서 설정가능",

    65. 

  65.  "2014-04-29 tom : AXConfig.AXGrid.pageCountMsg 설정기능 추가"

    66. 

  66. 

    67. 

  67.  * @description

    68. 

  68.  *

    69. 

  69.  ```js

    70. 

  70.  var myGrid = new AXGrid();

    71. 

  71.  myGrid.setConfig(classConfig:JSObject);

    72. 

  72.  ```

    73. 

  73.  *

    74. 

  74.  */

    75. 

  75. 

    76. 

  76. var AXGrid;

    77. 

  77. AXGrid = Class.create(AXJ, {

    78. 

  78.     initialize: function (AXJ_super) {

    79. 

  79.         AXJ_super();

    80. 

  80.         this.Observer = null;

    81. 

  81.         this.list = [];

    82. 

  82.         this.removedList = [];

    83. 

  83.         this.pageActive = false;

    84. 

  84.         this.page = { pageNo: 0, pageSize: 100, pageCount: "", listCount: 0 };

    85. 

  85. 

    86. 

  86.         this.moveSens = 0;

    87. 

  87.         this.config.viewMode = "grid"; // icon, mobile

    88. 

  88.         this.config.moveSens = 1;

    89. 

  89.         this.config.formPaddingRight = "11px";

    90. 

  90.         this.config.sort = true;

    91. 

  91.         this.config.xscroll = true;

    92. 

  92.         this.config.fitToWidth = (AXConfig.AXGrid.fitToWidth || false);

    93. 

  93.         this.config.fitToWidthRightMargin = (AXConfig.AXGrid.fitToWidthRightMargin || 10);

    94. 

  94.         this.config.passiveMode = AXConfig.AXGrid.passiveMode;

    95. 

  95.         this.config.passiveRemoveHide = AXConfig.AXGrid.passiveRemoveHide;

    96. 

  96. 

    97. 

  97.         this.selectedCells = [];

    98. 

  98.         this.selectedRow = [];

    99. 

  99. 

    100. 

  100.         var browser = AXUtil.browser;

    101. 

  101.         this.isMobile = browser.mobile;

    102. 

  102.     },

    103. 

  103.     /* 공통 영역 */

    104. 

  104.     defineConfig: function (rewrite) {

    105. 

  105.         var cfg = this.config;

    106. 

  106.         if (cfg.colGroup.length == 0) {

    107. 

  107.             trace("colGrpup is empty)");

    108. 

  108.             return;

    109. 

  109.         }

    110. 

  110. 

    111. 

  111.         /* col너비 합계 구하기 */

    112. 

  112.         var colWidth = 0;

    113. 

  113.         var hasHiddenCell = false;

    114. 

  114.         var showColLen = 0;

    115. 

  115.         if (!rewrite) this.fixedColSeq = cfg.fixedColSeq;

    116. 

  116.         var bodyWidth = this.body.width();

    117. 

  117.         var astricCount = 0;

    118. 

  118. 

    119. 

  119.         for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    120. 

  120.             if (CG.colSeq == undefined) CG.colSeq = cidx;

    121. 

  121.             if (CG.display == undefined) CG.display = true;

    122. 

  122.             if (CG.display) {

    123. 

  123.                 if (!rewrite) {

    124. 

  124.                     if (CG.width == "*") {

    125. 

  125.                         CG.width = 0;

    126. 

  126.                         CG.widthAstric = true;

    127. 

  127.                         astricCount++;

    128. 

  128.                     }

    129. 

  129.                     CG._owidth = CG.width;

    130. 

  130.                     /* 최초의 너비값 기억 하기 */

    131. 

  131.                 } else {

    132. 

  132.                     if (CG.widthAstric) {

    133. 

  133.                         CG.width = 0;

    134. 

  134.                         CG._owidth = CG.width;

    135. 

  135.                         astricCount++;

    136. 

  136.                     }

    137. 

  137.                 }

    138. 

  138. 

    139. 

  139.                 colWidth += (CG._owidth || 0).number();

    140. 

  140.                 showColLen += 1;

    141. 

  141.             } else {

    142. 

  142.                 hasHiddenCell = true;

    143. 

  143.             }

    144. 

  144.         }

    145. 

  145. 

    146. 

  146.         if (!cfg.fitToWidth) {

    147. 

  147.             /* width * 예외처리 구문 ------------ s */

    148. 

  148.             if ((bodyWidth - cfg.fitToWidthRightMargin) > (colWidth + 100 * astricCount)) {

    149. 

  149.                 var remainsWidth = (bodyWidth - cfg.fitToWidthRightMargin) - colWidth;

    150. 

  150.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    151. 

  151.                     if (CG.display && CG.widthAstric) {

    152. 

  152.                         CG._owidth = (remainsWidth / astricCount).ceil();

    153. 

  153.                         CG.width = CG._owidth;

    154. 

  154.                         colWidth += (CG._owidth || 0).number();

    155. 

  155.                     }

    156. 

  156.                 }

    157. 

  157.             } else {

    158. 

  158.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    159. 

  159.                     if (CG.display && CG.widthAstric) {

    160. 

  160.                         CG._owidth = 100;

    161. 

  161.                         CG.width = 100;

    162. 

  162.                         colWidth += (CG._owidth || 0).number();

    163. 

  163.                     }

    164. 

  164.                 }

    165. 

  165.             }

    166. 

  166.             /* width * 예외처리 구문 ------------ e */

    167. 

  167.         } else {

    168. 

  168.             for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    169. 

  169.                 if (CG.display && CG.widthAstric) {

    170. 

  170.                     CG.width = 100;

    171. 

  171.                     CG._owidth = 100;

    172. 

  172.                     colWidth += (CG._owidth || 0).number();

    173. 

  173.                 }

    174. 

  174.             }

    175. 

  175.         }

    176. 

  176.         this.colWidth = colWidth;

    177. 

  177. 

    178. 

  178.         if (cfg.fitToWidth) { /*너비 자동 맞춤버전의 경우 */

    179. 

  179.             if (bodyWidth > this.colWidth) {

    180. 

  180.                 var _bodyWidth = bodyWidth - cfg.fitToWidthRightMargin;

    181. 

  181.                 var zoomRatio = bodyWidth / this.colWidth;

    182. 

  182.                 colWidth = 0;

    183. 

  183.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    184. 

  184.                     CG.width = (CG._owidth * zoomRatio).ceil();

    185. 

  185.                     if (_bodyWidth > CG.width) _bodyWidth -= CG.width;

    186. 

  186.                     else CG.width = _bodyWidth;

    187. 

  187.                     if (CG.display) colWidth += CG.width.number();

    188. 

  188.                 }

    189. 

  189.                 this.colWidth = colWidth;

    190. 

  190.             } else {

    191. 

  191.                 colWidth = 0;

    192. 

  192.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    193. 

  193.                     if (CG._owidth == undefined) CG._owidth = (CG.width || 0).number();

    194. 

  194.                     CG.width = CG._owidth.number();

    195. 

  195.                     if (CG.display) colWidth += CG.width.number();

    196. 

  196.                 }

    197. 

  197.                 this.colWidth = colWidth;

    198. 

  198.             }

    199. 

  199.         }

    200. 

  200. 

    201. 

  201.         this.showColLen = showColLen;

    202. 

  202.         /* col너비 합계 구하기 ~~~~~~~~~~~~~~ 구해진 너비합은 그리드 head, body 의 너비로 지정됨. */

    203. 

  203. 

    204. 

  204.         if (!cfg.colHead) cfg.colHead = {};

    205. 

  205.         if (!cfg.body) cfg.body = {};

    206. 

  206.         if (!cfg.page) cfg.page = { display: false, paging: false, status: { formatter: null } };

    207. 

  207.         if (cfg.colHead.rowsEmpty) cfg.colHead.rows = undefined;

    208. 

  208.         if (cfg.body.rowsEmpty) cfg.body.rows = undefined;

    209. 

  209. 

    210. 

  210.         /* colHead rows ----------------------------------------------------------------------------------------------------- */

    211. 

  211.         if (cfg.colHead.rows) {

    212. 

  212.             /* colHeadRow 정해진 경우 */

    213. 

  213.             cfg.colHead._maps = new Array(cfg.colHead.rows.length);

    214. 

  214.             var colMaxLen = 0;

    215. 

  215.             for (var r = 0; r < cfg.colHead.rows.length; r++) {

    216. 

  216.                 var colLen = 0;

    217. 

  217.                 for (var CH, CHidx = 0, __arr = cfg.colHead.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    218. 

  218.                     if (CH.rowspan == undefined || CH.rowspan == null) CH.rowspan = 1;

    219. 

  219.                     if (CH.colspan == undefined || CH.colspan == null) {

    220. 

  220.                         CH.colspan = 1;

    221. 

  221.                         CH._colspan = 1;

    222. 

  222.                     } else {

    223. 

  223.                         if (!rewrite) {

    224. 

  224.                             CH._colspan = CH.colspan;

    225. 

  225.                         } else {

    226. 

  226.                             CH.colspan = CH._colspan;

    227. 

  227.                         }

    228. 

  228.                     }

    229. 

  229.                     if (CH.valign == undefined || CH.valign == null) CH.valign = "bottom";

    230. 

  230.                     if (cfg.colHeadAlign) CH.align = "center";

    231. 

  231.                     colLen += CH.colspan.number();

    232. 

  232.                 }

    233. 

  233.                 if (colMaxLen < colLen) colMaxLen = colLen;

    234. 

  234.             }

    235. 

  235.             for (var _m = 0; _m < cfg.colHead._maps.length; _m++) {

    236. 

  236.                 cfg.colHead._maps[_m] = new Array(colMaxLen);

    237. 

  237.             }

    238. 

  238.             /* colEndPosition 관련 처리 함수 */

    239. 

  239.             var appendPosToColHeadMap = function (r, c, posR, position) {

    240. 

  240.                 var nC = position.c;

    241. 

  241.                 /*시작 컬럼 위치 */

    242. 

  242.                 var startPosition = null;

    243. 

  243.                 for (var rr = posR; rr < (posR + r); rr++) {

    244. 

  244.                     if (r > 1) if (rr > 0 && startPosition != null) nC = startPosition;

    245. 

  245.                     var tC = c;

    246. 

  246.                     /*컬럼 루프횟수 */

    247. 

  247.                     var isWhile = true;

    248. 

  248.                     /* 루프유지변수 */

    249. 

  249.                     while (isWhile) {

    250. 

  250.                         try {

    251. 

  251.                             if (tC == 0) {

    252. 

  252.                                 isWhile = false;

    253. 

  253.                             } else {

    254. 

  254.                                 if (cfg.colHead._maps[rr][nC] == undefined) {

    255. 

  255.                                     cfg.colHead._maps[rr][nC] = position;

    256. 

  256.                                     if (startPosition == null) startPosition = nC;

    257. 

  257.                                     tC--;

    258. 

  258.                                 } else {

    259. 

  259.                                     nC++;

    260. 

  260.                                 }

    261. 

  261.                             }

    262. 

  262.                         } catch (e) {

    263. 

  263.                             isWhile = false;

    264. 

  264.                         }

    265. 

  265.                     }

    266. 

  266.                 }

    267. 

  267.                 return startPosition;

    268. 

  268.             };

    269. 

  269.             for (var r = 0; r < cfg.colHead.rows.length; r++) {

    270. 

  270.                 //var startPosition = null;

    271. 

  271.                 //var isMultiRow = false;

    272. 

  272.                 for (var CH, CHidx = 0, __arr = cfg.colHead.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    273. 

  273.                     if (CH.colSeq != undefined) {

    274. 

  274.                         var myCG = cfg.colGroup.getToSeq(CH.colSeq);

    275. 

  275.                     } else {

    276. 

  276.                         var myCG = cfg.colGroup.searchObject(function () {

    277. 

  277.                             return CH.key == this.item.key;

    278. 

  278.                         }).first();

    279. 

  279.                     }

    280. 

  280.                     if (myCG != null) {

    281. 

  281.                         if (rewrite) AXUtil.overwriteObject(CH, myCG, true);

    282. 

  282.                         else AXUtil.overwriteObject(CH, myCG, false);

    283. 

  283.                     } else {

    284. 

  284.                         AXUtil.overwriteObject(CH, { align: "left", valign: "bottom", display: true, rowspan: 1, colspan: 1 }, false);

    285. 

  285.                     }

    286. 

  286.                     appendPosToColHeadMap(CH.rowspan, CH.colspan, r, { r: r, c: CHidx });

    287. 

  287.                 }

    288. 

  288.             }

    289. 

  289.             /*colHead._maps 마지막 줄에 해당하는 cfg.colHead.rows 에 속성부여 */

    290. 

  290.             for (var m, midx = 0, __arr = cfg.colHead._maps.last(); (midx < __arr.length && (m = __arr[midx])); midx++) {

    291. 

  291.                 if (m) cfg.colHead.rows[m.r][m.c].isLastCell = true;

    292. 

  292.             }

    293. 

  293. 

    294. 

  294.             if (hasHiddenCell) { /* colGroup 중에 숨겨진 col 이 존재하는 경우 */

    295. 

  295.                 /* colspan 감소 시키기 */

    296. 

  296.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    297. 

  297.                     if (!CG.display) {

    298. 

  298.                         var rowPosition = null;

    299. 

  299.                         for (var a = 0; a < cfg.colHead._maps.length; a++) {

    300. 

  300.                             if (rowPosition != cfg.colHead._maps[a][cidx]) {

    301. 

  301.                                 rowPosition = cfg.colHead._maps[a][cidx];

    302. 

  302.                                 cfg.colHead.rows[rowPosition.r][rowPosition.c].colspan--;

    303. 

  303.                             }

    304. 

  304.                         }

    305. 

  305.                     }

    306. 

  306.                 }

    307. 

  307.             }

    308. 

  308.             /*trace(cfg.colHead._maps);  //_maps check */

    309. 

  309. 

    310. 

  310.             /* colHeadRow 정해진 경우 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    311. 

  311.         } else {

    312. 

  312.             /* colHeadRow 정해지지 않은 경우 */

    313. 

  313. 

    314. 

  314.             cfg.colHead._maps = [

    315. 

  315.                 []

    316. 

  316.             ];

    317. 

  317.             var colHeadRows = [

    318. 

  318.                 []

    319. 

  319.             ];

    320. 

  320.             for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    321. 

  321.                 var adder = {

    322. 

  322.                     key: CG.key,

    323. 

  323.                     colSeq: CG.colSeq,

    324. 

  324.                     label: CG.label,

    325. 

  325.                     align: (cfg.colHeadAlign || CG.align || "left"),

    326. 

  326.                     rowspan: 1, colspan: 1,

    327. 

  327.                     valign: "bottom", isLastCell: true, display: CG.display, formatter: CG.formatter, checked: CG.checked, disabled: CG.disabled,

    328. 

  328.                     sort: CG.sort,

    329. 

  329.                     tooltip: CG.tooltip,

    330. 

  330.                     displayLabel: (CG.displayLabel || false)

    331. 

  331.                 };

    332. 

  332.                 colHeadRows[0].push(adder);

    333. 

  333.                 cfg.colHead._maps[0].push({ r: 0, c: cidx });

    334. 

  334.             }

    335. 

  335.             cfg.colHead.rows = colHeadRows;

    336. 

  336.             cfg.colHead.rowsEmpty = true;

    337. 

  337.             /* colHeadRow 정해지지 않은 경우 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    338. 

  338.         }

    339. 

  339.         /* colHead rows ----------------------------------------------------------------------------------------------------- */

    340. 

  340. 

    341. 

  341.         /* body rows ------------------------------------------------------------------------------------------------------- */

    342. 

  342.         if (cfg.body.rows) {

    343. 

  343.             /* bodyRow 정해진 경우 */

    344. 

  344.             cfg.body._maps = new Array(cfg.body.rows.length);

    345. 

  345.             var colMaxLen = 0;

    346. 

  346.             for (var r = 0; r < cfg.body.rows.length; r++) {

    347. 

  347.                 var colLen = 0;

    348. 

  348.                 for (var CH, CHidx = 0, __arr = cfg.body.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    349. 

  349.                     if (CH.colspan == undefined || CH.colspan == null) {

    350. 

  350.                         CH.colspan = 1;

    351. 

  351.                         CH._colspan = 1;

    352. 

  352.                     } else {

    353. 

  353.                         if (!rewrite) CH._colspan = CH.colspan;

    354. 

  354.                         else CH.colspan = CH._colspan;

    355. 

  355.                     }

    356. 

  356.                     if (CH.rowspan == undefined || CH.rowspan == null) CH.rowspan = 1;

    357. 

  357.                     if (CH.valign == undefined || CH.valign == null) CH.valign = "middle";

    358. 

  358.                     /* if(CH.align == undefined || CH.align == null) CH.align = "left"; */

    359. 

  359.                     colLen += CH.colspan.number();

    360. 

  360.                 }

    361. 

  361.                 if (colMaxLen < colLen) colMaxLen = colLen;

    362. 

  362.             }

    363. 

  363.             for (var _m = 0; _m < cfg.body._maps.length; _m++) {

    364. 

  364.                 cfg.body._maps[_m] = new Array(colMaxLen);

    365. 

  365.             }

    366. 

  366.             /* colEndPosition 관련 처리 함수 */

    367. 

  367.             var appendPosToBodyMap = function (r, c, posR, position) {

    368. 

  368.                 var nC = position.c;

    369. 

  369.                 /*시작 컬럼 위치 */

    370. 

  370.                 var startPosition = null;

    371. 

  371.                 for (var rr = posR; rr < (posR + r); rr++) {

    372. 

  372.                     if (r > 1) if (rr > 0 && startPosition != null) nC = startPosition;

    373. 

  373.                     var tC = c;

    374. 

  374.                     /*컬럼 루프횟수 */

    375. 

  375.                     var isWhile = true;

    376. 

  376.                     /* 루프유지변수 */

    377. 

  377.                     while (isWhile) {

    378. 

  378.                         try {

    379. 

  379.                             if (tC == 0) {

    380. 

  380.                                 isWhile = false;

    381. 

  381.                             } else {

    382. 

  382.                                 if (cfg.body._maps[rr][nC] == undefined) {

    383. 

  383.                                     cfg.body._maps[rr][nC] = position;

    384. 

  384.                                     if (startPosition == null) startPosition = nC;

    385. 

  385.                                     tC--;

    386. 

  386.                                 } else {

    387. 

  387.                                     nC++;

    388. 

  388.                                 }

    389. 

  389.                             }

    390. 

  390.                         } catch (e) {

    391. 

  391.                             isWhile = false;

    392. 

  392.                         }

    393. 

  393.                     }

    394. 

  394.                 }

    395. 

  395.             };

    396. 

  396.             for (var r = 0; r < cfg.body.rows.length; r++) {

    397. 

  397.                 for (var CH, CHidx = 0, __arr = cfg.body.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    398. 

  398.                     if (CH.colSeq != undefined) {

    399. 

  399.                         var myCG = cfg.colGroup.getToSeq(CH.colSeq);

    400. 

  400.                     } else {

    401. 

  401.                         var myCG = cfg.colGroup.searchObject(function () {

    402. 

  402.                             return this.item.key == CH.key;

    403. 

  403.                         }).first();

    404. 

  404.                     }

    405. 

  405. 

    406. 

  406.                     if (myCG != null) {

    407. 

  407.                         AXUtil.overwriteObject(CH, myCG, false);

    408. 

  408.                     } else {

    409. 

  409.                         AXUtil.overwriteObject(CH, { align: "left", valign: "bottom", display: true, rowspan: 1, colspan: 1 }, false);

    410. 

  410.                     }

    411. 

  411.                     appendPosToBodyMap(CH.rowspan, CH.colspan, r, { r: r, c: CHidx });

    412. 

  412.                 }

    413. 

  413.             }

    414. 

  414.             /*body._maps 마지막 줄에 해당하는 cfg.body.rows 에 속성부여 */

    415. 

  415.             for (var m, midx = 0, __arr = cfg.body._maps.last(); (midx < __arr.length && (m = __arr[midx])); midx++) {

    416. 

  416.                 if (m) cfg.body.rows[m.r][m.c].isLastCell = true;

    417. 

  417.             }

    418. 

  418. 

    419. 

  419.             if (hasHiddenCell) { /* colGroup 중에 숨겨진 col 이 존재하는 경우 */

    420. 

  420.                 /* colspan 감소 시키기 */

    421. 

  421.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    422. 

  422.                     if (!CG.display) {

    423. 

  423.                         for (var a = 0; a < cfg.body._maps.length; a++) {

    424. 

  424.                             var rowPosition = cfg.body._maps[a][cidx];

    425. 

  425.                             cfg.body.rows[rowPosition.r][rowPosition.c].colspan--;

    426. 

  426.                         }

    427. 

  427.                     }

    428. 

  428.                 }

    429. 

  429.             }

    430. 

  430. 

    431. 

  431.             /* bodyRow 정해진 경우 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    432. 

  432.         } else {

    433. 

  433.             /* bodyRow 정해지지 않은 경우 */

    434. 

  434.             cfg.body._maps = [

    435. 

  435.                 []

    436. 

  436.             ];

    437. 

  437.             var bodyRows = [

    438. 

  438.                 []

    439. 

  439.             ];

    440. 

  440.             for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    441. 

  441.                 var adder = {

    442. 

  442.                     key: CG.key, colSeq: CG.colSeq, label: CG.label, align: (CG.align || "left"), rowspan: 1, colspan: 1, valign: "middle", isLastCell: true,

    443. 

  443.                     display: CG.display, checked: CG.checked, disabled: CG.disabled, formatter: CG.formatter,

    444. 

  444.                     tooltip: CG.tooltip

    445. 

  445.                 };

    446. 

  446.                 bodyRows[0].push(adder);

    447. 

  447.                 cfg.body._maps[0].push({ r: 0, c: cidx });

    448. 

  448.             }

    449. 

  449.             cfg.body.rows = bodyRows;

    450. 

  450.             cfg.body.rowsEmpty = true;

    451. 

  451.             /* bodyRow 정해지지 않은 경우 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    452. 

  452.         }

    453. 

  453.         /* body rows ------------------------------------------------------------------------------------------------------- */

    454. 

  454. 

    455. 

  455.         /*marker 관련 데이터 정리 */

    456. 

  456.         if (cfg.body.marker) {

    457. 

  457.             if (cfg.body.marker.rows) {

    458. 

  458.                 this.bodyHasMarker = true;

    459. 

  459.                 cfg.body.marker._maps = new Array(cfg.body.marker.rows.length);

    460. 

  460.                 colMaxLen = 0;

    461. 

  461.                 for (var r = 0; r < cfg.body.marker.rows.length; r++) {

    462. 

  462.                     var colLen = 0;

    463. 

  463.                     for (var CH, CHidx = 0, __arr = cfg.body.marker.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    464. 

  464.                         if (CH.rowspan == undefined || CH.rowspan == null) CH.rowspan = 1;

    465. 

  465.                         if (CH.colspan == undefined || CH.colspan == null) {

    466. 

  466.                             CH.colspan = 1;

    467. 

  467.                             CH._colspan = 1;

    468. 

  468.                         } else {

    469. 

  469.                             if (!rewrite) CH._colspan = CH.colspan;

    470. 

  470.                             else CH.colspan = CH._colspan;

    471. 

  471.                         }

    472. 

  472.                         if (CH.valign == undefined || CH.valign == null) CH.valign = "bottom";

    473. 

  473.                         colLen += CH.colspan.number();

    474. 

  474.                     }

    475. 

  475.                     if (colMaxLen < colLen) colMaxLen = colLen;

    476. 

  476.                 }

    477. 

  477.                 for (var _m = 0; _m < cfg.body.marker._maps.length; _m++) {

    478. 

  478.                     cfg.body.marker._maps[_m] = new Array(colMaxLen);

    479. 

  479.                 }

    480. 

  480.                 /* colEndPosition 관련 처리 함수 */

    481. 

  481.                 var appendPosToMarkerMap = function (r, c, posR, position) {

    482. 

  482.                     var nC = position.c;

    483. 

  483.                     /*시작 컬럼 위치 */

    484. 

  484.                     var startPosition = null;

    485. 

  485.                     for (var rr = posR; rr < (posR + r); rr++) {

    486. 

  486.                         if (r > 1) if (rr > 0 && startPosition != null) nC = startPosition;

    487. 

  487.                         var tC = c;

    488. 

  488.                         /*컬럼 루프횟수 */

    489. 

  489.                         var isWhile = true;

    490. 

  490.                         /* 루프유지변수 */

    491. 

  491.                         while (isWhile) {

    492. 

  492.                             try {

    493. 

  493.                                 if (tC == 0) {

    494. 

  494.                                     isWhile = false;

    495. 

  495.                                 } else {

    496. 

  496.                                     if (cfg.body.marker._maps[rr][nC] == undefined) {

    497. 

  497.                                         cfg.body.marker._maps[rr][nC] = position;

    498. 

  498.                                         if (startPosition == null) startPosition = nC;

    499. 

  499.                                         tC--;

    500. 

  500.                                     } else {

    501. 

  501.                                         nC++;

    502. 

  502.                                     }

    503. 

  503.                                 }

    504. 

  504.                             } catch (e) {

    505. 

  505.                                 isWhile = false;

    506. 

  506.                             }

    507. 

  507.                         }

    508. 

  508.                     }

    509. 

  509.                 };

    510. 

  510.                 for (var r = 0; r < cfg.body.marker.rows.length; r++) {

    511. 

  511.                     for (var CH, CHidx = 0, __arr = cfg.body.marker.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    512. 

  512.                         if (CH.colSeq != undefined) {

    513. 

  513.                             var myCG = cfg.colGroup.getToSeq(CH.colSeq);

    514. 

  514.                         } else {

    515. 

  515.                             var myCG = cfg.colGroup.searchObject(function () {

    516. 

  516.                                 return this.item.key == CH.key;

    517. 

  517.                             }).first();

    518. 

  518.                         }

    519. 

  519. 

    520. 

  520.                         if (myCG != null) {

    521. 

  521.                             AXUtil.overwriteObject(CH, myCG, false);

    522. 

  522.                         } else {

    523. 

  523.                             AXUtil.overwriteObject(CH, { align: "left", valign: "bottom", display: true, rowspan: 1, colspan: 1 }, false);

    524. 

  524.                         }

    525. 

  525.                         appendPosToMarkerMap(CH.rowspan, CH.colspan, r, { r: r, c: CHidx });

    526. 

  526.                     }

    527. 

  527. 

    528. 

  528.                 }

    529. 

  529.                 /*colHead._maps 마지막 줄에 해당하는 cfg.colHead.rows 에 속성부여 */

    530. 

  530.                 for (var m, midx = 0, __arr = cfg.body.marker._maps.last(); (midx < __arr.length && (m = __arr[midx])); midx++) {

    531. 

  531.                     if (m) cfg.body.marker.rows[m.r][m.c].isLastCell = true;

    532. 

  532.                 }

    533. 

  533. 

    534. 

  534. 

    535. 

  535.                 if (hasHiddenCell) { /* colGroup 중에 숨겨진 col 이 존재하는 경우 */

    536. 

  536.                     /* colspan 감소 시키기 */

    537. 

  537.                     for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    538. 

  538.                         if (!CG.display) {

    539. 

  539.                             for (var a = 0; a < cfg.body.marker._maps.length; a++) {

    540. 

  540.                                 var rowPosition = cfg.body.marker._maps[a][cidx];

    541. 

  541.                                 cfg.body.marker.rows[rowPosition.r][rowPosition.c].colspan--;

    542. 

  542.                             }

    543. 

  543.                         }

    544. 

  544.                     }

    545. 

  545. 

    546. 

  546.                 }

    547. 

  547.             }

    548. 

  548.         }

    549. 

  549.         /*marker 관련 데이터 정리 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    550. 

  550. 

    551. 

  551. 

    552. 

  552.         /*head 관련 데이터 정리 */

    553. 

  553.         if (cfg.head) {

    554. 

  554.             cfg.head._maps = new Array(cfg.head.rows.length);

    555. 

  555.             colMaxLen = 0;

    556. 

  556.             for (var r = 0; r < cfg.head.rows.length; r++) {

    557. 

  557.                 var colLen = 0;

    558. 

  558.                 for (var CH, CHidx = 0, __arr = cfg.head.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    559. 

  559.                     if (CH.rowspan == undefined || CH.rowspan == null) CH.rowspan = 1;

    560. 

  560.                     if (CH.colspan == undefined || CH.colspan == null) {

    561. 

  561.                         CH.colspan = 1;

    562. 

  562.                         CH._colspan = 1;

    563. 

  563.                     } else {

    564. 

  564.                         if (!rewrite) CH._colspan = CH.colspan;

    565. 

  565.                         else CH.colspan = CH._colspan;

    566. 

  566.                     }

    567. 

  567.                     if (CH.valign == undefined || CH.valign == null) CH.valign = "bottom";

    568. 

  568.                     /*if(CH.align == undefined || CH.align == null) CH.align = "left"; */

    569. 

  569.                     colLen += CH.colspan.number();

    570. 

  570.                 }

    571. 

  571. 

    572. 

  572.                 if (colMaxLen < colLen) colMaxLen = colLen;

    573. 

  573.             }

    574. 

  574.             for (var _m = 0; _m < cfg.head._maps.length; _m++) {

    575. 

  575.                 cfg.head._maps[_m] = new Array(colMaxLen);

    576. 

  576.             }

    577. 

  577.             /* colEndPosition 관련 처리 함수 */

    578. 

  578.             var appendPosToHeadMap = function (r, c, posR, position) {

    579. 

  579.                 var nC = position.c;

    580. 

  580.                 /*시작 컬럼 위치 */

    581. 

  581.                 var startPosition = null;

    582. 

  582.                 for (var rr = posR; rr < (posR + r); rr++) {

    583. 

  583.                     if (r > 1) if (rr > 0 && startPosition != null) nC = startPosition;

    584. 

  584.                     var tC = c;

    585. 

  585.                     /*컬럼 루프횟수 */

    586. 

  586.                     var isWhile = true;

    587. 

  587.                     /* 루프유지변수 */

    588. 

  588.                     while (isWhile) {

    589. 

  589.                         try {

    590. 

  590.                             if (tC == 0) {

    591. 

  591.                                 isWhile = false;

    592. 

  592.                             } else {

    593. 

  593.                                 if (cfg.head._maps[rr][nC] == undefined) {

    594. 

  594.                                     cfg.head._maps[rr][nC] = position;

    595. 

  595.                                     if (startPosition == null) startPosition = nC;

    596. 

  596.                                     tC--;

    597. 

  597.                                 } else {

    598. 

  598.                                     nC++;

    599. 

  599.                                 }

    600. 

  600.                             }

    601. 

  601.                         } catch (e) {

    602. 

  602.                             isWhile = false;

    603. 

  603.                         }

    604. 

  604.                     }

    605. 

  605.                 }

    606. 

  606.             };

    607. 

  607.             for (var r = 0; r < cfg.head.rows.length; r++) {

    608. 

  608.                 for (var CH, CHidx = 0, __arr = cfg.head.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    609. 

  609.                     if (CH.colSeq != undefined) {

    610. 

  610.                         var myCG = cfg.colGroup.getToSeq(CH.colSeq);

    611. 

  611.                     } else {

    612. 

  612.                         var myCG = cfg.colGroup.searchObject(function () {

    613. 

  613.                             return this.item.key == CH.key;

    614. 

  614.                         }).first();

    615. 

  615.                     }

    616. 

  616. 

    617. 

  617.                     if (myCG != null) {

    618. 

  618.                         AXUtil.overwriteObject(CH, myCG, false);

    619. 

  619.                     } else {

    620. 

  620.                         AXUtil.overwriteObject(CH, { align: "left", valign: "bottom", display: true, rowspan: 1, colspan: 1 }, false);

    621. 

  621.                     }

    622. 

  622.                     appendPosToHeadMap(CH.rowspan, CH.colspan, r, { r: r, c: CHidx });

    623. 

  623.                 }

    624. 

  624. 

    625. 

  625.             }

    626. 

  626. 

    627. 

  627.             /*colHead._maps 마지막 줄에 해당하는 cfg.colHead.rows 에 속성부여 */

    628. 

  628.             for (var m, midx = 0, __arr = cfg.head._maps.last(); (midx < __arr.length && (m = __arr[midx])); midx++) {

    629. 

  629.                 if (m) cfg.head.rows[m.r][m.c].isLastCell = true;

    630. 

  630.             }

    631. 

  631. 

    632. 

  632. 

    633. 

  633.             if (hasHiddenCell) { /* colGroup 중에 숨겨진 col 이 존재하는 경우 */

    634. 

  634.                 /* colspan 감소 시키기 */

    635. 

  635.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    636. 

  636.                     if (!CG.display) {

    637. 

  637.                         for (var a = 0; a < cfg.head._maps.length; a++) {

    638. 

  638.                             var rowPosition = cfg.head._maps[a][cidx];

    639. 

  639.                             cfg.head.rows[rowPosition.r][rowPosition.c].colspan--;

    640. 

  640.                         }

    641. 

  641.                     }

    642. 

  642.                 }

    643. 

  643.             }

    644. 

  644.         }

    645. 

  645.         /*head 관련 데이터 정리 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    646. 

  646. 

    647. 

  647.         /*foot 관련 데이터 정리 */

    648. 

  648.         if (cfg.foot) {

    649. 

  649.             cfg.foot._maps = new Array(cfg.foot.rows.length);

    650. 

  650.             colMaxLen = 0;

    651. 

  651.             for (var r = 0; r < cfg.foot.rows.length; r++) {

    652. 

  652.                 var colLen = 0;

    653. 

  653.                 for (var CH, CHidx = 0, __arr = cfg.foot.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    654. 

  654.                     if (CH.rowspan == undefined || CH.rowspan == null) CH.rowspan = 1;

    655. 

  655.                     if (CH.colspan == undefined || CH.colspan == null) {

    656. 

  656.                         CH.colspan = 1;

    657. 

  657.                         CH._colspan = 1;

    658. 

  658.                     } else {

    659. 

  659.                         if (!rewrite) CH._colspan = CH.colspan;

    660. 

  660.                         else CH.colspan = CH._colspan;

    661. 

  661.                     }

    662. 

  662.                     if (CH.valign == undefined || CH.valign == null) CH.valign = "bottom";

    663. 

  663.                     colLen += CH.colspan.number();

    664. 

  664.                 }

    665. 

  665. 

    666. 

  666.                 if (colMaxLen < colLen) colMaxLen = colLen;

    667. 

  667.             }

    668. 

  668.             for (var _m = 0; _m < cfg.foot._maps.length; _m++) {

    669. 

  669.                 cfg.foot._maps[_m] = new Array(colMaxLen);

    670. 

  670.             }

    671. 

  671.             /* colEndPosition 관련 처리 함수 */

    672. 

  672.             var appendPosToFootMap = function (r, c, posR, position) {

    673. 

  673.                 var nC = position.c;

    674. 

  674.                 /*시작 컬럼 위치 */

    675. 

  675.                 var startPosition = null;

    676. 

  676.                 for (var rr = posR; rr < (posR + r); rr++) {

    677. 

  677.                     if (r > 1) if (rr > 0 && startPosition != null) nC = startPosition;

    678. 

  678.                     var tC = c;

    679. 

  679.                     var isWhile = true;

    680. 

  680.                     while (isWhile) {

    681. 

  681.                         try {

    682. 

  682.                             if (tC == 0) {

    683. 

  683.                                 isWhile = false;

    684. 

  684.                             } else {

    685. 

  685.                                 if (cfg.foot._maps[rr][nC] == undefined) {

    686. 

  686.                                     cfg.foot._maps[rr][nC] = position;

    687. 

  687.                                     if (startPosition == null) startPosition = nC;

    688. 

  688.                                     tC--;

    689. 

  689.                                 } else {

    690. 

  690.                                     nC++;

    691. 

  691.                                 }

    692. 

  692.                             }

    693. 

  693.                         } catch (e) {

    694. 

  694.                             isWhile = false;

    695. 

  695.                         }

    696. 

  696.                     }

    697. 

  697.                 }

    698. 

  698.             };

    699. 

  699.             for (var r = 0; r < cfg.foot.rows.length; r++) {

    700. 

  700.                 for (var CH, CHidx = 0, __arr = cfg.foot.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    701. 

  701.                     if (CH.colSeq != undefined) {

    702. 

  702.                         var myCG = cfg.colGroup.getToSeq(CH.colSeq);

    703. 

  703.                     } else {

    704. 

  704.                         var myCG = cfg.colGroup.searchObject(function () {

    705. 

  705.                             return this.item.key == CH.key;

    706. 

  706.                         }).first();

    707. 

  707.                     }

    708. 

  708. 

    709. 

  709.                     if (myCG != null) {

    710. 

  710.                         AXUtil.overwriteObject(CH, myCG, false);

    711. 

  711.                     } else {

    712. 

  712.                         AXUtil.overwriteObject(CH, { align: "left", valign: "bottom", display: true, rowspan: 1, colspan: 1 }, false);

    713. 

  713.                     }

    714. 

  714.                     appendPosToFootMap(CH.rowspan, CH.colspan, r, { r: r, c: CHidx });

    715. 

  715.                 }

    716. 

  716. 

    717. 

  717.             }

    718. 

  718.             /*colHead._maps 마지막 줄에 해당하는 cfg.colHead.rows 에 속성부여 */

    719. 

  719.             for (var m, midx = 0, __arr = cfg.foot._maps.last(); (midx < __arr.length && (m = __arr[midx])); midx++) {

    720. 

  720.                 if (m) cfg.foot.rows[m.r][m.c].isLastCell = true;

    721. 

  721.             }

    722. 

  722. 

    723. 

  723. 

    724. 

  724.             if (hasHiddenCell) { /* colGroup 중에 숨겨진 col 이 존재하는 경우 */

    725. 

  725.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    726. 

  726.                     if (!CG.display) {

    727. 

  727.                         for (var a = 0; a < cfg.foot._maps.length; a++) {

    728. 

  728.                             var rowPosition = cfg.foot._maps[a][cidx];

    729. 

  729.                             cfg.foot.rows[rowPosition.r][rowPosition.c].colspan--;

    730. 

  730.                         }

    731. 

  731.                     }

    732. 

  732.                 }

    733. 

  733. 

    734. 

  734.             }

    735. 

  735.         }

    736. 

  736.         /*foot 관련 데이터 정리 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    737. 

  737. 

    738. 

  738.         /*editor 관련 데이터 정리 */

    739. 

  739.         if (cfg.editor) {

    740. 

  740.             if (cfg.editor.rows) {

    741. 

  741.                 this.hasEditor = true;

    742. 

  742.                 cfg.editor._maps = new Array(cfg.editor.rows.length);

    743. 

  743.                 colMaxLen = 0;

    744. 

  744.                 for (var r = 0; r < cfg.editor.rows.length; r++) {

    745. 

  745.                     var colLen = 0;

    746. 

  746.                     for (var CH, CHidx = 0, __arr = cfg.editor.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    747. 

  747.                         if (CH) {

    748. 

  748.                             if (CH.rowspan == undefined || CH.rowspan == null) CH.rowspan = 1;

    749. 

  749.                             if (CH.colspan == undefined || CH.colspan == null) {

    750. 

  750.                                 CH.colspan = 1;

    751. 

  751.                                 CH._colspan = 1;

    752. 

  752.                             } else {

    753. 

  753.                                 if (!rewrite) CH._colspan = CH.colspan;

    754. 

  754.                                 else CH.colspan = CH._colspan;

    755. 

  755.                             }

    756. 

  756.                             if (CH.valign == undefined || CH.valign == null) CH.valign = "bottom";

    757. 

  757.                             colLen += CH.colspan.number();

    758. 

  758.                         }

    759. 

  759.                     }

    760. 

  760. 

    761. 

  761.                     if (colMaxLen < colLen) colMaxLen = colLen;

    762. 

  762.                 }

    763. 

  763.                 for (var _m = 0; _m < cfg.editor._maps.length; _m++) {

    764. 

  764.                     cfg.editor._maps[_m] = new Array(colMaxLen);

    765. 

  765.                 }

    766. 

  766.                 /* colEndPosition 관련 처리 함수 */

    767. 

  767.                 var appendPosToEditorMap = function (r, c, posR, position) {

    768. 

  768.                     var nC = position.c;

    769. 

  769.                     var startPosition = null;

    770. 

  770.                     for (var rr = posR; rr < (posR + r); rr++) {

    771. 

  771.                         var tC = c;

    772. 

  772.                         var isWhile = true;

    773. 

  773.                         while (isWhile) {

    774. 

  774.                             try {

    775. 

  775.                                 if (tC == 0) {

    776. 

  776.                                     isWhile = false;

    777. 

  777.                                 } else {

    778. 

  778.                                     if (cfg.editor._maps[rr][nC] == undefined) {

    779. 

  779.                                         cfg.editor._maps[rr][nC] = position;

    780. 

  780.                                         if (startPosition == null) startPosition = nC;

    781. 

  781.                                         tC--;

    782. 

  782.                                     } else {

    783. 

  783.                                         nC++;

    784. 

  784.                                     }

    785. 

  785.                                 }

    786. 

  786.                             } catch (e) {

    787. 

  787.                                 isWhile = false;

    788. 

  788.                             }

    789. 

  789.                         }

    790. 

  790.                     }

    791. 

  791.                 };

    792. 

  792.                 for (var r = 0; r < cfg.editor.rows.length; r++) {

    793. 

  793.                     for (var CH, CHidx = 0, __arr = cfg.editor.rows[r]; (CHidx < __arr.length && (CH = __arr[CHidx])); CHidx++) {

    794. 

  794.                         if (CH) {

    795. 

  795.                             if (CH.colSeq != undefined) {

    796. 

  796.                                 var myCG = cfg.colGroup.getToSeq(CH.colSeq);

    797. 

  797.                             } else {

    798. 

  798.                                 var myCG = cfg.colGroup.searchObject(function () {

    799. 

  799.                                     return this.item.key == CH.key;

    800. 

  800.                                 }).first();

    801. 

  801.                             }

    802. 

  802.                             if (myCG != null) {

    803. 

  803.                                 AXUtil.overwriteObject(CH, myCG, false);

    804. 

  804.                             } else {

    805. 

  805.                                 AXUtil.overwriteObject(CH, { align: "left", valign: "bottom", display: true, rowspan: 1, colspan: 1 }, false);

    806. 

  806.                             }

    807. 

  807.                             appendPosToEditorMap(CH.rowspan, CH.colspan, r, { r: r, c: CHidx });

    808. 

  808.                         }

    809. 

  809.                     }

    810. 

  810. 

    811. 

  811.                 }

    812. 

  812. 

    813. 

  813.                 for (var m, midx = 0, __arr = cfg.editor._maps.last(); (midx < __arr.length && (m = __arr[midx])); midx++) {

    814. 

  814.                     if (m) cfg.editor.rows[m.r][m.c].isLastCell = true;

    815. 

  815.                 }

    816. 

  816. 

    817. 

  817. 

    818. 

  818.                 if (hasHiddenCell) {

    819. 

  819.                     for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    820. 

  820.                         if (!CG.display) {

    821. 

  821.                             for (var a = 0; a < cfg.editor._maps.length; a++) {

    822. 

  822.                                 var rowPosition = cfg.editor._maps[a][cidx];

    823. 

  823.                                 cfg.editor.rows[rowPosition.r][rowPosition.c].colspan--;

    824. 

  824.                             }

    825. 

  825.                         }

    826. 

  826.                     }

    827. 

  827. 

    828. 

  828.                 }

    829. 

  829.             }

    830. 

  830.         }

    831. 

  831. 

    832. 

  832.         /*editor 관련 데이터 정리 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */

    833. 

  833. 

    834. 

  834.         /*fixedColSeq가 설정된 경우 */

    835. 

  835.         if (cfg.fixedColSeq != undefined && cfg.fixedColSeq != null) {

    836. 

  836. 

    837. 

  837.             var fixedColSeq = this.fixedColSeq;

    838. 

  838. 

    839. 

  839.             for (var m, midx = 0, __arr = cfg.colHead._maps; (midx < __arr.length && (m = __arr[midx])); midx++) {

    840. 

  840.                 for (var c, cidx = 0, __arr2 = m; (cidx < __arr2.length && (c = __arr2[cidx])); cidx++) {

    841. 

  841.                     if (c) {

    842. 

  842.                         if ((fixedColSeq + 1) > cidx) cfg.colHead.rows[c.r][c.c].isFixedCell = true;

    843. 

  843.                     }

    844. 

  844.                 }

    845. 

  845. 

    846. 

  846.             }

    847. 

  847. 

    848. 

  848. 

    849. 

  849.             for (var m, midx = 0, __arr = cfg.body._maps; (midx < __arr.length && (m = __arr[midx])); midx++) {

    850. 

  850.                 for (var c, cidx = 0, __arr2 = m; (cidx < __arr2.length && (c = __arr2[cidx])); cidx++) {

    851. 

  851.                     if (c) {

    852. 

  852.                         if (fixedColSeq == cidx) cfg.body.rows[c.r][c.c].isFixedEndCell = true;

    853. 

  853.                         if ((fixedColSeq + 1) > cidx) cfg.body.rows[c.r][c.c].isFixedCell = true;

    854. 

  854.                     }

    855. 

  855.                 }

    856. 

  856. 

    857. 

  857.             }

    858. 

  858. 

    859. 

  859.             if (cfg.head) {

    860. 

  860.                 for (var m, midx = 0, __arr = cfg.head._maps; (midx < __arr.length && (m = __arr[midx])); midx++) {

    861. 

  861.                     for (var c, cidx = 0, __arr2 = m; (cidx < __arr2.length && (c = __arr2[cidx])); cidx++) {

    862. 

  862.                         if (c) {

    863. 

  863.                             if (fixedColSeq == cidx) cfg.head.rows[c.r][c.c].isFixedEndCell = true;

    864. 

  864.                             if ((fixedColSeq + 1) > cidx) cfg.head.rows[c.r][c.c].isFixedCell = true;

    865. 

  865.                         }

    866. 

  866.                     }

    867. 

  867. 

    868. 

  868.                 }

    869. 

  869. 

    870. 

  870.             }

    871. 

  871.             if (cfg.foot) {

    872. 

  872.                 for (var m, midx = 0, __arr = cfg.foot._maps; (midx < __arr.length && (m = __arr[midx])); midx++) {

    873. 

  873.                     for (var c, cidx = 0, __arr2 = m; (cidx < __arr2.length && (c = __arr2[cidx])); cidx++) {

    874. 

  874.                         if (c) {

    875. 

  875.                             if (fixedColSeq == cidx) cfg.foot.rows[c.r][c.c].isFixedEndCell = true;

    876. 

  876.                             if ((fixedColSeq + 1) > cidx) cfg.foot.rows[c.r][c.c].isFixedCell = true;

    877. 

  877.                         }

    878. 

  878.                     }

    879. 

  879. 

    880. 

  880.                 }

    881. 

  881. 

    882. 

  882.             }

    883. 

  883. 

    884. 

  884.             if (cfg.body.marker) {

    885. 

  885.                 if (cfg.body.marker.rows) {

    886. 

  886.                     for (var m, midx = 0, __arr = cfg.body.marker._maps; (midx < __arr.length && (m = __arr[midx])); midx++) {

    887. 

  887.                         for (var c, cidx = 0, __arr2 = m; (cidx < __arr2.length && (c = __arr2[cidx])); cidx++) {

    888. 

  888.                             if (c) {

    889. 

  889.                                 if (fixedColSeq == cidx) cfg.body.marker.rows[c.r][c.c].isFixedEndCell = true;

    890. 

  890.                                 if ((fixedColSeq + 1) > cidx) cfg.body.marker.rows[c.r][c.c].isFixedCell = true;

    891. 

  891.                             }

    892. 

  892.                         }

    893. 

  893. 

    894. 

  894.                     }

    895. 

  895. 

    896. 

  896.                 }

    897. 

  897.             }

    898. 

  898. 

    899. 

  899.             if (cfg.editor) {

    900. 

  900.                 if (cfg.editor.rows) {

    901. 

  901.                     for (var m, midx = 0, __arr = cfg.editor._maps; (midx < __arr.length && (m = __arr[midx])); midx++) {

    902. 

  902.                         for (var c, cidx = 0, __arr2 = m; (cidx < __arr2.length && (c = __arr2[cidx])); cidx++) {

    903. 

  903.                             if (c) {

    904. 

  904.                                 if (fixedColSeq == cidx) cfg.editor.rows[c.r][c.c].isFixedEndCell = true;

    905. 

  905.                                 if ((fixedColSeq + 1) > cidx) cfg.editor.rows[c.r][c.c].isFixedCell = true;

    906. 

  906.                             }

    907. 

  907.                         }

    908. 

  908. 

    909. 

  909.                     }

    910. 

  910. 

    911. 

  911.                 }

    912. 

  912.             }

    913. 

  913.             this.hasFixed = true;

    914. 

  914.             if (hasHiddenCell) {

    915. 

  915.                 var minusFixedCol = 0;

    916. 

  916.                 var fixedColSeq = this.fixedColSeq;

    917. 

  917.                 for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    918. 

  918.                     if (!CG.display) {

    919. 

  919.                         if ((fixedColSeq + 1) > cidx) minusFixedCol++;

    920. 

  920.                     }

    921. 

  921.                 }

    922. 

  922. 

    923. 

  923.                 cfg.fixedColSeq = this.fixedColSeq - minusFixedCol;

    924. 

  924.             } else {

    925. 

  925.                 cfg.fixedColSeq = this.fixedColSeq;

    926. 

  926.             }

    927. 

  927. 

    928. 

  928.             if (cfg.fixedColSeq == -1) {

    929. 

  929.                 /*fixed 제거*/

    930. 

  930.                 this.hasFixed = false;

    931. 

  931.             }

    932. 

  932. 

    933. 

  933.             var fixedColSeq = this.fixedColSeq, fixedColWidth = 0;

    934. 

  934.             for (var CG, cidx = 0, __arr = cfg.colGroup; (cidx < __arr.length && (CG = __arr[cidx])); cidx++) {

    935. 

  935.                 if (CG.display && cidx < (fixedColSeq + 1)) {

    936. 

  936.                     fixedColWidth += CG.width.number();

    937. 

  937.                 }

    938. 

  938.             }

    939. 

  939. 

    940. 

  940.             this.fixedColWidth = fixedColWidth;

    941. 

  941.         }

    942. 

  942.     },

    943. 

  943.     init: function () {

    944. 

  944.         var cfg = this.config;

    945. 

  945. 

    946. 

  946.         if (Object.isUndefined(cfg.targetID)) {

    947. 

  947.             trace("need targetID - setConfig({targetID:''})");

    948. 

  948.             return;

    949. 

  949.         }

    950. 

  950.         if (!cfg.colGroup) {

    951. 

  951.             trace("need colGroup - setConfig({colGroup:[]})");

    952. 

  952.             return;

    953. 

  953.         }

    954. 

  954. 

    955. 

  955.         cfg.emptyListMSG = cfg.emptyListMSG || AXConfig.AXGrid.emptyListMSG;

    956. 

  956.         cfg.listCountMSG = cfg.listCountMSG || AXConfig.AXGrid.listCountMSG || "전체 <b>{listCount}</b>개의 목록이 있습니다.";

    957. 

  957.         cfg.pageCountMSG = cfg.pageCountMSG || AXConfig.AXGrid.pageCountMSG;

    958. 

  958. 

    959. 

  959.         /*

    960. 

  960.          cfg.viewMode 결정 구간.

    961. 

  961.          */

    962. 

  962. 

    963. 

  963.         if (cfg.mediaQuery) {

    964. 

  964.             var _viewMode = "", clientWidth = axf.clientWidth();

    965. 

  965.             axf.each(cfg.mediaQuery, function (k, v) {

    966. 

  966.                 if (Object.isObject(v)) {

    967. 

  967. 

    968. 

  968.                     if(v.min != undefined && v.max != undefined){

    969. 

  969.                         if (v.min <= clientWidth && clientWidth <= v.max) {

    970. 

  970.                             _viewMode = (k == "dx") ? "grid" : "mobile";

    971. 

  971.                             return false;

    972. 

  972.                         }

    973. 

  973.                     }else{

    974. 

  974.                         if (v.min <= clientWidth) {

    975. 

  975.                             _viewMode = (k == "dx") ? "grid" : "mobile";

    976. 

  976.                             return false;

    977. 

  977.                         }

    978. 

  978.                     }

    979. 

  979.                 }

    980. 

  980.             });

    981. 

  981.             if (_viewMode != "") {

    982. 

  982.                 cfg.viewMode = _viewMode;

    983. 

  983.             }

    984. 

  984.         }

    985. 

  985. 

    986. 

  986. 

    987. 

  987.         if (Object.isObject(cfg.colGroup)) {

    988. 

  988.             var newColGroup = cfg.colGroup.concat();

    989. 

  989.             cfg.colGroup = newColGroup;

    990. 

  990.         }

    991. 

  991. 

    992. 

  992.         this.target = axdom("#" + cfg.targetID);

    993. 

  993. 

    994. 

  994.         var targetInnerHeight = this.target.innerHeight();

    995. 

  995.         if (targetInnerHeight == 0) targetInnerHeight = (AXConfig.AXGrid.pageHeight || 400);

    996. 

  996.         this.theme = (cfg.theme) ? cfg.theme : "AXGrid";

    997. 

  997.         /* 테마기본값 지정*/

    998. 

  998.         cfg.height = (cfg.height) ? cfg.height : targetInnerHeight + "px";

    999. 

  999.         /* 그리드 높이 지정 */

    1000. 

  1000. 

    1001. 

  1001. 

    1002. 

  1002.         var theme = this.theme;

    1003. 

  1003.         var gridCss = [];

    1004. 

  1004.         if (cfg.width) gridCss.push("width:" + cfg.width + ";");

    1005. 

  1005.         if (cfg.height) gridCss.push("height:" + cfg.height + ";");

    1006. 

  1006. 

    1007. 

  1007.         /* grid 뼈대 그리기 ----------------------------------------------------------------------------------------------------- */

    1008. 

  1008.         var ol = [];

    1009. 

  1009.         ol.push("<div class=\"" + theme + "\" id=\"" + cfg.targetID + "_AX_grid\" style=\"" + gridCss.join('') + "\">");

    1010. 

  1010.         ol.push("	<div class=\"AXgridScrollBody\" id=\"" + cfg.targetID + "_AX_gridScrollBody\" style=\"z-index:2;\">");

    1011. 

  1011.         ol.push("		<div class=\"AXGridColHead AXUserSelectNone\" id=\"" + cfg.targetID + "_AX_gridColHead\" onselectstart=\"return false;\"></div>");

    1012. 

  1012.         ol.push("		<div class=\"AXGridToolGroup top\" id=\"" + cfg.targetID + "_AX_gridToolGroupTop\"></div>");

    1013. 

  1013.         ol.push("		<div class=\"AXGridBody\" id=\"" + cfg.targetID + "_AX_gridBody\"></div>");

    1014. 

  1014.         ol.push("		<div cla…
    1015.