From c1bc39976ee45e165bfff0267eaa2bfc91a03136 Mon Sep 17 00:00:00 2001 From: Rushabh Mehta Date: Wed, 7 Mar 2012 18:19:49 +0530 Subject: [PATCH] new listing and changed wn.widgets.listing to wn.ui.listing --- conf/index.html | 1 + css/legacy/body.css | 2 +- css/legacy/final.css | 0 css/ui/{filter.css => list.css} | 31 +- js/legacy/widgets/listing.js | 2 +- js/lib/slickgrid/images/actions.gif | Bin 0 -> 170 bytes js/lib/slickgrid/images/ajax-loader-small.gif | Bin 0 -> 1849 bytes js/lib/slickgrid/images/arrow_redo.png | Bin 0 -> 625 bytes .../images/arrow_right_peppermint.png | Bin 0 -> 240 bytes .../images/arrow_right_spearmint.png | Bin 0 -> 240 bytes js/lib/slickgrid/images/arrow_undo.png | Bin 0 -> 631 bytes js/lib/slickgrid/images/bullet_blue.png | Bin 0 -> 289 bytes js/lib/slickgrid/images/bullet_star.png | Bin 0 -> 347 bytes .../slickgrid/images/bullet_toggle_minus.png | Bin 0 -> 207 bytes .../slickgrid/images/bullet_toggle_plus.png | Bin 0 -> 209 bytes js/lib/slickgrid/images/calendar.gif | Bin 0 -> 1035 bytes js/lib/slickgrid/images/collapse.gif | Bin 0 -> 846 bytes js/lib/slickgrid/images/comment_yellow.gif | Bin 0 -> 257 bytes js/lib/slickgrid/images/down.gif | Bin 0 -> 59 bytes js/lib/slickgrid/images/drag-handle.png | Bin 0 -> 1223 bytes js/lib/slickgrid/images/editor-helper-bg.gif | Bin 0 -> 1164 bytes js/lib/slickgrid/images/expand.gif | Bin 0 -> 851 bytes js/lib/slickgrid/images/header-bg.gif | Bin 0 -> 872 bytes js/lib/slickgrid/images/header-columns-bg.gif | Bin 0 -> 836 bytes .../images/header-columns-over-bg.gif | Bin 0 -> 823 bytes js/lib/slickgrid/images/help.png | Bin 0 -> 510 bytes js/lib/slickgrid/images/info.gif | Bin 0 -> 80 bytes js/lib/slickgrid/images/listview.gif | Bin 0 -> 2380 bytes js/lib/slickgrid/images/pencil.gif | Bin 0 -> 914 bytes js/lib/slickgrid/images/row-over-bg.gif | Bin 0 -> 823 bytes js/lib/slickgrid/images/sort-asc.gif | Bin 0 -> 830 bytes js/lib/slickgrid/images/sort-asc.png | Bin 0 -> 163 bytes js/lib/slickgrid/images/sort-desc.gif | Bin 0 -> 833 bytes js/lib/slickgrid/images/sort-desc.png | Bin 0 -> 161 bytes js/lib/slickgrid/images/stripes.png | Bin 0 -> 1238 bytes js/lib/slickgrid/images/tag_red.png | Bin 0 -> 592 bytes js/lib/slickgrid/images/tick.png | Bin 0 -> 537 bytes js/lib/slickgrid/images/user_identity.gif | Bin 0 -> 905 bytes .../slickgrid/images/user_identity_plus.gif | Bin 0 -> 546 bytes js/lib/slickgrid/jquery.event.drag.min.js | 6 + js/lib/slickgrid/slick-default-theme.css | 295 ++ js/lib/slickgrid/slick.core.js | 424 +++ js/lib/slickgrid/slick.grid.css | 158 + js/lib/slickgrid/slick.grid.js | 2799 +++++++++++++++++ js/wn/pages/doclistview.js | 341 +- js/wn/ui/listing.js | 644 +++- py/webnotes/widgets/doclistview.py | 2 +- 47 files changed, 4258 insertions(+), 447 deletions(-) create mode 100644 css/legacy/final.css rename css/ui/{filter.css => list.css} (78%) create mode 100644 js/lib/slickgrid/images/actions.gif create mode 100644 js/lib/slickgrid/images/ajax-loader-small.gif create mode 100644 js/lib/slickgrid/images/arrow_redo.png create mode 100644 js/lib/slickgrid/images/arrow_right_peppermint.png create mode 100644 js/lib/slickgrid/images/arrow_right_spearmint.png create mode 100644 js/lib/slickgrid/images/arrow_undo.png create mode 100644 js/lib/slickgrid/images/bullet_blue.png create mode 100644 js/lib/slickgrid/images/bullet_star.png create mode 100644 js/lib/slickgrid/images/bullet_toggle_minus.png create mode 100644 js/lib/slickgrid/images/bullet_toggle_plus.png create mode 100644 js/lib/slickgrid/images/calendar.gif create mode 100644 js/lib/slickgrid/images/collapse.gif create mode 100644 js/lib/slickgrid/images/comment_yellow.gif create mode 100644 js/lib/slickgrid/images/down.gif create mode 100644 js/lib/slickgrid/images/drag-handle.png create mode 100644 js/lib/slickgrid/images/editor-helper-bg.gif create mode 100644 js/lib/slickgrid/images/expand.gif create mode 100644 js/lib/slickgrid/images/header-bg.gif create mode 100644 js/lib/slickgrid/images/header-columns-bg.gif create mode 100644 js/lib/slickgrid/images/header-columns-over-bg.gif create mode 100644 js/lib/slickgrid/images/help.png create mode 100644 js/lib/slickgrid/images/info.gif create mode 100644 js/lib/slickgrid/images/listview.gif create mode 100644 js/lib/slickgrid/images/pencil.gif create mode 100644 js/lib/slickgrid/images/row-over-bg.gif create mode 100644 js/lib/slickgrid/images/sort-asc.gif create mode 100644 js/lib/slickgrid/images/sort-asc.png create mode 100644 js/lib/slickgrid/images/sort-desc.gif create mode 100644 js/lib/slickgrid/images/sort-desc.png create mode 100644 js/lib/slickgrid/images/stripes.png create mode 100644 js/lib/slickgrid/images/tag_red.png create mode 100644 js/lib/slickgrid/images/tick.png create mode 100644 js/lib/slickgrid/images/user_identity.gif create mode 100644 js/lib/slickgrid/images/user_identity_plus.gif create mode 100644 js/lib/slickgrid/jquery.event.drag.min.js create mode 100644 js/lib/slickgrid/slick-default-theme.css create mode 100644 js/lib/slickgrid/slick.core.js create mode 100644 js/lib/slickgrid/slick.grid.css create mode 100644 js/lib/slickgrid/slick.grid.js diff --git a/conf/index.html b/conf/index.html index 65cb220712..fae62bdc0f 100644 --- a/conf/index.html +++ b/conf/index.html @@ -26,6 +26,7 @@ } {% endif %} + diff --git a/css/legacy/body.css b/css/legacy/body.css index ed8686872f..df77e1fd41 100644 --- a/css/legacy/body.css +++ b/css/legacy/body.css @@ -235,4 +235,4 @@ div.std-footer-item { height: 24px; margin-bottom: -7px; max-width: 24px; -} +} \ No newline at end of file diff --git a/css/legacy/final.css b/css/legacy/final.css new file mode 100644 index 0000000000..e69de29bb2 diff --git a/css/ui/filter.css b/css/ui/list.css similarity index 78% rename from css/ui/filter.css rename to css/ui/list.css index d3ae112ad2..243d40399b 100644 --- a/css/ui/filter.css +++ b/css/ui/list.css @@ -1,3 +1,26 @@ +.hide { + display: none; +} + +.list-filters { + margin: 7px 0px; +} + +.wnlist .img-load { + display: none; + float: left; + margin-left: 11px; + margin-top: 8px; +} + +div.list-row { + border-bottom: 1px solid #eee; + padding: 3px 0px; +} +div.list-row:hover { + background-color: #eef +} + div.show_filters { display: none; } @@ -8,7 +31,7 @@ div.filter_list { div.show_filters.well { margin-top: 11px; - margin-bottom: 0px; + margin-bottom: 11px; } div.filter_list .run_btn { @@ -46,9 +69,3 @@ span.bar-inner { span.bar-complete { background-color: green; } -div.list-row { - border-bottom: 1px solid #eee; -} -div.list-row:hover { - background-color: #eef -} \ No newline at end of file diff --git a/js/legacy/widgets/listing.js b/js/legacy/widgets/listing.js index 7b7d4295cb..add4557c4d 100644 --- a/js/legacy/widgets/listing.js +++ b/js/legacy/widgets/listing.js @@ -23,7 +23,7 @@ // Listing // this listing object will soon be // deprecated because it has a very non standard way of creation -// the new listing object is at wn.widgets.Listing +// the new listing object is at wn.ui.Listing // ----------------------- list_opts = { diff --git a/js/lib/slickgrid/images/actions.gif b/js/lib/slickgrid/images/actions.gif new file mode 100644 index 0000000000000000000000000000000000000000..026dd108edb433b2592695258f5a26fead66a7bf GIT binary patch literal 170 zcmV;b09F4-Nk%w1VG{ro0HOx~|NsBFxw+Wb*vQDp?Ck8An3!f}X8-^HA^8LW000L7 zEC2ui022Tc000ATcq&u=F9=14Bp_=*L>SeujoScvWSU8mntBE1j)XI(_C4mS;s1uf zhSviMhXoE{2?+d-ON=ebbPB1`WJl1!Tm@h-z_A1mz|k1KkDxg* Yaq4(_7$y}LDRLkb2QUy25)=slJ8Q{ByZ`_I literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/ajax-loader-small.gif b/js/lib/slickgrid/images/ajax-loader-small.gif new file mode 100644 index 0000000000000000000000000000000000000000..5b33f7e54f4e55b6b8774d86d96895db9af044b4 GIT binary patch literal 1849 zcma*odr(tX9tZI2z31lM+(&YVk%mZ}5P~KlG2s=WSbGzm0!x7^P##Mnh7t-jP!X0Q zk_SQ}Po-L1tlDK;6l?(>v)e5ZBQx4|Y-Q?nr@Px3?9h(3ZWr3^tj=`TP57gKr87N$ zp2wWee1GRRCwo_xahnw)5cxNPJbCg2L6DV|6`#+yw6v6!mDS$f9-JvFD^n;GQ&UrZ zzh5jCkByB101O60U0q#p_1BM>Cv-vP?&s4@g_((4_1L=L$(a91)0=J91Gas#R{McE znYG^9*0A5YZ>#;~+Wkn(W5B0^yELIYLP!K}mB~<)AM@1&nqekynuaEGqPrzoH|KodRXJy)%+w_fu3nE5>@Bd_b zqC$EQ;{c`T&?EsNO|igL9gC7Ygxv?aQUEXMq?~>wg{EyW;VcJ37CUF#HjrT=KQO_* zS>M9yydXk18D(+QDJ1>r);Lav_uYKp$T?4vr{Q$lTo&pKv^?(>L-)G2*lwH!Ah7k? z7oH<8h-(KTKt5V6$8gF)C7Io&P5=SjTh)=zV=E2EUhQZP##L8S{d%UK>>+y82>+FV+#^BzW7u3F)Bb>=lYQ%%j`F>ASe zo*cw@V#u6T`A2He;70mR(V&iV&-7{qP~=SRf&jm9-T{*ZeZ}$rd0#6c&fLG^xJcf5 z+p<`wJYgW+_s*V{uI$nMB;%8`S_3>PfGOj3Rq}@Cx^+j?rk92fANSFDBYnOqQ>Vdj z)(|$AhP4t&Lb=Gvo2#3Gl%9<=Gv`Mz?Po@P4iLF!x}GUWJICDlFk-hS^Whyh7x~VH z@0vD1>HYD4&e+~yzS*-sFR{9`{QEEZO1zg7>R&7cHts-6j!xHVdA8eI+ZlVzd%`es zJT@$#GX(gvCJ1oJN%yLBK}{V=V;seo;!w|Yte!W1%5qLNFWqvZW>h&IiH+oPT=b@E zPhGzv5=(Un*X>v`>%8h_nj^NdYcE6NHS_ifkCV$*D)Tqrbu`s;<=t<4 zAHNqNV?6(g<1PY-w@#I-WYFViz?9TrkMr)u0g`O`u|>T;k|2sV*YF^punvT;$SuTy{j3Gv)yqD!R_CF>yR)MzmmYS5v+~R zXAdD%ng9?df;wd8GxR#%3O+gz};Vo;)sK%Bj-q>Oq%R7JU-KD?vYu>#2UjaDo z&8$>5xW~?KPD_#XFToU1hIb*VOMidUr6iYiO0N|i-7s`T8!cFT`rN!^1Pt78J93i6 z5HI1wIM$94m{3SLDvISDe6$ZG1;eq_D9RTaaC>=cO{@Bs>$IlPCPJJ$h$)-3vzNUQ6OsN#_zWxey!_9%hxwH2_dEJi=yY|1c7nDm2_Lm!Cof8-R_+9UkS zcBE(o47yE)oMR(Q=dp1a2wTX5KvvGyLqlWTa7V&!A*|w|)ax~1_~aJ0=_Lilg*0iQk7#ZD EAHN$8j{pDw literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/arrow_redo.png b/js/lib/slickgrid/images/arrow_redo.png new file mode 100644 index 0000000000000000000000000000000000000000..fdc394c7c59b83cc2b876abc41064c75eb365877 GIT binary patch literal 625 zcmV-%0*?KOP)FZj9*=u@@4&g|7erBn|Ebu&JU%m$={t4j zMA?=F80s{QH%n(hsfF%mohhehBz1^t6ID+NGJzBtYm#sZbA{ZEu?vrT)(Lb!?K~){ zH(Aw`uB}Xq9=*Zczi=_)|A3QuQ}znM~D7~ zjUb95oVKv23l4|e@$lZ*dJFeEA1zqO!B_8JKbXnR;M>>lDE=(2>_dXN zph(~yiDNMRkPr-H-w^rC^iexUih-$vv%Pmt0PmX}J-i9Zx+c*5+ z-=yHc@G$5PV~1*#(6v9VVk{gAIbHG&qW_$xGjJ%d1z0FQe)aR9&Wj`ipjkajT(}$< g3=JnRFfj2j_#0ZN_H7mB0J?_3)78&qol`;+0B}f4I{*Lx literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/arrow_right_spearmint.png b/js/lib/slickgrid/images/arrow_right_spearmint.png new file mode 100644 index 0000000000000000000000000000000000000000..298515ab6c37321d55e17f105cb093d2d984df6b GIT binary patch literal 240 zcmeAS@N?(olHy`uVBq!ia0vp^+#t-s1|(OmDOUqhEa{HEjtmUzPnffIy#(?lOI#yL zg7ec#$`gxH85~pclTsBta}(23gHjVyDhp4h+5i9&PM5rc=s&0F3>*q<0T#-SZTnwEUO1WnG)uy>Q>1|* gDM^8mfklF$^RJbu%hc1sK-VyMy85}Sb4q9e0BIOb6#xJL literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/arrow_undo.png b/js/lib/slickgrid/images/arrow_undo.png new file mode 100644 index 0000000000000000000000000000000000000000..6972c5e5946080ca1dec4de09d9430d3edf6c555 GIT binary patch literal 631 zcmV--0*L*IP)`NY~_X_4^RN+9OmbDu*=G*+_}E z3jR}&gbG0=R0#?Z-=09KI|YP8=#E5@+>uO|=1VUCOole%Li*0J2^Gy8+;b?&km6gg zf;aDGp1r#I_V|We$e$~WifFF9R7MCMwsmwsME9<<@yx?a+v)qKuKbNe>k1{IrVt}k zbbSs~bXr8Se}V_b4opa0GhLA`RHceaP=N}IElbSa8@d(ij1Q|4CvOirm9DX@>Vt8IAj)#jg!+?Z23wnf7d! zNAH#A4i6V)y_WtvZQ1hT)TAWgjoY{t%BOsI;8VOzQvNniDZk5xCy$)UQWb1PRjRoz l1#moJy|?3|{zvx%+MCW^-+4b6gSOJTlY4hP&f-;|-P$*M_2JKlU;gITjZ` z{x5A_(;&5}v4T&aoM|I#fY0yx;$r5+^$jtG$!>-LljTB+Ehjuewo4_`|D~s5}!Bww5usZ rTv^L-ldIQlg2YSCt_73XV;C9C`_J;k2tHT_^f`m4tDnm{r-UW|`Z|OR literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/bullet_toggle_minus.png b/js/lib/slickgrid/images/bullet_toggle_minus.png new file mode 100644 index 0000000000000000000000000000000000000000..b47ce55f685dac56ee9d63f2c3d426bfc4c9e31a GIT binary patch literal 207 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!60wlNoGJgf6SkfJR9T^zbpD<_bdI{u9mbgZg z1m~xflqVLYGB~E>C#5QQ<|d}62BjvZR2H60wE-$h^mK6y(Kw&{<9vg>(S^W+6Zii9 z|Nhthr~iNb*Z!}6uiN$Dz5neG3a-`baBX8yz1H+_;eX)`ni0%X8XBDc-`=Ph(Uan2 zYsR{H!kvIN--9isvHznRsC#5QQ<|d}62BjvZR2H60wE-$h_H=O!(Kw&{<9vg>(S^W+6Zii9 z|Nhthr~iNb*Z!}6uiN$Dz5neG3a-`baBX8yz4q@v|B?28{s)#N@CGn3@%_y|zAV9T z66e<&B4?b6oF&azg|C(V&1ZbI_D}pL`}(^FT2yXwG1Ph~$Q@h8mJYOz!PC{xWt~$( F699+YQR)By literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/calendar.gif b/js/lib/slickgrid/images/calendar.gif new file mode 100644 index 0000000000000000000000000000000000000000..90fd2e17fe247d3252977a0fb5b9e15aa0a513fb GIT binary patch literal 1035 zcmZ?wbhEHb6krfw_|5)@S9f&o11MQ?xO!cw>Iaru@>)1r=M0E4P+ZZ7mII zIULeKgDU;7-PP>>t`%1~&E2Rss zmoK_ev+zRIlAE$=f(b?AOC-O$p6(*{}&|uUzqrRQPTg#DgT!MQR@E+qCNbq%HSb);wrm_poFAqn?eAdp14k-|}?A)@PHqKcBko;gs#qr|o(M^svF)$&Z_>+Z^f#E-c4#;{?o?zg3!SJ6`#$&^S1A0Mo zOd^|}cuZ7utZDF2x^QZKw}f%r8-))i=S!QW?1-3n$c0l#`Co>>jVJxRayDfzPBbdB z@d(x%aio0O$kr>VAGIN%@zD`^9;T^(W-@hfEzoLM$MA{iMIURU+pmy=lUPqr(`R8} zQ7}$#a!{(>!NA06dGg`n cVfH2m1!<$04Gs?(n;)OBm5A{(P++hI0EaJh%K!iX literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/collapse.gif b/js/lib/slickgrid/images/collapse.gif new file mode 100644 index 0000000000000000000000000000000000000000..01e691450c48632dc92a40a8c2b509bf99987225 GIT binary patch literal 846 zcmZ?wbhEHb$FyaIl$)g-gQVfI}k_i-?$k!^A~S3=)P?0Tm31hZvXy UI%HM~I5JIC=Ul}jAi!V^09i~Z*8l(j literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/comment_yellow.gif b/js/lib/slickgrid/images/comment_yellow.gif new file mode 100644 index 0000000000000000000000000000000000000000..df7158a47713eaba957b506048235a44ea204b7e GIT binary patch literal 257 zcmV+c0sj6+Nk%w1VGsZi0K@S*iEN$I#V?9xjA@}>Xoga7rz|MtxP@t*(f zd;jyT|Ma^5_}BT?cIUw`|L>9O(^dcLa{u(R|L~Uo`Rwb_Gym_4@6JNjmm=$!66@0} z+@UAy$58+O|NsC0A^8LW0018VEC2ui01yBW000Gk;3tk`NqT6imL3tk1c6!B=8c}C zdO&j^2-_#;K`k44ofy`glX(f`u%tWsIx;Y9 z?C1WI$jZRL%n;xc;tCX>Hf`FC8#jQAQ7{?;BP|4;Eor|4%qI*bL4LviM>b#x{?4un zjDOAokH}&M2EM}}%y>M1MG8<*vcxr_Bsf2{!~BQ#!ZHk&8dWP+^PJ3Jn5`1R&i~|7I4F^My85}S Ib4q9e0P)5;9smFU literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/editor-helper-bg.gif b/js/lib/slickgrid/images/editor-helper-bg.gif new file mode 100644 index 0000000000000000000000000000000000000000..2daa973bc525c83872e4a0357b756727ca7eaa49 GIT binary patch literal 1164 zcmZ?wbhEHbYF9fS*UcPPtW$y zAC1e8&dfF|PCBwPc)8m=``RLrQxnq8EOwjBBztRfX25cv`Ch$VTVDjNcFA@+x-0Z` z$h!EwVWQk+I+s?bT%LD!*S7528}iR;rCMLljonfHbWv~gw)MC6)cyQ-m%G9s_D~1E z_O{tGJ|^wyRkXimZCQ|baE5+%pU=&W=_lt~H_Pen+LC&1xwbUl+*x0Syf|Ke-=FW_A3xmP?_a;~@8`E4XYbdGudo02^{2Q(!*@ZAgvM7- z(;qZ(zPtXQo}W)bvFVLvgkp=h*9^s0F29Ng?L2uLi`o^-G?F^SX01r-(n;F!s9yG{ Q#^WB7YZ;4s85tR@0d|1E6951J literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/expand.gif b/js/lib/slickgrid/images/expand.gif new file mode 100644 index 0000000000000000000000000000000000000000..1b24ef1248de55c6140895f6760758a1579f14cf GIT binary patch literal 851 zcmZ?wbhEHb$FyaIl$)g-gPK!J(0fMMMlpH!w1DF=kxpFl=aGX3~-h X>0od?I!Q%XL14k81*aJp85yhr3QsCm literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/header-bg.gif b/js/lib/slickgrid/images/header-bg.gif new file mode 100644 index 0000000000000000000000000000000000000000..fe7dd1c1ebedc02d4e1aabf91fe43e1bcae824e7 GIT binary patch literal 872 zcmZ?wbhEHbWMt4`Y-eC-S#V_a@i#lpzuR@;-JVPD_g;R#|H_AhS3exO_Tk8lkH>C) zJaOyO$=jb!-~D{{-ski8KVNw8<p u#Ky(P`xTtKWIQ)5IXPLwHYwudrlqH+8zi5a#gWNI1yM!7mYUVnf4WCKe8!85Rx=4Ga>@3=9GS G4Auam1ttan literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/header-columns-over-bg.gif b/js/lib/slickgrid/images/header-columns-over-bg.gif new file mode 100644 index 0000000000000000000000000000000000000000..f9c07af1347fc44dcabb1a9d22458deb195fd92b GIT binary patch literal 823 zcmZ?wbhEHbWMU9wXlGzpb>`d67r$SB{>v~5Mnhoag@EEu7NDp9Gw6W44$2b@93l*? Z95Nmo7Bnz$2y4ZhC{SczU}R*l1^^j55kLR{ literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/help.png b/js/lib/slickgrid/images/help.png new file mode 100644 index 0000000000000000000000000000000000000000..0eff0a5cb58f8d3478a23ffc5a39abcc03763ae8 GIT binary patch literal 510 zcmV7!c@t%Q;hm#>P z*^NPxS3gKuS@{l7aT6mW<9C1nVgeH0pME?A+VGD-R#BWGDbJVT&C3s9K1iIOpWh9r zm>Xm|KmdUh8-Dx!mH`9|OjQ}`3+6BwnyZ2NAaO1(E|4=gfS3g!fS7>py}-pP%m4$a z1%3?HPI_QANF3mXBsm=Pd=n125Jxr2{Gnt_p#39R7Qfh%Ad#0QB#dGh2Ckoy;i z{{sXN)4O-?mazO4TnF?F0}q=RLqwu0myv6~YMg-b(ohdF0R#{uDExq)WQKZz8%i@ntp=I+6+{Eo z{RIdhuwsZC!HxzgVgYeMZiHI>_dh5cfdC-D04Px#07*qoM6N<$f)Ak8 AdjJ3c literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/info.gif b/js/lib/slickgrid/images/info.gif new file mode 100644 index 0000000000000000000000000000000000000000..5769434fb244628e2a7637ae9efe4bb041aa8971 GIT binary patch literal 80 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 Jk&%(X8US2;)^z{? literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/row-over-bg.gif b/js/lib/slickgrid/images/row-over-bg.gif new file mode 100644 index 0000000000000000000000000000000000000000..b288e38739ad9914b73eb32837303a11a37f354a GIT binary patch literal 823 zcmV-71IYYGNk%w1VF3Ug0EYko000010RaL60s{jB1Ox;H1qB8M1_uWR2nYxX2?+`c z3JVJh3=9kn4Gj(s4i66x5D*X%5fKs+5)%^>6ciK{6%`g178e&67#J8C85tTH8XFrM z92^`S9UUGX9v>ecARr(iAt53nA|oRsBqSsyB_$>%CMPE+C@3f?DJd!{Dl021EG#T7 zEiEoCE-x=HFfcGNF)=bSGBYzXG&D3dH8nOiHa9mnI5;>tIXOByIy*Z%JUl!-Jv}}? zK0iM{KtMo2K|w-7LPJACL_|bIMMXwNMn^|SNJvOYNl8jdN=r*iOiWBoO-)WtPESuy zP*6}&QBhJ-Qd3h?R8&+|RaI72R##V7SXfwDSy@_IT3cINTwGjTU0q&YUSD5dU|?Wj zVPRroVq;@tWMpJzWo2e&W@l$-XlQ6@X=!R|YHMq2Y;0_8ZEbFDZf|dIaBy&OadC2T za&vQYbaZreb#-=jc6WDoczAeud3kzzdV70&e0+R;eSLm@et&;|fPjF3fq{a8f`fyD zgoK2Jg@uNOhKGlTh=_=ZiHVAeii?YjjEszpjg5|uj*pLzkdTm(k&%*;l9Q8@l$4Z} zm6ev3mY0{8n3$NEnVFiJnwy)OoSdAUot>VZo}ZteprD|kp`oIpqNAguq@<*!rKP5( zrl+T;sHmu^si~@}s;jH3tgNi9t*x%EuCK4Ju&}VPv9YqUva_?Zw6wIfwY9dkwzs#p zxVX5vxw*Q!y1To(yu7@dCU$jHda z$;ryf%FD~k%*@Qq&CSlv&d<-!(9qD)(b3Y<($mw^)YR0~)z#M4*4Nk9*x1lt)=I7_<=;-L_>FMg~>g((4 z?Ck9A?d|UF?(gsK@bK{Q@$vHV^7Hfa^z`)g_4W4l_V@Sq`1ttw`T6?#`uqF){QUg= z{r&#_{{R2~A^8LV00930EC2ui0096U000OS0Po$iSC8I2dGX-ATgb4XLx%wY06VC` Bj$r@* literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/sort-asc.gif b/js/lib/slickgrid/images/sort-asc.gif new file mode 100644 index 0000000000000000000000000000000000000000..67a2a4c669fc5821a07fc486228d626e16d6ad9e GIT binary patch literal 830 zcmZ?wbhEHbra@ocD)4hB}!Z) zN`mv#O3D+9QW*jgGxJLH{9Hp6%8d1l%~n2tqzY7H=IP=XA`zaP=D_+U;9b2*p}}zopr0I3BsYybcN literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/sort-desc.gif b/js/lib/slickgrid/images/sort-desc.gif new file mode 100644 index 0000000000000000000000000000000000000000..34db47c3b1eecab2d3873ee2fc556cd3a6e322f9 GIT binary patch literal 833 zcmZ?wbhEHbra@ocD)4hB}!Z) zN`mv#O3D+9QW*jgGxJLH{9Hp6%8d1l%~n2tqzY7H;_2cTA`zaPpukkXc(sP<(f^De zb`#DsT|Up8Qq!#UgMG<;Mnmac4-H%+R1>>yHu9vU%w@3I!+n0@-}`@o`WZZ3{an^L HB{Ts5Wh^rm literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/stripes.png b/js/lib/slickgrid/images/stripes.png new file mode 100644 index 0000000000000000000000000000000000000000..0c293a927c15df89bd1effaca4184bf0ad79823f GIT binary patch literal 1238 zcmeAS@N?(olHy`uVBq!ia0vp^oIotZ!3-q##j#WYDaPU;cPEB*=VV?2IV|apzK#qG z8~eHcB(ehe3dtTpz6=aiY77hwEes65fIOr{Nf?NJjGBFly85}Sb4q9e03B>MiU0rr literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/tag_red.png b/js/lib/slickgrid/images/tag_red.png new file mode 100644 index 0000000000000000000000000000000000000000..6ebb37d25f58c68246d8ad6a015295dfa5367870 GIT binary patch literal 592 zcmV-W0k7R5;6p zlgVxxK@f)LC45c9TOf_{d{!)DV#gQ9u^lTnR)N?B4hRsNK&)mFLI{BXaU6RP-Hd*B zb;Jb3l0#jp`v2;$?rNpgYN6R|qF%3~R;!^}t)fz?pj!?Xf$9L#$Jra zV+qOU^Cuw+btb`RG?JZ%!=VYGoN$3mCUX>`kYzed-6&Bk7R#EZfpaeN1kB}fNG6j9 zAqsWf92DY}usm8Wm*DdmSn7|g4F&_G(`h6Ui9Luyoi~=(>orKcUM#@A*}%S@gC$>N zt>5pH3q+&Q9f%@k)E7cPhZtkvGtt>@1HZome|iABzA_=bUXNTL7z~;arBEn*5i{!Z z`TQ^BwFP!@4*qZt{`(pH*W(VP+wGDI_d4WAzVcfivW|vfP^h0000Hs{AQG2a)rMyf zFQK~pm1x3+7!nu%-M`k}``c>^00{o_1pjWJUTfl8mg=3qGEl8H@}^@w`VUx0_$uy4 z2FhRqKX}xI*?Tv1DJd8z#F#0c%*~rM30HE1@2o5m~}ZyoWhqv>ql{V z1ZGE0lgcoK^lx+eqc*rAX1Ky;Xx3U%u#zG!m-;eD1Qsn@kf3|F9qz~|95=&g3(7!X zB}JAT>RU;a%vaNOGnJ%e1=K6eAh43c(QN8RQ6~GP%O}Jju$~Ld*%`mO1pphCpI>2{dBys(sIwpFWDz^b5`?95CI)&S&yhXMcq literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/images/user_identity_plus.gif b/js/lib/slickgrid/images/user_identity_plus.gif new file mode 100644 index 0000000000000000000000000000000000000000..b276a81c786561a82422555b598bbc07e63bf82b GIT binary patch literal 546 zcmZ?wbhEHb!lchi~8b7yvx zhlk4?-L>w+!;3T8%cr#zy}WUJPJ8K&IgO7`ZD`I3>n%>ZR_fBqWElN7JYt`JY zvd_2nAK0?|(~Z5KA6>k%Ywn`{iZiJ$v>W7x^ZI1k2m*@ZCy08t@!iZBj>ivKDus3QITpr{ordpS$wvCCZh^f8h0exu+Lk$Bh>jMgM zY_{C4H(guY@7{B9dwAQ^-Q(GF_Xm%jK7af2_1kx^T;F{3c<=V*+cWo;Mh0sD^HazS literal 0 HcmV?d00001 diff --git a/js/lib/slickgrid/jquery.event.drag.min.js b/js/lib/slickgrid/jquery.event.drag.min.js new file mode 100644 index 0000000000..2cb7fee0e2 --- /dev/null +++ b/js/lib/slickgrid/jquery.event.drag.min.js @@ -0,0 +1,6 @@ +/*! + * jquery.event.drag - v 2.0.0 + * Copyright (c) 2010 Three Dub Media - http://threedubmedia.com + * Open Source MIT License - http://threedubmedia.com/code/license + */ +;(function(f){f.fn.drag=function(b,a,d){var e=typeof b=="string"?b:"",k=f.isFunction(b)?b:f.isFunction(a)?a:null;if(e.indexOf("drag")!==0)e="drag"+e;d=(b==k?a:d)||{};return k?this.bind(e,d,k):this.trigger(e)};var i=f.event,h=i.special,c=h.drag={defaults:{which:1,distance:0,not:":input",handle:null,relative:false,drop:true,click:false},datakey:"dragdata",livekey:"livedrag",add:function(b){var a=f.data(this,c.datakey),d=b.data||{};a.related+=1;if(!a.live&&b.selector){a.live=true;i.add(this,"draginit."+ c.livekey,c.delegate)}f.each(c.defaults,function(e){if(d[e]!==undefined)a[e]=d[e]})},remove:function(){f.data(this,c.datakey).related-=1},setup:function(){if(!f.data(this,c.datakey)){var b=f.extend({related:0},c.defaults);f.data(this,c.datakey,b);i.add(this,"mousedown",c.init,b);this.attachEvent&&this.attachEvent("ondragstart",c.dontstart)}},teardown:function(){if(!f.data(this,c.datakey).related){f.removeData(this,c.datakey);i.remove(this,"mousedown",c.init);i.remove(this,"draginit",c.delegate);c.textselect(true); this.detachEvent&&this.detachEvent("ondragstart",c.dontstart)}},init:function(b){var a=b.data,d;if(!(a.which>0&&b.which!=a.which))if(!f(b.target).is(a.not))if(!(a.handle&&!f(b.target).closest(a.handle,b.currentTarget).length)){a.propagates=1;a.interactions=[c.interaction(this,a)];a.target=b.target;a.pageX=b.pageX;a.pageY=b.pageY;a.dragging=null;d=c.hijack(b,"draginit",a);if(a.propagates){if((d=c.flatten(d))&&d.length){a.interactions=[];f.each(d,function(){a.interactions.push(c.interaction(this,a))})}a.propagates= a.interactions.length;a.drop!==false&&h.drop&&h.drop.handler(b,a);c.textselect(false);i.add(document,"mousemove mouseup",c.handler,a);return false}}},interaction:function(b,a){return{drag:b,callback:new c.callback,droppable:[],offset:f(b)[a.relative?"position":"offset"]()||{top:0,left:0}}},handler:function(b){var a=b.data;switch(b.type){case !a.dragging&&"mousemove":if(Math.pow(b.pageX-a.pageX,2)+Math.pow(b.pageY-a.pageY,2)This is pretty much identical to how W3C and jQuery implement events.

+ * @class EventData + * @constructor + */ + function EventData() { + var isPropagationStopped = false; + var isImmediatePropagationStopped = false; + + /*** + * Stops event from propagating up the DOM tree. + * @method stopPropagation + */ + this.stopPropagation = function () { + isPropagationStopped = true; + }; + + /*** + * Returns whether stopPropagation was called on this event object. + * @method isPropagationStopped + * @return {Boolean} + */ + this.isPropagationStopped = function () { + return isPropagationStopped; + }; + + /*** + * Prevents the rest of the handlers from being executed. + * @method stopImmediatePropagation + */ + this.stopImmediatePropagation = function () { + isImmediatePropagationStopped = true; + }; + + /*** + * Returns whether stopImmediatePropagation was called on this event object.\ + * @method isImmediatePropagationStopped + * @return {Boolean} + */ + this.isImmediatePropagationStopped = function () { + return isImmediatePropagationStopped; + } + } + + /*** + * A simple publisher-subscriber implementation. + * @class Event + * @constructor + */ + function Event() { + var handlers = []; + + /*** + * Adds an event handler to be called when the event is fired. + *

Event handler will receive two arguments - an EventData and the data + * object the event was fired with.

+ * @method subscribe + * @param fn {Function} Event handler. + */ + this.subscribe = function (fn) { + handlers.push(fn); + }; + + /*** + * Removes an event handler added with subscribe(fn). + * @method unsubscribe + * @param fn {Function} Event handler to be removed. + */ + this.unsubscribe = function (fn) { + for (var i = handlers.length - 1; i >= 0; i--) { + if (handlers[i] === fn) { + handlers.splice(i, 1); + } + } + }; + + /*** + * Fires an event notifying all subscribers. + * @method notify + * @param args {Object} Additional data object to be passed to all handlers. + * @param e {EventData} + * Optional. + * An EventData object to be passed to all handlers. + * For DOM events, an existing W3C/jQuery event object can be passed in. + * @param scope {Object} + * Optional. + * The scope ("this") within which the handler will be executed. + * If not specified, the scope will be set to the Event instance. + */ + this.notify = function (args, e, scope) { + e = e || new EventData(); + scope = scope || this; + + var returnValue; + for (var i = 0; i < handlers.length && !(e.isPropagationStopped() || e.isImmediatePropagationStopped()); i++) { + returnValue = handlers[i].call(scope, e, args); + } + + return returnValue; + }; + } + + function EventHandler() { + var handlers = []; + + this.subscribe = function (event, handler) { + handlers.push({ + event: event, + handler: handler + }); + event.subscribe(handler); + }; + + this.unsubscribe = function (event, handler) { + var i = handlers.length; + while (i--) { + if (handlers[i].event === event && + handlers[i].handler === handler) { + handlers.splice(i, 1); + event.unsubscribe(handler); + return; + } + } + }; + + this.unsubscribeAll = function () { + var i = handlers.length; + while (i--) { + handlers[i].event.unsubscribe(handlers[i].handler); + } + handlers = []; + } + } + + /*** + * A structure containing a range of cells. + * @class Range + * @constructor + * @param fromRow {Integer} Starting row. + * @param fromCell {Integer} Starting cell. + * @param toRow {Integer} Optional. Ending row. Defaults to fromRow. + * @param toCell {Integer} Optional. Ending cell. Defaults to fromCell. + */ + function Range(fromRow, fromCell, toRow, toCell) { + if (toRow === undefined && toCell === undefined) { + toRow = fromRow; + toCell = fromCell; + } + + /*** + * @property fromRow + * @type {Integer} + */ + this.fromRow = Math.min(fromRow, toRow); + + /*** + * @property fromCell + * @type {Integer} + */ + this.fromCell = Math.min(fromCell, toCell); + + /*** + * @property toRow + * @type {Integer} + */ + this.toRow = Math.max(fromRow, toRow); + + /*** + * @property toCell + * @type {Integer} + */ + this.toCell = Math.max(fromCell, toCell); + + /*** + * Returns whether a range represents a single row. + * @method isSingleRow + * @return {Boolean} + */ + this.isSingleRow = function () { + return this.fromRow == this.toRow; + }; + + /*** + * Returns whether a range represents a single cell. + * @method isSingleCell + * @return {Boolean} + */ + this.isSingleCell = function () { + return this.fromRow == this.toRow && this.fromCell == this.toCell; + }; + + /*** + * Returns whether a range contains a given cell. + * @method contains + * @param row {Integer} + * @param cell {Integer} + * @return {Boolean} + */ + this.contains = function (row, cell) { + return row >= this.fromRow && row <= this.toRow && + cell >= this.fromCell && cell <= this.toCell; + }; + + /*** + * Returns a readable representation of a range. + * @method toString + * @return {String} + */ + this.toString = function () { + if (this.isSingleCell()) { + return "(" + this.fromRow + ":" + this.fromCell + ")"; + } + else { + return "(" + this.fromRow + ":" + this.fromCell + " - " + this.toRow + ":" + this.toCell + ")"; + } + } + } + + + /*** + * A base class that all special / non-data rows (like Group and GroupTotals) derive from. + * @class NonDataItem + * @constructor + */ + function NonDataItem() { + this.__nonDataRow = true; + } + + + /*** + * Information about a group of rows. + * @class Group + * @extends Slick.NonDataItem + * @constructor + */ + function Group() { + this.__group = true; + this.__updated = false; + + /*** + * Number of rows in the group. + * @property count + * @type {Integer} + */ + this.count = 0; + + /*** + * Grouping value. + * @property value + * @type {Object} + */ + this.value = null; + + /*** + * Formatted display value of the group. + * @property title + * @type {String} + */ + this.title = null; + + /*** + * Whether a group is collapsed. + * @property collapsed + * @type {Boolean} + */ + this.collapsed = false; + + /*** + * GroupTotals, if any. + * @property totals + * @type {GroupTotals} + */ + this.totals = null; + } + + Group.prototype = new NonDataItem(); + + /*** + * Compares two Group instances. + * @method equals + * @return {Boolean} + * @param group {Group} Group instance to compare to. + */ + Group.prototype.equals = function (group) { + return this.value === group.value && + this.count === group.count && + this.collapsed === group.collapsed; + }; + + /*** + * Information about group totals. + * An instance of GroupTotals will be created for each totals row and passed to the aggregators + * so that they can store arbitrary data in it. That data can later be accessed by group totals + * formatters during the display. + * @class GroupTotals + * @extends Slick.NonDataItem + * @constructor + */ + function GroupTotals() { + this.__groupTotals = true; + + /*** + * Parent Group. + * @param group + * @type {Group} + */ + this.group = null; + } + + GroupTotals.prototype = new NonDataItem(); + + /*** + * A locking helper to track the active edit controller and ensure that only a single controller + * can be active at a time. This prevents a whole class of state and validation synchronization + * issues. An edit controller (such as SlickGrid) can query if an active edit is in progress + * and attempt a commit or cancel before proceeding. + * @class EditorLock + * @constructor + */ + function EditorLock() { + var activeEditController = null; + + /*** + * Returns true if a specified edit controller is active (has the edit lock). + * If the parameter is not specified, returns true if any edit controller is active. + * @method isActive + * @param editController {EditController} + * @return {Boolean} + */ + this.isActive = function (editController) { + return (editController ? activeEditController === editController : activeEditController !== null); + }; + + /*** + * Sets the specified edit controller as the active edit controller (acquire edit lock). + * If another edit controller is already active, and exception will be thrown. + * @method activate + * @param editController {EditController} edit controller acquiring the lock + */ + this.activate = function (editController) { + if (editController === activeEditController) { // already activated? + return; + } + if (activeEditController !== null) { + throw "SlickGrid.EditorLock.activate: an editController is still active, can't activate another editController"; + } + if (!editController.commitCurrentEdit) { + throw "SlickGrid.EditorLock.activate: editController must implement .commitCurrentEdit()"; + } + if (!editController.cancelCurrentEdit) { + throw "SlickGrid.EditorLock.activate: editController must implement .cancelCurrentEdit()"; + } + activeEditController = editController; + }; + + /*** + * Unsets the specified edit controller as the active edit controller (release edit lock). + * If the specified edit controller is not the active one, an exception will be thrown. + * @method deactivate + * @param editController {EditController} edit controller releasing the lock + */ + this.deactivate = function (editController) { + if (activeEditController !== editController) { + throw "SlickGrid.EditorLock.deactivate: specified editController is not the currently active one"; + } + activeEditController = null; + }; + + /*** + * Attempts to commit the current edit by calling "commitCurrentEdit" method on the active edit + * controller and returns whether the commit attempt was successful (commit may fail due to validation + * errors, etc.). Edit controller's "commitCurrentEdit" must return true if the commit has succeeded + * and false otherwise. If no edit controller is active, returns true. + * @method commitCurrentEdit + * @return {Boolean} + */ + this.commitCurrentEdit = function () { + return (activeEditController ? activeEditController.commitCurrentEdit() : true); + }; + + /*** + * Attempts to cancel the current edit by calling "cancelCurrentEdit" method on the active edit + * controller and returns whether the edit was successfully cancelled. If no edit controller is + * active, returns true. + * @method cancelCurrentEdit + * @return {Boolean} + */ + this.cancelCurrentEdit = function cancelCurrentEdit() { + return (activeEditController ? activeEditController.cancelCurrentEdit() : true); + }; + } +})(jQuery); + + diff --git a/js/lib/slickgrid/slick.grid.css b/js/lib/slickgrid/slick.grid.css new file mode 100644 index 0000000000..e5ef44cd57 --- /dev/null +++ b/js/lib/slickgrid/slick.grid.css @@ -0,0 +1,158 @@ +/* +IMPORTANT: +In order to preserve the uniform grid appearance, all cell styles need to have padding, margin and border sizes. +No built-in (selected, editable, highlight, flashing, invalid, loading, :focus) or user-specified CSS +classes should alter those! +*/ + +.slick-header.ui-state-default, .slick-headerrow.ui-state-default { + width: 100%; + overflow: hidden; + border-left: 0px; +} + +.slick-header-columns, .slick-headerrow-columns { + width: 999999px; + position: relative; + white-space: nowrap; + cursor: default; + overflow: hidden; +} + +.slick-header-column.ui-state-default { + position: relative; + display: inline-block; + overflow: hidden; + text-overflow: ellipsis; + height: 16px; + line-height: 16px; + margin: 0; + padding: 4px; + border-right: 1px solid silver; + border-left: 0px; + border-top: 0px; + border-bottom: 0px; + float: left; +} + +.slick-headerrow-column.ui-state-default { + padding: 4px; +} + +.slick-header-column-sorted { + font-style: italic; +} + +.slick-sort-indicator { + display: inline-block; + width: 8px; + height: 5px; + margin-left: 4px; +} + +.slick-sort-indicator-desc { + background: url(images/sort-desc.gif); +} + +.slick-sort-indicator-asc { + background: url(images/sort-asc.gif); +} + +.slick-resizable-handle { + position: absolute; + font-size: 0.1px; + display: block; + cursor: col-resize; + width: 4px; + right: 0px; + top: 0; + height: 100%; +} + +.slick-sortable-placeholder { + background: silver; +} + +.grid-canvas { + position: relative; + outline: 0; +} + +.slick-row.ui-widget-content, .slick-row.ui-state-active { + position: absolute; + border: 0px; + width: 100%; +} + +.slick-cell, .slick-headerrow-column { + position: absolute; + + border: 1px solid transparent; + border-right: 1px dotted silver; + border-bottom-color: silver; + + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + vertical-align: middle; + z-index: 1; + padding: 1px 2px 2px 1px; + margin: 0; + + white-space: nowrap; + + cursor: default; +} + +.slick-group { +} + +.slick-group-toggle { + display: inline-block; +} + +.slick-cell.highlighted { + background: lightskyblue; + background: rgba(0, 0, 255, 0.2); + -webkit-transition: all 0.5s; + -moz-transition: all 0.5s; + transition: all 0.5s; +} + +.slick-cell.flashing { + border: 1px solid red !important; +} + +.slick-cell.editable { + z-index: 11; + overflow: visible; + background: white; + border-color: black; + border-style: solid; +} + +.slick-cell:focus { + outline: none; +} + +.slick-reorder-proxy { + display: inline-block; + background: blue; + opacity: 0.15; + filter: alpha(opacity = 15); + cursor: move; +} + +.slick-reorder-guide { + display: inline-block; + height: 2px; + background: blue; + opacity: 0.7; + filter: alpha(opacity = 70); +} + +.slick-selection { + z-index: 10; + position: absolute; + border: 2px dashed black; +} \ No newline at end of file diff --git a/js/lib/slickgrid/slick.grid.js b/js/lib/slickgrid/slick.grid.js new file mode 100644 index 0000000000..c9a3b0e811 --- /dev/null +++ b/js/lib/slickgrid/slick.grid.js @@ -0,0 +1,2799 @@ +/** + * @license + * (c) 2009-2012 Michael Leibman + * michael{dot}leibman{at}gmail{dot}com + * http://github.com/mleibman/slickgrid + * + * Distributed under MIT license. + * All rights reserved. + * + * SlickGrid v2.0 + * + * NOTES: + * Cell/row DOM manipulations are done directly bypassing jQuery's DOM manipulation methods. + * This increases the speed dramatically, but can only be done safely because there are no event handlers + * or data associated with any cell/row DOM nodes. Cell editors must make sure they implement .destroy() + * and do proper cleanup. + */ + +// make sure required JavaScript modules are loaded +if (typeof jQuery === "undefined") { + throw "SlickGrid requires jquery module to be loaded"; +} +if (!jQuery.fn.drag) { + throw "SlickGrid requires jquery.event.drag module to be loaded"; +} +if (typeof Slick === "undefined") { + throw "slick.core.js not loaded"; +} + + +(function ($) { + // Slick.Grid + $.extend(true, window, { + Slick: { + Grid: SlickGrid + } + }); + + // shared across all grids on the page + var scrollbarDimensions; + var maxSupportedCssHeight; // browser's breaking point + + ////////////////////////////////////////////////////////////////////////////////////////////// + // SlickGrid class implementation (available as Slick.Grid) + + /** + * Creates a new instance of the grid. + * @class SlickGrid + * @constructor + * @param {Node} container Container node to create the grid in. + * @param {Array,Object} data An array of objects for databinding. + * @param {Array} columns An array of column definitions. + * @param {Object} options Grid options. + **/ + function SlickGrid(container, data, columns, options) { + // settings + var defaults = { + explicitInitialization: false, + rowHeight: 25, + defaultColumnWidth: 80, + enableAddRow: false, + leaveSpaceForNewRows: false, + editable: false, + autoEdit: true, + enableCellNavigation: true, + enableColumnReorder: true, + asyncEditorLoading: false, + asyncEditorLoadDelay: 100, + forceFitColumns: false, + enableAsyncPostRender: false, + asyncPostRenderDelay: 60, + autoHeight: false, + editorLock: Slick.GlobalEditorLock, + showHeaderRow: false, + headerRowHeight: 25, + showTopPanel: false, + topPanelHeight: 25, + formatterFactory: null, + editorFactory: null, + cellFlashingCssClass: "flashing", + selectedCellCssClass: "selected", + multiSelect: true, + enableTextSelectionOnCells: false, + dataItemColumnValueExtractor: null, + fullWidthRows: false, + multiColumnSort: false, + defaultFormatter: defaultFormatter + }; + + var columnDefaults = { + name: "", + resizable: true, + sortable: false, + minWidth: 30, + rerenderOnResize: false, + headerCssClass: null + }; + + // scroller + var th; // virtual height + var h; // real scrollable height + var ph; // page height + var n; // number of pages + var cj; // "jumpiness" coefficient + + var page = 0; // current page + var offset = 0; // current page offset + var scrollDir = 1; + + // private + var initialized = false; + var $container; + var uid = "slickgrid_" + Math.round(1000000 * Math.random()); + var self = this; + var $headerScroller; + var $headers; + var $headerRow, $headerRowScroller; + var $topPanelScroller; + var $topPanel; + var $viewport; + var $canvas; + var $style; + var stylesheet, columnCssRulesL = [], columnCssRulesR = []; + var viewportH, viewportW; + var canvasWidth; + var viewportHasHScroll, viewportHasVScroll; + var headerColumnWidthDiff = 0, headerColumnHeightDiff = 0, // border+padding + cellWidthDiff = 0, cellHeightDiff = 0; + var absoluteColumnMinWidth; + var numberOfRows = 0; + + var activePosX; + var activeRow, activeCell; + var activeCellNode = null; + var currentEditor = null; + var serializedEditorValue; + var editController; + + var rowsCache = {}; + var renderedRows = 0; + var numVisibleRows; + var prevScrollTop = 0; + var scrollTop = 0; + var lastRenderedScrollTop = 0; + var prevScrollLeft = 0; + var avgRowRenderTime = 10; + + var selectionModel; + var selectedRows = []; + + var plugins = []; + var cellCssClasses = {}; + + var columnsById = {}; + var sortColumns = []; + + + // async call handles + var h_editorLoader = null; + var h_render = null; + var h_postrender = null; + var postProcessedRows = {}; + var postProcessToRow = null; + var postProcessFromRow = null; + + // perf counters + var counter_rows_rendered = 0; + var counter_rows_removed = 0; + + + ////////////////////////////////////////////////////////////////////////////////////////////// + // Initialization + + function init() { + $container = $(container); + if ($container.length < 1) { + throw new Error("SlickGrid requires a valid container, " + container + " does not exist in the DOM."); + } + + // calculate these only once and share between grid instances + maxSupportedCssHeight = maxSupportedCssHeight || getMaxSupportedCssHeight(); + scrollbarDimensions = scrollbarDimensions || measureScrollbar(); + + options = $.extend({}, defaults, options); + columnDefaults.width = options.defaultColumnWidth; + + // validate loaded JavaScript modules against requested options + if (options.enableColumnReorder && !$.fn.sortable) { + throw new Error("SlickGrid's 'enableColumnReorder = true' option requires jquery-ui.sortable module to be loaded"); + } + + editController = { + "commitCurrentEdit": commitCurrentEdit, + "cancelCurrentEdit": cancelCurrentEdit + }; + + $container + .empty() + .attr("tabIndex", 0) + .attr("hideFocus", true) + .css("overflow", "hidden") + .css("outline", 0) + .addClass(uid) + .addClass("ui-widget"); + + // set up a positioning container if needed + if (!/relative|absolute|fixed/.test($container.css("position"))) { + $container.css("position", "relative"); + } + + $headerScroller = $("

").appendTo($container); + $headers = $("
").appendTo($headerScroller); + + $headerRowScroller = $("
").appendTo($container); + $headerRow = $("
").appendTo($headerRowScroller); + + $topPanelScroller = $("
").appendTo($container); + $topPanel = $("
").appendTo($topPanelScroller); + + if (!options.showTopPanel) { + $topPanelScroller.hide(); + } + + if (!options.showHeaderRow) { + $headerRowScroller.hide(); + } + + $viewport = $("
").appendTo($container); + $viewport.css("overflow-y", options.autoHeight ? "hidden" : "auto"); + + $canvas = $("
").appendTo($viewport); + + if (!options.explicitInitialization) { + finishInitialization(); + } + } + + function finishInitialization() { + if (!initialized) { + initialized = true; + + viewportW = parseFloat($.css($container[0], "width", true)); + + // header columns and cells may have different padding/border skewing width calculations (box-sizing, hello?) + // calculate the diff so we can set consistent sizes + measureCellPaddingAndBorder(); + + // for usability reasons, all text selection in SlickGrid is disabled + // with the exception of input and textarea elements (selection must + // be enabled there so that editors work as expected); note that + // selection in grid cells (grid body) is already unavailable in + // all browsers except IE + disableSelection($headers); // disable all text selection in header (including input and textarea) + + if (!options.enableTextSelectionOnCells) { + // disable text selection in grid cells except in input and textarea elements + // (this is IE-specific, because selectstart event will only fire in IE) + $viewport.bind("selectstart.ui", function (event) { + return $(event.target).is("input,textarea"); + }); + } + + createColumnHeaders(); + setupColumnSort(); + createCssRules(); + resizeCanvas(); + bindAncestorScrollEvents(); + + $container + .bind("resize.slickgrid", resizeCanvas); + $viewport + .bind("scroll.slickgrid", handleScroll); + $headerScroller + .bind("contextmenu.slickgrid", handleHeaderContextMenu) + .bind("click.slickgrid", handleHeaderClick); + $canvas + .bind("keydown.slickgrid", handleKeyDown) + .bind("click.slickgrid", handleClick) + .bind("dblclick.slickgrid", handleDblClick) + .bind("contextmenu.slickgrid", handleContextMenu) + .bind("draginit", handleDragInit) + .bind("dragstart", handleDragStart) + .bind("drag", handleDrag) + .bind("dragend", handleDragEnd) + .delegate(".slick-cell", "mouseenter", handleMouseEnter) + .delegate(".slick-cell", "mouseleave", handleMouseLeave); + } + } + + function registerPlugin(plugin) { + plugins.unshift(plugin); + plugin.init(self); + } + + function unregisterPlugin(plugin) { + for (var i = plugins.length; i >= 0; i--) { + if (plugins[i] === plugin) { + if (plugins[i].destroy) { + plugins[i].destroy(); + } + plugins.splice(i, 1); + break; + } + } + } + + function setSelectionModel(model) { + if (selectionModel) { + selectionModel.onSelectedRangesChanged.unsubscribe(handleSelectedRangesChanged); + if (selectionModel.destroy) { + selectionModel.destroy(); + } + } + + selectionModel = model; + if (selectionModel) { + selectionModel.init(self); + selectionModel.onSelectedRangesChanged.subscribe(handleSelectedRangesChanged); + } + } + + function getSelectionModel() { + return selectionModel; + } + + function getCanvasNode() { + return $canvas[0]; + } + + function measureScrollbar() { + var $c = $("
").appendTo("body"); + var dim = { + width: $c.width() - $c[0].clientWidth, + height: $c.height() - $c[0].clientHeight + }; + $c.remove(); + return dim; + } + + function getCanvasWidth() { + var availableWidth = viewportHasVScroll ? viewportW - scrollbarDimensions.width : viewportW; + var rowWidth = 0; + var i = columns.length; + while (i--) { + rowWidth += (columns[i].width || columnDefaults.width); + } + return options.fullWidthRows ? Math.max(rowWidth, availableWidth) : rowWidth; + } + + function updateCanvasWidth(forceColumnWidthsUpdate) { + var oldCanvasWidth = canvasWidth; + canvasWidth = getCanvasWidth(); + + if (canvasWidth != oldCanvasWidth) { + $canvas.width(canvasWidth); + $headerRow.width(canvasWidth); + viewportHasHScroll = (canvasWidth > viewportW - scrollbarDimensions.width); + } + + if (canvasWidth != oldCanvasWidth || forceColumnWidthsUpdate) { + applyColumnWidths(); + } + } + + function disableSelection($target) { + if ($target && $target.jquery) { + $target + .attr("unselectable", "on") + .css("MozUserSelect", "none") + .bind("selectstart.ui", function () { + return false; + }); // from jquery:ui.core.js 1.7.2 + } + } + + function getMaxSupportedCssHeight() { + var increment = 1000000; + var supportedHeight = increment; + // FF reports the height back but still renders blank after ~6M px + var testUpTo = ($.browser.mozilla) ? 5000000 : 1000000000; + var div = $("
").appendTo(document.body); + + while (supportedHeight <= testUpTo) { + div.css("height", supportedHeight + increment); + if (div.height() !== supportedHeight + increment) { + break; + } else { + supportedHeight += increment; + } + } + + div.remove(); + return supportedHeight; + } + + // TODO: this is static. need to handle page mutation. + function bindAncestorScrollEvents() { + var elem = $canvas[0]; + while ((elem = elem.parentNode) != document.body && elem != null) { + // bind to scroll containers only + if (elem == $viewport[0] || elem.scrollWidth != elem.clientWidth || elem.scrollHeight != elem.clientHeight) { + $(elem).bind("scroll.slickgrid", handleActiveCellPositionChange); + } + } + } + + function unbindAncestorScrollEvents() { + $canvas.parents().unbind("scroll.slickgrid"); + } + + function updateColumnHeader(columnId, title, toolTip) { + if (!initialized) { return; } + var idx = getColumnIndex(columnId); + var $header = $headers.children().eq(idx); + if ($header) { + columns[idx].name = title; + columns[idx].toolTip = toolTip; + $header + .attr("title", toolTip || title || "") + .children().eq(0).html(title); + } + } + + function getHeaderRow() { + return $headerRow[0]; + } + + function getHeaderRowColumn(columnId) { + var idx = getColumnIndex(columnId); + var $header = $headerRow.children().eq(idx); + return $header && $header[0]; + } + + function createColumnHeaders() { + function hoverBegin() { + $(this).addClass("ui-state-hover"); + } + + function hoverEnd() { + $(this).removeClass("ui-state-hover"); + } + + $headers.empty(); + $headerRow.empty(); + columnsById = {}; + + for (var i = 0; i < columns.length; i++) { + var m = columns[i] = $.extend({}, columnDefaults, columns[i]); + columnsById[m.id] = i; + + var header = $("
") + .html("" + m.name + "") + .width(m.width - headerColumnWidthDiff) + .attr("title", m.toolTip || m.name || "") + .data("fieldId", m.id) + .addClass(m.headerCssClass || "") + .appendTo($headers); + + if (options.enableColumnReorder || m.sortable) { + header.hover(hoverBegin, hoverEnd); + } + + if (m.sortable) { + header.append(""); + } + + if (options.showHeaderRow) { + $("
") + .appendTo($headerRow); + } + } + + if (options.showHeaderRow) { + // add a spacer to let the container scroll beyond the header row columns width + $("
") + .appendTo($headerRowScroller); + } + + setSortColumns(sortColumns); + setupColumnResize(); + if (options.enableColumnReorder) { + setupColumnReorder(); + } + } + + function setupColumnSort() { + $headers.click(function (e) { + // temporary workaround for a bug in jQuery 1.7.1 (http://bugs.jquery.com/ticket/11328) + e.metaKey = e.metaKey || e.ctrlKey; + + if ($(e.target).hasClass("slick-resizable-handle")) { + return; + } + + var $col = $(e.target).closest(".slick-header-column"); + if (!$col.length) { + return; + } + + var column = columns[getColumnIndex($col.data("fieldId"))]; + if (column.sortable) { + if (!getEditorLock().commitCurrentEdit()) { + return; + } + + var sortOpts = null; + var i = 0; + for (; i < sortColumns.length; i++) { + if (sortColumns[i].columnId == column.id) { + sortOpts = sortColumns[i]; + sortOpts.sortAsc = !sortOpts.sortAsc; + break; + } + } + + if (e.metaKey && options.multiColumnSort) { + if (sortOpts) { + sortColumns.splice(i, 1); + } + } + else { + if ((!e.shiftKey && !e.metaKey) || !options.multiColumnSort) { + sortColumns = []; + } + + if (!sortOpts) { + sortOpts = { columnId: column.id, sortAsc: true }; + sortColumns.push(sortOpts); + } else if (sortColumns.length == 0) { + sortColumns.push(sortOpts); + } + } + + setSortColumns(sortColumns); + + if (!options.multiColumnSort) { + trigger(self.onSort, { + multiColumnSort: false, + sortCol: column, + sortAsc: sortOpts.sortAsc}, e); + } else { + trigger(self.onSort, { + multiColumnSort: true, + sortCols: $.map(sortColumns, function(col) { + return {sortCol: columns[getColumnIndex(col.columnId)], sortAsc: col.sortAsc }; + })}, e); + } + } + }); + } + + function setupColumnReorder() { + $headers.sortable({ + containment: "parent", + axis: "x", + cursor: "default", + tolerance: "intersection", + helper: "clone", + placeholder: "slick-sortable-placeholder ui-state-default slick-header-column", + forcePlaceholderSize: true, + start: function (e, ui) { + $(ui.helper).addClass("slick-header-column-active"); + }, + beforeStop: function (e, ui) { + $(ui.helper).removeClass("slick-header-column-active"); + }, + stop: function (e) { + if (!getEditorLock().commitCurrentEdit()) { + $(this).sortable("cancel"); + return; + } + + var reorderedIds = $headers.sortable("toArray"); + var reorderedColumns = []; + for (var i = 0; i < reorderedIds.length; i++) { + reorderedColumns.push(columns[getColumnIndex(reorderedIds[i].replace(uid, ""))]); + } + setColumns(reorderedColumns); + + trigger(self.onColumnsReordered, {}); + e.stopPropagation(); + setupColumnResize(); + } + }); + } + + function setupColumnResize() { + var $col, j, c, pageX, columnElements, minPageX, maxPageX, firstResizable, lastResizable; + columnElements = $headers.children(); + columnElements.find(".slick-resizable-handle").remove(); + columnElements.each(function (i, e) { + if (columns[i].resizable) { + if (firstResizable === undefined) { + firstResizable = i; + } + lastResizable = i; + } + }); + if (firstResizable === undefined) { + return; + } + columnElements.each(function (i, e) { + if (i < firstResizable || (options.forceFitColumns && i >= lastResizable)) { + return; + } + $col = $(e); + $("
") + .appendTo(e) + .bind("dragstart", function (e, dd) { + if (!getEditorLock().commitCurrentEdit()) { + return false; + } + pageX = e.pageX; + $(this).parent().addClass("slick-header-column-active"); + var shrinkLeewayOnRight = null, stretchLeewayOnRight = null; + // lock each column's width option to current width + columnElements.each(function (i, e) { + columns[i].previousWidth = $(e).outerWidth(); + }); + if (options.forceFitColumns) { + shrinkLeewayOnRight = 0; + stretchLeewayOnRight = 0; + // colums on right affect maxPageX/minPageX + for (j = i + 1; j < columnElements.length; j++) { + c = columns[j]; + if (c.resizable) { + if (stretchLeewayOnRight !== null) { + if (c.maxWidth) { + stretchLeewayOnRight += c.maxWidth - c.previousWidth; + } else { + stretchLeewayOnRight = null; + } + } + shrinkLeewayOnRight += c.previousWidth - Math.max(c.minWidth || 0, absoluteColumnMinWidth); + } + } + } + var shrinkLeewayOnLeft = 0, stretchLeewayOnLeft = 0; + for (j = 0; j <= i; j++) { + // columns on left only affect minPageX + c = columns[j]; + if (c.resizable) { + if (stretchLeewayOnLeft !== null) { + if (c.maxWidth) { + stretchLeewayOnLeft += c.maxWidth - c.previousWidth; + } else { + stretchLeewayOnLeft = null; + } + } + shrinkLeewayOnLeft += c.previousWidth - Math.max(c.minWidth || 0, absoluteColumnMinWidth); + } + } + if (shrinkLeewayOnRight === null) { + shrinkLeewayOnRight = 100000; + } + if (shrinkLeewayOnLeft === null) { + shrinkLeewayOnLeft = 100000; + } + if (stretchLeewayOnRight === null) { + stretchLeewayOnRight = 100000; + } + if (stretchLeewayOnLeft === null) { + stretchLeewayOnLeft = 100000; + } + maxPageX = pageX + Math.min(shrinkLeewayOnRight, stretchLeewayOnLeft); + minPageX = pageX - Math.min(shrinkLeewayOnLeft, stretchLeewayOnRight); + }) + .bind("drag", function (e, dd) { + var actualMinWidth, d = Math.min(maxPageX, Math.max(minPageX, e.pageX)) - pageX, x; + if (d < 0) { // shrink column + x = d; + for (j = i; j >= 0; j--) { + c = columns[j]; + if (c.resizable) { + actualMinWidth = Math.max(c.minWidth || 0, absoluteColumnMinWidth); + if (x && c.previousWidth + x < actualMinWidth) { + x += c.previousWidth - actualMinWidth; + c.width = actualMinWidth; + } else { + c.width = c.previousWidth + x; + x = 0; + } + } + } + + if (options.forceFitColumns) { + x = -d; + for (j = i + 1; j < columnElements.length; j++) { + c = columns[j]; + if (c.resizable) { + if (x && c.maxWidth && (c.maxWidth - c.previousWidth < x)) { + x -= c.maxWidth - c.previousWidth; + c.width = c.maxWidth; + } else { + c.width = c.previousWidth + x; + x = 0; + } + } + } + } + } else { // stretch column + x = d; + for (j = i; j >= 0; j--) { + c = columns[j]; + if (c.resizable) { + if (x && c.maxWidth && (c.maxWidth - c.previousWidth < x)) { + x -= c.maxWidth - c.previousWidth; + c.width = c.maxWidth; + } else { + c.width = c.previousWidth + x; + x = 0; + } + } + } + + if (options.forceFitColumns) { + x = -d; + for (j = i + 1; j < columnElements.length; j++) { + c = columns[j]; + if (c.resizable) { + actualMinWidth = Math.max(c.minWidth || 0, absoluteColumnMinWidth); + if (x && c.previousWidth + x < actualMinWidth) { + x += c.previousWidth - actualMinWidth; + c.width = actualMinWidth; + } else { + c.width = c.previousWidth + x; + x = 0; + } + } + } + } + } + applyColumnHeaderWidths(); + if (options.syncColumnCellResize) { + applyColumnWidths(); + } + }) + .bind("dragend", function (e, dd) { + var newWidth; + $(this).parent().removeClass("slick-header-column-active"); + for (j = 0; j < columnElements.length; j++) { + c = columns[j]; + newWidth = $(columnElements[j]).outerWidth(); + + if (c.previousWidth !== newWidth && c.rerenderOnResize) { + invalidateAllRows(); + } + } + updateCanvasWidth(true); + render(); + trigger(self.onColumnsResized, {}); + }); + }); + } + + function getVBoxDelta($el) { + var p = ["borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"]; + var delta = 0; + $.each(p, function (n, val) { + delta += parseFloat($el.css(val)) || 0; + }); + return delta; + } + + function measureCellPaddingAndBorder() { + var el; + var h = ["borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight"]; + var v = ["borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"]; + + el = $("").appendTo($headers); + headerColumnWidthDiff = headerColumnHeightDiff = 0; + $.each(h, function (n, val) { + headerColumnWidthDiff += parseFloat(el.css(val)) || 0; + }); + $.each(v, function (n, val) { + headerColumnHeightDiff += parseFloat(el.css(val)) || 0; + }); + el.remove(); + + var r = $("
").appendTo($canvas); + el = $("").appendTo(r); + cellWidthDiff = cellHeightDiff = 0; + $.each(h, function (n, val) { + cellWidthDiff += parseFloat(el.css(val)) || 0; + }); + $.each(v, function (n, val) { + cellHeightDiff += parseFloat(el.css(val)) || 0; + }); + r.remove(); + + absoluteColumnMinWidth = Math.max(headerColumnWidthDiff, cellWidthDiff); + } + + function createCssRules() { + $style = $("