From 561eba2a0c9ec6049965e7f7107e2a7d5c411513 Mon Sep 17 00:00:00 2001 From: yangxx Date: Mon, 25 Aug 2003 19:01:54 +0000 Subject: [PATCH] main window files git-svn-id: http://ltt.polymtl.ca/svn@185 04897980-b3bd-0310-b5e0-8ef037075253 --- .../poly/lttv/modules/gui/mainWin/Makefile.am | 30 + .../lttv/modules/gui/mainWin/mainwin.glade | 760 ++++++++++++++ .../lttv/modules/gui/mainWin/mainwin.gladep | 8 + .../gui/mainWin/pixmaps/1downarrow.png | Bin 0 -> 188 bytes .../modules/gui/mainWin/pixmaps/1uparrow.png | Bin 0 -> 188 bytes .../gui/mainWin/pixmaps/edit_add_22.png | Bin 0 -> 820 bytes .../gui/mainWin/pixmaps/edit_remove_22.png | Bin 0 -> 713 bytes .../modules/gui/mainWin/pixmaps/filenew.png | Bin 0 -> 1316 bytes .../modules/gui/mainWin/pixmaps/fileopen.png | Bin 0 -> 1295 bytes .../modules/gui/mainWin/pixmaps/filesave.png | Bin 0 -> 595 bytes .../gui/mainWin/pixmaps/filesaveas.png | Bin 0 -> 732 bytes .../modules/gui/mainWin/pixmaps/gtk-add.png | Bin 0 -> 460 bytes .../gui/mainWin/pixmaps/gtk-jump-to.png | Bin 0 -> 3596 bytes .../gui/mainWin/pixmaps/mini-display.xpm | 25 + .../gui/mainWin/pixmaps/move_message.xpm | 59 ++ .../modules/gui/mainWin/pixmaps/remove.png | Bin 0 -> 236 bytes .../modules/gui/mainWin/pixmaps/remove1.png | Bin 0 -> 724 bytes .../gui/mainWin/pixmaps/stock_zoom_fit_24.png | Bin 0 -> 1102 bytes .../gui/mainWin/pixmaps/stock_zoom_in_24.png | Bin 0 -> 1099 bytes .../gui/mainWin/pixmaps/stock_zoom_out_24.png | Bin 0 -> 1074 bytes .../gui/mainWin/src/.deps/callbacks.Po | 910 +++++++++++++++++ .../gui/mainWin/src/.deps/gtkcustom.Po | 826 ++++++++++++++++ .../gui/mainWin/src/.deps/interface.Po | 923 ++++++++++++++++++ .../modules/gui/mainWin/src/.deps/main.Po | 910 +++++++++++++++++ .../modules/gui/mainWin/src/.deps/support.Po | 916 +++++++++++++++++ .../lttv/modules/gui/mainWin/src/Makefile.am | 21 + .../lttv/modules/gui/mainWin/src/callbacks.c | 723 ++++++++++++++ .../lttv/modules/gui/mainWin/src/callbacks.h | 206 ++++ .../lttv/modules/gui/mainWin/src/gtkcustom.c | 406 ++++++++ .../lttv/modules/gui/mainWin/src/gtkcustom.h | 66 ++ .../lttv/modules/gui/mainWin/src/interface.c | 772 +++++++++++++++ .../lttv/modules/gui/mainWin/src/interface.h | 5 + .../poly/lttv/modules/gui/mainWin/src/main.c | 96 ++ .../lttv/modules/gui/mainWin/src/mainWindow.h | 76 ++ .../poly/lttv/modules/gui/mainWin/src/mainwin | Bin 0 -> 670932 bytes .../lttv/modules/gui/mainWin/src/support.c | 144 +++ .../lttv/modules/gui/mainWin/src/support.h | 67 ++ 37 files changed, 7949 insertions(+) create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/Makefile.am create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.glade create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.gladep create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/1downarrow.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/1uparrow.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/edit_add_22.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/edit_remove_22.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filenew.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/fileopen.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filesave.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filesaveas.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/gtk-add.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/gtk-jump-to.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/mini-display.xpm create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/move_message.xpm create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/remove.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/remove1.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_fit_24.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_in_24.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_out_24.png create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/.deps/callbacks.Po create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/.deps/gtkcustom.Po create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/.deps/interface.Po create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/.deps/main.Po create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/.deps/support.Po create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/Makefile.am create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/callbacks.c create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/callbacks.h create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.c create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.h create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.c create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.h create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/main.c create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/mainWindow.h create mode 100755 ltt/branches/poly/lttv/modules/gui/mainWin/src/mainwin create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/support.c create mode 100644 ltt/branches/poly/lttv/modules/gui/mainWin/src/support.h diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/Makefile.am b/ltt/branches/poly/lttv/modules/gui/mainWin/Makefile.am new file mode 100644 index 00000000..cf433398 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/Makefile.am @@ -0,0 +1,30 @@ +## Process this file with automake to produce Makefile.in + +SUBDIRS = src po + +EXTRA_DIST = \ + autogen.sh \ + mainwin.glade \ + mainwin.gladep + +install-data-local: + @$(NORMAL_INSTALL) + if test -d $(srcdir)/pixmaps; then \ + $(mkinstalldirs) $(DESTDIR)$(pkgdatadir)/pixmaps; \ + for pixmap in $(srcdir)/pixmaps/*; do \ + if test -f $$pixmap; then \ + $(INSTALL_DATA) $$pixmap $(DESTDIR)$(pkgdatadir)/pixmaps; \ + fi \ + done \ + fi + +dist-hook: + if test -d pixmaps; then \ + mkdir $(distdir)/pixmaps; \ + for pixmap in pixmaps/*; do \ + if test -f $$pixmap; then \ + cp -p $$pixmap $(distdir)/pixmaps; \ + fi \ + done \ + fi + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.glade b/ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.glade new file mode 100644 index 00000000..0d4cd97d --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.glade @@ -0,0 +1,760 @@ + + + + + + + 100 + 50 + True + Main window + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + 600 + 400 + True + False + + + + + True + False + 0 + + + + True + False + 0 + + + + True + + + + True + _File + True + + + + + + + True + New + True + + + + + + + True + Empty trace set + True + + + + + + + True + Clone trace set + True + + + + + + + True + + + + + + True + Tab + True + + + + + + + + + + + True + Open + True + + + + + + + True + Close + True + + + + + + + True + Close Tab + True + + + + + + + True + + + + + + True + Add Trace + True + + + + + + + True + Remove Trace + True + + + + + + + True + Save + True + + + + + + + True + Save As + True + + + + + + + True + + + + + + True + Quit + True + + + + + + + + + + + True + _Edit + True + + + + + + + True + gtk-cut + True + + + + + + + True + gtk-copy + True + + + + + + + True + gtk-paste + True + + + + + + + True + gtk-delete + True + + + + + + + + + + + True + _View + True + + + + + + + True + Zoom in + True + + + + + + + True + Zoom out + True + + + + + + + True + Zoom extended + True + + + + + + + True + + + + + + True + Go to time + True + + + + + + + True + Show time frame + True + + + + + + + + + + + True + Tools + True + + + + + + + True + Move viewer up + True + + + + + + + True + Move viewer down + True + + + + + + + True + Remove viewer + True + + + + + + + True + + + + + + True + Insert viewer test + True + + + + + + + + + + + True + Plugins + True + + + + + + + True + Load module + True + + + + + + + True + Unload module + True + + + + + + + True + Add module search path + True + + + + + + + + + + + True + Options + True + + + + + + + True + Color + True + + + + + + + True + + + + + + True + Filter + True + + + + + + + True + Save configuration + True + + + + + + + + + + 0 + False + False + + + + + + True + + + + True + _Help + True + + + + + + + True + Content + True + + + + + + + True + + + + + + True + About... + True + + + + + + + + + + 0 + False + False + GTK_PACK_END + + + + + 0 + False + False + + + + + + True + GTK_ORIENTATION_HORIZONTAL + GTK_TOOLBAR_ICONS + True + + + + 1 + True + New window with empty trace set + + True + filenew.png + + + + + + + 1 + True + open a trace set + + True + fileopen.png + + + + + + + 1 + True + Add a trace + + True + edit_add_22.png + + + + + + + 1 + True + Remove a trace + + True + edit_remove_22.png + + + + + + + 1 + True + save the current trace set + + True + filesave.png + + + + + + + 1 + True + save as + + True + filesaveas.png + + + + + + + 1 + True + Zoom in + + True + stock_zoom_in_24.png + True + + + + True + + + + + + 1 + True + Zoom out + + True + stock_zoom_out_24.png + + + + + + + 1 + True + Zoom extended + + True + stock_zoom_fit_24.png + + + + + + + 1 + True + Go to time + + True + gtk-jump-to.png + + + + + + + 1 + True + Show time frame + + True + mini-display.xpm + + + + + + + 1 + True + Move up current viewer + + True + 1uparrow.png + True + + + + True + + + + + + 1 + True + Move down current viewer + + True + 1downarrow.png + + + + + + + 1 + True + Delete current viewer + + True + remove.png + + + + + + 0 + False + False + + + + + + True + GTK_ORIENTATION_HORIZONTAL + GTK_TOOLBAR_BOTH + True + + + + + + + 0 + False + False + + + + + + True + True + True + True + GTK_POS_TOP + False + False + + + + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + 0 + True + True + + + + + + True + True + + + 0 + False + False + + + + + + + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.gladep b/ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.gladep new file mode 100644 index 00000000..2576206d --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/mainwin.gladep @@ -0,0 +1,8 @@ + + + + + MainWin + mainwin + FALSE + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/1downarrow.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/1downarrow.png new file mode 100644 index 0000000000000000000000000000000000000000..30e060241259da35d42c04c9253a43512514dd3d GIT binary patch literal 188 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!D3?x-;bCrM;OS+@4BLl<6e(pbstUx|nfKQ0) z|NsAi%+N!Z>wpwvNswQ#gPGOLZy-*Rx4R2N2dk_Hki%Kv5n0T@z%2;EjP)t;6M=&4 zC7!;n>=!ttIV9NK`XWGf$a}gthE&W+PHON V)~1Sk`vR3Rc)I$ztaD0e0s!P7E}H-V literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/1uparrow.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/1uparrow.png new file mode 100644 index 0000000000000000000000000000000000000000..7bb1b688e5ecb78a917f957c5c1e227195945bca GIT binary patch literal 188 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!D3?x-;bCrM;OS+@4BLl<6e(pbstUx|nfKQ0) z|NsAi%+N!Z>wpwvNswQ#gPGOLZy-*Rx4R2N2dk_Hki%Kv5n0T@z%2;EjP)t;6M=&4 zC7!;n>=!ttImEPIU6u3)3dwuAIEGZrNltKJ?cwD)!!B_{-rz%h!i4_^6aKUN$}v<` Wvexc@`TQMFDTAl0pUXO@geCw55-^Sc literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/edit_add_22.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/edit_add_22.png new file mode 100644 index 0000000000000000000000000000000000000000..c46aed2b163e1586e77d40d225fb0d03ff9cf18b GIT binary patch literal 820 zcmV-41Izr0P)S010qNS#tmY3k?7O3k?D72f!=<000McNliru z(E}O-Dl@-NyJi3Y01yld;JkRZW0nvDvAV^0+lLNPzk{a zTJ=;_LJ0UHkoc$Iz_lkN5aPm>D*Z^^FF9@#H;!vNvAy1%*`1dIDkWfVIP}uzG+)n8 z?>sYl;dPVB+q`o98~NzM`K}drN}LqRS zLu{sLR7>oSW~|@2L;B;*47dV;=53XTR6W1?v|B5z!)26_Irj*$|PM?|EpgiPMzGI(EkqeUtKJ zaLCiWXaBq6@ana%#vfk1z;d%ep;+Sl<|ZD{i!*k{Gf=Qp@Mx4vgoOZB&x*Ac=NyGX zfoZ?3=7Gx}yuZoEpI>EdeHAA{lEUaA`w`(6-%@ab%^b=0O_q26 zVA^lbtypQ#V|8tXYQ4tPWJI%s-cpmthlVJ1m`oTX8M_xhA&LwFq)zahWB2CI^D_n_ z--A>jb&BVSVP~8$Nx@fwrxcNca^TS@1!$$PPLLN>iCPGr&ElA?Nx`;ld69i_mh z8U*-SBckxN=FLixwJ<>cgC+VH_hl4HsqD(NFL}2&K&+-UoZxvHUx!$rpBUPQhDPY4 zl%g31IDui3k^qRz2Lo)~x`%h;7yP&0p+8Ab8lIT}?$W1pBTHu-Q#S$C-+m%EdyaBq z$zsF7gWHIi9RnW=rn2(3)ax|>(lo>KJXXH`4)fkQCN^ViGqi%*{T9KmKm7GDv0>Ej zVFr6Rm(2ZcO#5v$?Z2D{%V#7RO-Up3_nH%!CYDL3gBk2BY(jd`#z~TYW%|m%Cn>*0 y0a_r(jFLb+c=6%` zR&fq zH3k257!TE(nE}R`7^bUi;`GrO9-n-At)C>St zK2MSuqF7TZmnjsAlqwZEoe0l!(K^AeZuUIyz#+N$xvM;X_7w3vM1)pH6T~q=Y;Z)_ z4K;N?pjh{rYBbrZwyF6c)6Ej^mtNvmH~AIpT%4XHo6E4%F=!*yMQB-vhE+HY*o=qo zrHQ;8VQz%oOvrYt!`DiKR;AYW6bIp;_`O8A8Bo%oT!&`IkXXoi3WXvt25lg*5F5dW zWxte;I7h)UMBmXSE@TkCt6)abvI> z3Hb6Ev$a9^<`szvjy)g1J#NuPP0YqB>6y#WY9M}_c v2byk4P$7J`)cug(qbCkGb86s0|L?^QhPx-x0T!hq00000NkvXXu0mjfR$)YT literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filenew.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filenew.png new file mode 100644 index 0000000000000000000000000000000000000000..cba0053d37a32be280f3ef794028265f9ed4824f GIT binary patch literal 1316 zcmV+<1>5?GP)0DOV1(I`Ooe8^1z zlJde~RO&cFRAX6-OT*zXT5B*2nwpx(&(B{3F_!~)p5)Gz{iv&75|796Ja5Uma5#+R z&moyi(%Ra}x^?S_Mx#Wxban$(%PM$&!`DSxgPXWW-}%$n_D1}E|Drm>FbGFV>FVlY zVq$_|et?MWM=H%t0lrZ4+hQt#mT8=UuSnIerJ$ey(_Aci=gys^Z%i;Wc$r@gA7X5D zjNYEJ0HI}<$W6tb3)O9=u(BC@>L9ULj7%o8WUb{h2^QpI2W{Hh+Ni9mK~9^*0=RxK zxXN*;otTuS@HDx0-HYjDe{M}h10rt-@%v%CzjtuO_beg15HQFuUWFa0#XzAv7wu&z zEwTyd2qW7OQ>dwb z(8{G|bqzK3w}DUb?_U=w!Iw$OY291XXxB48P4;i9|@!Ce2G0>EvJCSUk` zdnmSc^8Hss70s-yzZay7RxU^vr5tcF{CVsgJ!b}SRy={fyo0iEG1cW|_)U!#F4}X^ zB7+j{tb**}2V>9dNbUG&zj%7+;yD?=5(mSahBzQITsYfLZ}%{%s+Y;Be2}JwJ7`=} zM^P{rq=)h{D3L*V4qCXg3T9lSfaH7M%I^)U&@uB$&~9pWaxEQ96NDKeuVghX_q5PZ zzlOq4Xi3`wC@JS$G#&cLJAVJ<*hoQP*v3r_(tD~0AtepXD=AwM;KtY}MV2N~Y?JFZ zvr8h~xvv*lH_cbD;72oZLXVjkjK+F6edt%6NGe0?02jN5X=#h#3;3A0dKNd`j?A+_ zdfAN?S%CItU<>zPo-8_(*T*=%|0hnI7e_ukx`xr}H^~$|#DV?S7$23m@iQbwhH=w3 zP@a=*u7h?nv(L*am>f^tJ>^>cAN-Kn`&*B?@JNUKVEg*}sjlec%<+fmIkbz^$R*+wy?d#q7lZ0000!M6QCJJ4fHj~!3^^>Y^x%K|F0fM*aXkJ#8; zSyLIWsju-`T&15lf^8i+)la_wtXi(D-;$|JGew&sF#;HmR$9-vQ;zD9Nx4 z0!Of|8CX-(=pU34q?Abq)oL}?Z(QFCIIO-+djLw&-MZ-e)au+F^0Ir7HN+CCLdne-J2cd~)LyfTBDo&uHvk zi{0kLZg(&_GZToWh>{7cT3tBpZ}g9whFLWgi(B+aPe1TZs%(~EFj!X1)Y(#BeQjbQ z5^xlk^`&Y)K69@HQw1avu-oi79Jx$HV}WQq5hzG25-5r=ZVunvqDOjuNR}!Fph_t} ztgEY|qvL&aU8niA_gVn7ssQ(A4OA7R38s`tsbWe=UY-k!MIk(Ww*_F0%Xzx{r|wDP zPWYF_C#?!0UO8~!0H$eT7zW=QJB+4jv>rN&6^ItqA*IBWD$>ll zhgtv<1Ks;sXu$Mgi(oJ)&zw1fq9|yZhOX;qnwFmLJJJEbY)L&9)qjik3Kmu6 z&+mVvu(*`)KtDiK&d+@szx?e7Kuk3ZgPEBboK9z2g=v~;?>Mv%P1AVe*jE6|xdRy` zyE`_Ho=C8=sDz@DGUnrR1wFt2+728CMiiUPMpsu?255@pVX~vIxAM`eFY(xDFFD~W zXbA%?p%K2;OJPYFx~8M+Iyp9bsyZGZ-(t7huSOz~))OaA;B-3idc7Eik#=3zGsevu zYMC4Tn_HvfOy3-4HX$i2^(0$Ma`oZ`?qB@+Enote5G-85RX40Ea>$ddBW?VJJqKw*iZ4Av|zx2{;g2e50j_yk2i}Wo6~NilVS{ z=S~_L8VH3#X`=S_c1Bh|i{0Vm*2s;l;0rC7-O@x=RaHAY9?zkioE&!V-c3zS4WUqo z^XJbKDSnRW$$uURz8t|4BA?IqvfJ%`)8TNCo107boR695$g<$D=sn0{^T~kN)YR0a za5#KgQIt6Fgx40O|6J#?;QvLzqZ9>r@ND)1ec8YP{slSgEMz}>py~hs002ovPDHLk FV1mhORek^f literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filesave.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/filesave.png new file mode 100644 index 0000000000000000000000000000000000000000..6a9adc13ce726f6e31379c706b7e8bd15a0615c7 GIT binary patch literal 595 zcmV-Z0<8UsP)z2EII1t zv6KTi=X_hKK;(-m!mIc1))F1wys>JuP=N?_93LETG$)Z2s+CVG8ad~v*X!JW@Tjn9 zS=DNFJCTS`tJM$@Lg0?Jd1WGdU;_=!BBF)a z10@iIvLFat7cFu&ZQHjEp~Z|r3n4P8P3?lB&Ddizg6WlNT6yapXY`(PTId~oW{dvt z!Fhb=cmC%bz9UYG(*X3(e62Sa1QsqDfrUX+PF}1|Q(|bQRIkxkSS+Bi*o8*(GkL9Q z0YZH#nD|Br4vU0@O?ipm;hYB4FOG8pY4{h$TDXWMeg^MI2i6A-rhsD z&Lf)6vZt|e#hqFKD5U~WbTtS8)kwo$dItv?A0Ox4n8%rpWsV*CNNaPM=T9f8^bT^q zJ;vqZsg0nTLV&g`i*PthB9S2fc$6RCzwygmV0o#^KsH2c(*a^F2QXS~JlZ-C0LB=y z*(}#@-a>1QF{YLzgut>agb<`sscjwAcF|gsPN&gY*I+?A=qshrT5k^u613J7i^WZe zfs)DOI=5RoGR819HASIN!1Fw$lt?KV85yCkuMedZ6B84(wYBZ+2*C3^hKGj%$mMbX zEG{nA=6AfKz_OGQ0Nb`}?MkIm1O4^Y);f|>lFQ|gQsQ~uCeT)Q6jWzC9*@rjgSKt2 zO9~2gtsKX>1AGQP0Zssl0&!MqC%S3X)^dS4R*QD+e-T|1{|XA?|LG57Xg|)v#m!g% O0000 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 STLtR?0000 c #EAE8E3", +", c #969491", +"' c #F6F4F1", +") c #81807C", +"! c #E5E3DE", +"~ c #000000", +"{ c #928F8B", +"] c #FBFBFA", +"^ c #F7F5F2", +"/ c #F5F3F0", +"( c #F7F6F4", +"_ c #B5B2AC", +": c #A09C97", +"< c #F0EFEB", +"[ c #E4E2DD", +"} c #AEABA6", +"| c #92908B", +"1 c #E8E6E1", +"2 c #B0ADA7", +"3 c #F7F6F2", +"4 c #F5F4F0", +"5 c #6B6A68", +"6 c #83817E", +"7 c #E1DFDA", +"8 c #E2DFD9", +"9 c #E2E0DB", +"0 c #E3E1DC", +"a c #E6E4DF", +" ", +" . . . . . . ", +". . ", +" ", +". . ", +" .+......... ", +". .@#########$.", +" .#%&*#*=*-;>.", +". .#*,=*=*')'!.", +" ~ .#**{]*^)*/!.", +" .#*(_)#):-<[.", +" .#(}**)^^|1[.", +" .#2*/34^/>51.", +" .678887990a$.", +" ........... ", +" "}; diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/remove.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/remove.png new file mode 100644 index 0000000000000000000000000000000000000000..8127ee498c1303191c42462abd6b2e0adf8a9379 GIT binary patch literal 236 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!73?$#)eFPFrM`2{`sf1#T%0LyiFMcd)>mBeAGNk1oy`TT`#rChpw_GJq_CoaM>qZjK#Q8;?CY*xEPk7ha&1#*C00`%W{(dn&ky?d&y`eH|u>S?J} z@OxdTZU?5*CicUFG-NF~LYeL9(PAf#A|T;8J`@a8^fmhxG1zl}*Kgi&xL%>zukid@ z3&z$oF0~S;x2~zr$KSBh;KYjg0}8M7Z`f0RccQ0b)_f`mVv+uEEll@ylj1 zS&MkoL~1E)nJ${WfV(sUJ+`s5w47xotd-gh4UGWs;n@`uU&k=h+ej^etw+8T^NIjF zxAT4^vbxU9YzBai{wIjWE;_I0V{=*@nOq@fCXjpclZ7pqMIi}bf1vBe15dDLz@=6q zP_QwOS}I>Txq^`lBa_P$>CLI9z-M5tTu7FX@i{x^J})zSej~MsnFu43tC)#3q!z(S z&cDq>K8@P8wFoQ#@p35(Kn0pA8oGyt8t5%d8(ZJ`X2xg7^;C2Q*Z{r*VLm7h6!lKo|() z23LgOXuQoO2Xl(~2R!M2A*e$x!32yaK}|H-Rf7;jL{~H(Mm(5idb+!+dk=9MC5|qO zTkxQ|s(7FGzV*7Q;D2sfv57A9mdwc%r z)2I5-&=55>HI$c^Q(aw6O-&7V?%W|3i&0iqMp;=Ijg5`iwk_7z*Zc0@zyI#!2JYKze#o^(h{^iS; z383pTfBQ3gS9VR1p83ss_NJbLs9rIcB;imIxryxG}V{qEhnR903JjYf$? zB19q)gb<-~-}g~U;dx$IQMp`>gM$MeKYlD-*EKHPWTh0ErlIRPN-55Ms$a4w%$)~G zDe*k-m&`6mq?Fp<-Q5jqePCdKXV0D?r3~%7vs5a@@bEC6=i$08TU%QwrS^*gf*@G_ z@Zkgbd>+?z!zf+X#c`a_T-U{Q-7tf~_}ttazV9y=1qdNBnM{W5?QLw^4y8z?QVa|X zVB0p1er3Qc9Fk*tX5LZ{K+T{yjjZD8RC;4JqZq*w`4BWnIu$DTQTO;dsHM zl$@TPGCn?z@B0hD+bho^!!TNal_yW0=p!Q|7>0qa>tW6Nz8`M1>$>D}ImXAwnV+AR z!0*7jE6*a|_oJGoEo^OV^{uU~iTe6_N=r*|T{o1-aU3kmVsmqov9U2eeflJU9PkHl z0{nU1aUBO@nx;(%Av!xcI%sQaqoJVzfSsKkmX?-STwDZL0A2!bfU2`#kAWA!>~$AT z9QY0B15Dt-+4w%Ne72#-z#%|GL&GMZ?d|OezylIz>#l9_EA0H5<8(UhwYIj}!0DN6 z@teGQ@B|v=@)Zy_*J{ha3S4=mg^04Zl*(NBlRyKXRT6 UX2HdmmH+?%07*qoM6N<$f)LCR!vFvP literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_in_24.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_in_24.png new file mode 100644 index 0000000000000000000000000000000000000000..1ac4864d4a0c95a022e19ef38b4544711de39f1e GIT binary patch literal 1099 zcmV-R1ho5!P)af{SP@!vXJ%)ntuV;yBK7U0vPNwY9Zh{xzVtw>Ncs zeEdS!^^)P?VQOk>C@n2T2!ZRm*tU&nntb^1f#=Vkv%0$KM5EE+gM))>vk4THp`oD% z*=+Ww$B!SEjE|2KkH?8bB2-mX5s$~IuC68)ixCco35Ub9w6tIthJ5qp&B(ob_kKJ* zJw3h=P$(3>({;URVq$`DI7~DerMkMBa5zjb7$gt~5C{Ya27^Q*5kjF5&CSj1?d{3^ z{r%4^%lhV101436)|PTzw`Xi@jPmkwqR}YvcpOdB2m}H=di02afdL;Pr6d#z(bUvL zI-SPzyq>D6s?@cBTrM|~N~Nf+ttAu+QBhHW5CSPBLj2h#Ap}AQA0nlst*wn@GKpar zBi8~f%hJ2MyU{d_NF;&~0?+gCJnt{gMcY-o5Q6^xew0%BrvN1YN~wnW`g(%FpdWl- zV89P>Wj1_3CX?~?`}gkyG~5J02ti3n2}&uHQh1){!#9vmD5V19lc$8k_fVVWkkZBr-|*xlVlDRp>l4?NFXSz21c zG))SH0+wY_C=`6%bzNN7^=+nUVi*RNWnozsi;Ii6uDfzAKuVd(WHMy4Sq#GRMv$L~knue4TP1F272qFCb6j#Q@ z#RZd-lWc8mEd#wbP4aJ2%B`cLqpv=G{3zSo+x_Mh%VijbU!HtE&)L}-Gcz-+uC6-3 z*Fg5hRpGj>CWKht-Q6A8+}xD)_4SmMmHEMo^*%p8XM1~_>FH@+zkclidEiUn6!`hJ zb)5iWLWpNl%ASW0AJWy;MPp+l00##Lyn6MDmoHxeECWx07rQWzN|_ygF>@YIfg RUN-;$002ovPDHLkV1jl}0RjL3 literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_out_24.png b/ltt/branches/poly/lttv/modules/gui/mainWin/pixmaps/stock_zoom_out_24.png new file mode 100644 index 0000000000000000000000000000000000000000..d67a87de533e307cb0e95ab2623259d98eb1adae GIT binary patch literal 1074 zcmV-21kL-2P)ZcG>Ma%D2N{kj*D)b>fpvF=zwm5 z5E-mXbGYn7^T$p^GpsN-Jnrg5T1P7C|(AOa;G)2(2OS^S;-Oc{m-T zrPvDx4(A=t@1Aow=RWwKkErw^ola*8g~FI=nwsM{ZAvMCBVg&#qer>*_4ObB6JUIN z{ORWA=36P{z~JB@Po6v>9*^U?E`>sYwY4>7XJ>I7XTG_)`Q_^B>TmxV@a);M%<1Xr zdri}-Mn^|!Y;2^ux*8z_uIpmkHiltva&p4EckftUUUp)!*y#TLe#LA8Wo2Y!N*^MnBpeRY-ri0&o5l0I zf%^LTOhrJUP#DW(GBh^|6Wo(=@fdzCMD% zAkk$*6OgHj5^FtBYK%d*(n*+D6FRIvx1=Pk|6&0!b@mStg@CYELSdRfXg!!Xcw z-M7!q&f>c6QbmB2GMCHc$mjFux=yK7Lf7?A#57GxrIIhEX`<^o+uPgB%*+7fDh`@u zS%wgz`{3XpH8?nk>$+H$<*x_JvaoI2&!P+~7K^-k^@_8zvw2|Zu1Wq=O8NWo@$on3 z=jXD!yW4MGIjFAdetAlz5?5DOym|A6<>h4u_zuY5xhh=O4GJOVcXoEhK79BfTU%SH zsj2aUm+M_D7TMa`;`Qs-tgNg!KneI7xCDN^Z(S#WxDev4lyacIzn|XTUQ($P0Q>v< zEG{mxu&@9y54;5417BQU_5%18`02g}CkcE7i~-t>AvywFLpdzpl%ce8{Ia30zH0O({*&9N-ElJ|v`^m66S6?PM}( sKQ!Pb +#endif + +#include +#include + +#include "callbacks.h" +#include "interface.h" +#include "support.h" +#include "mainWindow.h" + + +extern systemView * gSysView; + +typedef void (*call_Event_Selected_Hook)(void * call_data); +extern call_Event_Selected_Hook selected_hook; +extern view_constructor gConstructor; + +mainWindow * get_window_data_struct(GtkWidget * widget); + +/* test part */ +void insertView(GtkWidget* widget, view_constructor constructor); + +void +on_textview1_grab_focus (GtkTextView *text_view, + gpointer user_data) +{ + GtkWidget * widget; + GtkCustom * custom = (GtkCustom*)user_data; + widget = gtk_widget_get_parent((GtkWidget*)text_view); + widget = gtk_widget_get_parent(widget); + gtk_custom_set_focus((GtkWidget*)custom, (gpointer)widget); +} + +void +insertViewTest(GtkMenuItem *menuitem, gpointer user_data) +{ + guint val = 20; + insertView((GtkWidget*)menuitem, gConstructor); + selected_hook(&val); +} + +void +on_insert_viewer_test_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + GtkWidget *scrolledwindow1, *textview1, *label; + static int count = 0; + char str[64]; + GtkCustom * custom; + GtkTextBuffer* buf; + + mainWindow * mwData; + mwData = get_window_data_struct((GtkWidget*)menuitem); + if(!mwData->CurrentTab) return; + custom = mwData->CurrentTab->custom; + + sprintf(str,"label : %d",++count); + scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (scrolledwindow1); + label = gtk_label_new(str); + gtk_widget_show(label); + + gtk_custom_widget_add(custom, scrolledwindow1); + gtk_widget_set_size_request ((GtkWidget*)scrolledwindow1, 800, 100); + + textview1 = gtk_text_view_new (); + gtk_widget_show (textview1); + gtk_container_add (GTK_CONTAINER (scrolledwindow1), textview1); + buf = gtk_text_view_get_buffer((GtkTextView*)textview1); + sprintf(str,"text view : %d",count); + gtk_text_buffer_set_text(buf,str, -1); + + g_signal_connect ((gpointer) textview1, "grab_focus", + G_CALLBACK (on_textview1_grab_focus), custom); +} + +/* end of test part */ + + +/* internal functions */ +void insertView(GtkWidget* widget, view_constructor constructor) +{ + GtkCustom * custom; + mainWindow * mwData; + + mwData = get_window_data_struct(widget); + if(!mwData->CurrentTab) return; + custom = mwData->CurrentTab->custom; + + gtk_custom_widget_add(custom, (GtkWidget*)constructor(mwData)); +} + +void get_label_string (GtkWidget * text, gchar * label) +{ + GtkEntry * entry = (GtkEntry*)text; + if(strlen(gtk_entry_get_text(entry))!=0) + strcpy(label,gtk_entry_get_text(entry)); +} + +void get_label(GtkWindow * mw, gchar * str) +{ + GtkWidget * dialogue; + GtkWidget * text; + GtkWidget * label; + gint id; + + strcpy(str,"Page"); //default label + + dialogue = gtk_dialog_new_with_buttons("Get the name of the tab",mw, + GTK_DIALOG_MODAL, + GTK_STOCK_OK,GTK_RESPONSE_ACCEPT, + GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT, + NULL); + + label = gtk_label_new("Please input tab's name"); + gtk_widget_show(label); + + text = gtk_entry_new(); + gtk_widget_show(text); + + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0); + + id = gtk_dialog_run(GTK_DIALOG(dialogue)); + switch(id){ + case GTK_RESPONSE_ACCEPT: + get_label_string(text,str); + gtk_widget_destroy(dialogue); + break; + case GTK_RESPONSE_REJECT: + default: + gtk_widget_destroy(dialogue); + break; + } +} + +mainWindow * get_window_data_struct(GtkWidget * widget) +{ + GtkWidget * mw; + mainWindow * mwData; + + mw = lookup_widget(widget, "MWindow"); + if(mw == NULL){ + g_printf("Main window does not exist\n"); + return; + } + + mwData = (mainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow"); + if(mwData == NULL){ + g_printf("Main window data does not exist\n"); + return; + } + return mwData; +} + +void createNewWindow(GtkWidget* widget, gpointer user_data, gboolean clone) +{ + GtkWidget * mw = NULL; /* Main window */ + systemView * sv = NULL; /* System view */ + systemView * newSv; /* New system view displayed in the new window */ + GtkWidget * newWindow; /* New generated main window */ + mainWindow * newMWindow;/* New main window structure */ + + //test + GtkWidget * ToolMenuTitle_menu, *insert_view; + //end + + mw = lookup_widget (widget, "MWindow"); + if(mw == NULL){ + g_printf("Can not find main window\n"); + return; + } + + sv = (systemView *)g_object_get_data(G_OBJECT(mw),"systemView"); + if(sv == NULL){ + g_printf("Can not find system view\n"); + return; + } + + newMWindow = g_new(mainWindow, 1); + newWindow = create_MWindow(); + gtk_widget_show (newWindow); + + + newSv = g_new(systemView, 1); + while(sv->Next) sv = sv->Next; + sv->Next = newSv; + + newSv->EventDB = NULL; + newSv->SystemInfo = NULL; + newSv->Options = NULL; + newSv->Next = NULL; + newSv->Window = newMWindow; + + newMWindow->MWindow = newWindow; + newMWindow->Tab = NULL; + newMWindow->CurrentTab = NULL; + newMWindow->SystemView = newSv; + // newMWindow->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL)); + + //test yxx + ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"ToolMenuTitle_menu"); + insert_view = gtk_menu_item_new_with_mnemonic (_("insert_view")); + gtk_widget_show (insert_view); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), insert_view); + g_signal_connect ((gpointer) insert_view, "activate", + G_CALLBACK (insertViewTest), + NULL); + //end + + g_object_set_data(G_OBJECT(newWindow), "systemView", (gpointer)newSv); + g_object_set_data(G_OBJECT(newWindow), "mainWindow", (gpointer)newMWindow); + + if(clone){ + g_printf("Clone : use the same traceset\n"); + }else{ + g_printf("Empty : traceset is set to NULL\n"); + } +} + +void move_up_viewer(GtkWidget * widget, gpointer user_data) +{ + mainWindow * mw = get_window_data_struct(widget); + if(!mw->CurrentTab) return; + gtk_custom_widget_move_up(mw->CurrentTab->custom); +} + +void move_down_viewer(GtkWidget * widget, gpointer user_data) +{ + mainWindow * mw = get_window_data_struct(widget); + if(!mw->CurrentTab) return; + gtk_custom_widget_move_down(mw->CurrentTab->custom); +} + +void delete_viewer(GtkWidget * widget, gpointer user_data) +{ + mainWindow * mw = get_window_data_struct(widget); + if(!mw->CurrentTab) return; + gtk_custom_widget_delete(mw->CurrentTab->custom); +} + +void open_traceset(GtkWidget * widget, gpointer user_data) +{ + g_printf("Open a trace set\n"); +} + +void add_trace(GtkWidget * widget, gpointer user_data) +{ + g_printf("add a trace to a trace set\n"); +} + +void remove_trace(GtkWidget * widget, gpointer user_data) +{ + g_printf("remove a trace from a trace set\n"); +} + +void save(GtkWidget * widget, gpointer user_data) +{ + g_printf("Save\n"); +} + +void save_as(GtkWidget * widget, gpointer user_data) +{ + g_printf("Save as\n"); +} + +void zoom_in(GtkWidget * widget, gpointer user_data) +{ + g_printf("Zoom in\n"); +} + +void zoom_out(GtkWidget * widget, gpointer user_data) +{ + g_printf("Zoom out\n"); +} + +void zoom_extended(GtkWidget * widget, gpointer user_data) +{ + g_printf("Zoom extended\n"); +} + +void go_to_time(GtkWidget * widget, gpointer user_data) +{ + g_printf("Go to time\n"); +} + +void show_time_frame(GtkWidget * widget, gpointer user_data) +{ + g_printf("Show time frame\n"); +} + + +/* callback function */ + +void +on_empty_traceset_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + createNewWindow((GtkWidget*)menuitem, user_data, FALSE); +} + + +void +on_clone_traceset_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + createNewWindow((GtkWidget*)menuitem, user_data, TRUE); +} + + +void +on_tab_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + GList * list; + gchar label[64]; + + tab * tmpTab; + GtkWidget * pane; + mainWindow * mwData; + GtkNotebook * notebook = (GtkNotebook *)lookup_widget((GtkWidget*)menuitem, "MNotebook"); + if(notebook == NULL){ + g_printf("Notebook does not exist\n"); + return; + } + + mwData = get_window_data_struct((GtkWidget*)menuitem); + + tmpTab = mwData->Tab; + while(tmpTab && tmpTab->Next) tmpTab = tmpTab->Next; + if(!tmpTab){ + tmpTab = g_new(tab,1); + mwData->Tab = tmpTab; + }else{ + tmpTab->Next = g_new(tab,1); + tmpTab = tmpTab->Next; + } + // mwData->CurrentTab = tmpTab; + tmpTab->custom = (GtkCustom*)gtk_custom_new(); + gtk_widget_show((GtkWidget*)tmpTab->custom); + tmpTab->Next = NULL; + + get_label((GtkWindow*)mwData->MWindow, label); + tmpTab->label = gtk_label_new (label); + gtk_widget_show (tmpTab->label); + + gtk_notebook_append_page(notebook, (GtkWidget*)tmpTab->custom, tmpTab->label); + + list = gtk_container_get_children(GTK_CONTAINER(notebook)); + gtk_notebook_set_current_page(notebook,g_list_length(list)-1); +} + + +void +on_open_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + open_traceset((GtkWidget*)menuitem, user_data); +} + + +void +on_close_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Close\n"); +} + + +void +on_close_tab_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Close tab\n"); +} + + +void +on_add_trace_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + add_trace((GtkWidget*)menuitem, user_data); +} + + +void +on_remove_trace_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + remove_trace((GtkWidget*)menuitem, user_data); +} + + +void +on_save_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + save((GtkWidget*)menuitem, user_data); +} + + +void +on_save_as_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + save_as((GtkWidget*)menuitem, user_data); +} + + +void +on_quit_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + on_MWindow_destroy(GTK_OBJECT(menuitem), user_data); +} + + +void +on_cut_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Cut\n"); +} + + +void +on_copy_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Copye\n"); +} + + +void +on_paste_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Paste\n"); +} + + +void +on_delete_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Delete\n"); +} + + +void +on_zoom_in_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + zoom_in((GtkWidget*)menuitem, user_data); +} + + +void +on_zoom_out_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + zoom_out((GtkWidget*)menuitem, user_data); +} + + +void +on_zoom_extended_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + zoom_extended((GtkWidget*)menuitem, user_data); +} + + +void +on_go_to_time_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + go_to_time((GtkWidget*)menuitem, user_data); +} + + +void +on_show_time_frame_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + show_time_frame((GtkWidget*)menuitem, user_data); +} + + +void +on_move_viewer_up_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + move_up_viewer((GtkWidget*)menuitem, user_data); +} + + +void +on_move_viewer_down_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + move_down_viewer((GtkWidget*)menuitem, user_data); +} + + +void +on_remove_viewer_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + delete_viewer((GtkWidget*)menuitem, user_data); +} + + +void +on_load_module_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Load module\n"); +} + + +void +on_unload_module_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Unload module\n"); +} + + +void +on_add_module_search_path_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Add module search path\n"); +} + + +void +on_color_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Color\n"); +} + + +void +on_filter_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Filter\n"); +} + + +void +on_save_configuration_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Save configuration\n"); +} + + +void +on_content_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("Content\n"); +} + + +void +on_about_activate (GtkMenuItem *menuitem, + gpointer user_data) +{ + g_printf("About...\n"); +} + + +void +on_button_new_clicked (GtkButton *button, + gpointer user_data) +{ + createNewWindow((GtkWidget*)button, user_data, FALSE); +} + + +void +on_button_open_clicked (GtkButton *button, + gpointer user_data) +{ + open_traceset((GtkWidget*)button, user_data); +} + + +void +on_button_add_trace_clicked (GtkButton *button, + gpointer user_data) +{ + add_trace((GtkWidget*)button, user_data); +} + + +void +on_button_remove_trace_clicked (GtkButton *button, + gpointer user_data) +{ + remove_trace((GtkWidget*)button, user_data); +} + + +void +on_button_save_clicked (GtkButton *button, + gpointer user_data) +{ + save((GtkWidget*)button, user_data); +} + + +void +on_button_save_as_clicked (GtkButton *button, + gpointer user_data) +{ + save_as((GtkWidget*)button, user_data); +} + + +void +on_button_zoom_in_clicked (GtkButton *button, + gpointer user_data) +{ + zoom_in((GtkWidget*)button, user_data); +} + + +void +on_button_zoom_out_clicked (GtkButton *button, + gpointer user_data) +{ + zoom_out((GtkWidget*)button, user_data); +} + + +void +on_button_zoom_extended_clicked (GtkButton *button, + gpointer user_data) +{ + zoom_extended((GtkWidget*)button, user_data); +} + + +void +on_button_go_to_time_clicked (GtkButton *button, + gpointer user_data) +{ + go_to_time((GtkWidget*)button, user_data); +} + + +void +on_button_show_time_frame_clicked (GtkButton *button, + gpointer user_data) +{ + show_time_frame((GtkWidget*)button, user_data); +} + + +void +on_button_move_up_clicked (GtkButton *button, + gpointer user_data) +{ + move_up_viewer((GtkWidget*)button, user_data); +} + + +void +on_button_move_down_clicked (GtkButton *button, + gpointer user_data) +{ + move_down_viewer((GtkWidget*)button, user_data); +} + + +void +on_button_delete_viewer_clicked (GtkButton *button, + gpointer user_data) +{ + delete_viewer((GtkWidget*)button, user_data); +} + +void +on_MWindow_destroy (GtkObject *object, + gpointer user_data) +{ + systemView * sv = gSysView; + gint count = 0; + while(sv->Next){ + g_printf("There are : %d windows\n",++count); + sv = sv->Next; + } + g_printf("There are : %d windows\n",++count); + + gtk_main_quit (); + +} + + +void +on_MNotebook_switch_page (GtkNotebook *notebook, + GtkNotebookPage *page, + guint page_num, + gpointer user_data) +{ + mainWindow * mw = get_window_data_struct((GtkWidget*)notebook); + tab * Tab = mw->Tab; + + while(page_num){ + Tab = Tab->Next; + page_num--; + } + mw->CurrentTab = Tab; +} + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/callbacks.h b/ltt/branches/poly/lttv/modules/gui/mainWin/src/callbacks.h new file mode 100644 index 00000000..0c15b356 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/callbacks.h @@ -0,0 +1,206 @@ +#include + +/* internal functions */ + +void createNewWindow(GtkWidget* widget, gpointer user_data, gboolean clone); + + +/* callback functions*/ + +void +on_empty_traceset_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_clone_traceset_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_tab_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_open_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_close_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_close_tab_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_add_trace_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_remove_trace_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save_as_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_quit_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_cut_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_copy_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_paste_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_delete_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_zoom_in_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_zoom_out_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_zoom_extended_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_go_to_time_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_show_time_frame_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_move_viewer_up_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_move_viewer_down_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_remove_viewer_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_load_module_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_unload_module_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_add_module_search_path_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_color_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_filter_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save_configuration_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_content_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_about_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_button_new_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_open_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_add_trace_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_remove_trace_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_save_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_save_as_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_zoom_in_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_zoom_out_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_zoom_extended_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_go_to_time_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_show_time_frame_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_move_up_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_move_down_clicked (GtkButton *button, + gpointer user_data); + +void +on_button_delete_viewer_clicked (GtkButton *button, + gpointer user_data); + +void +on_MWindow_destroy (GtkObject *object, + gpointer user_data); + + +void +on_insert_viewer_test_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +insertViewTest(GtkMenuItem *menuitem, gpointer user_data); + +void +on_MNotebook_switch_page (GtkNotebook *notebook, + GtkNotebookPage *page, + guint page_num, + gpointer user_data); diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.c b/ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.c new file mode 100644 index 00000000..b0fb2ec3 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.c @@ -0,0 +1,406 @@ +#include + +#include "gtkcustom.h" +//#include "gtkintl.h" + +static void gtk_custom_class_init (GtkCustomClass *klass); +static void gtk_custom_init (GtkCustom *custom); + + +static void gtk_custom_size_request (GtkWidget *widget, + GtkRequisition *requisition); +static void gtk_custom_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); + +GType +gtk_custom_get_type (void) +{ + static GType custom_type = 0; + + if (!custom_type) + { + static const GTypeInfo custom_info = + { + sizeof (GtkCustomClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) gtk_custom_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GtkCustom), + 0, /* n_preallocs */ + (GInstanceInitFunc) gtk_custom_init, + NULL, /* value_table */ + }; + + custom_type = g_type_register_static (GTK_TYPE_PANED, "GtkCustom", + &custom_info, 0); + } + + return custom_type; +} + +static void +gtk_custom_class_init (GtkCustomClass *class) +{ + GtkWidgetClass *widget_class; + + widget_class = (GtkWidgetClass *) class; + + widget_class->size_request = gtk_custom_size_request; + widget_class->size_allocate = gtk_custom_size_allocate; +} + +static void +gtk_custom_init (GtkCustom *custom) +{ + GtkWidget * button; + + GTK_WIDGET_SET_FLAGS (custom, GTK_NO_WINDOW); + gtk_widget_set_redraw_on_allocate (GTK_WIDGET (custom), FALSE); + + custom->firstPane = NULL; + custom->lastPane = NULL; + custom->focusedPane = NULL; + custom->numChildren = 0; + + custom->vbox = NULL; + // custom->scrollWindow = NULL; + // custom->viewport = NULL; + custom->hScrollbar = NULL; +} + + +GtkWidget* gtk_custom_new () +{ + return GTK_WIDGET (g_object_new (gtk_custom_get_type (), NULL)); +} + + +void gtk_custom_set_focus (GtkWidget * widget, gpointer user_data) +{ + GtkCustom * custom = (GtkCustom*) widget; + GtkPaned * pane; + if(!custom->firstPane) return; + + + pane = custom->firstPane; + while(1){ + if((GtkWidget*)pane == (GtkWidget*)user_data){ + custom->focusedPane = pane; + break; + } + if(pane == custom->lastPane){ + custom->focusedPane = NULL; + break; + } + pane = (GtkPaned*)pane->child1; + } +} + +void gtk_custom_widget_add(GtkCustom * custom, GtkWidget * widget1) +{ + GtkPaned * tmpPane; + GtkWidget * w; + + g_return_if_fail(GTK_IS_CUSTOM(custom)); + g_object_ref(G_OBJECT(widget1)); + + + if(!custom->firstPane){ + custom->firstPane = (GtkPaned *)gtk_vpaned_new(); + custom->lastPane = custom->firstPane; + + custom->hScrollbar = gtk_hscrollbar_new (NULL); + gtk_widget_show(custom->hScrollbar); + + custom->vbox = gtk_vbox_new(FALSE,0); + gtk_widget_show(custom->vbox); + + // custom->viewport = gtk_viewport_new (NULL,NULL); + // gtk_widget_show(custom->viewport); + + // gtk_container_add(GTK_CONTAINER(custom->viewport), (GtkWidget*)custom->vbox); + gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->hScrollbar,FALSE,FALSE,0); + gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->firstPane,TRUE,TRUE,0); + + // custom->scrollWindow = gtk_scrolled_window_new (NULL, NULL); + // gtk_widget_show(custom->scrollWindow); + // gtk_container_add (GTK_CONTAINER (custom->scrollWindow), (GtkWidget*)custom->viewport); + // gtk_paned_pack1(GTK_PANED(custom), (GtkWidget*)custom->scrollWindow,FALSE, TRUE); + + gtk_paned_pack1(GTK_PANED(custom), (GtkWidget*)custom->vbox,FALSE, TRUE); + }else{ + tmpPane = custom->lastPane; + custom->lastPane = (GtkPaned *)gtk_vpaned_new(); + gtk_paned_pack1 (tmpPane,(GtkWidget*)custom->lastPane, FALSE,TRUE); + } + gtk_widget_show((GtkWidget *)custom->lastPane); + + gtk_paned_pack2 (custom->lastPane,widget1, TRUE, TRUE); + custom->focusedPane = custom->lastPane; + custom->numChildren++; + +} + +void gtk_custom_widget_delete(GtkCustom * custom) +{ + GtkPaned * tmp, *prev, *next; + + if(!custom->focusedPane) return; + + tmp = (GtkPaned*)custom->focusedPane->child2; //widget in vpaned + g_object_unref(G_OBJECT(tmp)); + + if(custom->focusedPane == custom->firstPane && + custom->focusedPane == custom->lastPane){ + // gtk_container_remove(GTK_CONTAINER(custom),(GtkWidget*)custom->scrollWindow); + gtk_container_remove(GTK_CONTAINER(custom),(GtkWidget*)custom->vbox); + custom->firstPane = NULL; + custom->lastPane = NULL; + custom->focusedPane = NULL; + }else if(custom->focusedPane == custom->firstPane && + custom->focusedPane != custom->lastPane){ + next = (GtkPaned*)custom->firstPane->child1; + g_object_ref(G_OBJECT(next)); + gtk_container_remove(GTK_CONTAINER(custom->firstPane),(GtkWidget*)next); + gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)custom->firstPane); + custom->firstPane = next; + gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->firstPane,TRUE,TRUE,0); + custom->focusedPane = custom->firstPane; + g_object_unref(G_OBJECT(next)); + }else if(custom->focusedPane != custom->firstPane && + custom->focusedPane == custom->lastPane){ + tmp = custom->lastPane; + custom->lastPane = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)custom->lastPane); + custom->focusedPane = custom->lastPane; + gtk_container_remove(GTK_CONTAINER(custom->lastPane),(GtkWidget*)tmp); + }else{ + tmp = custom->focusedPane; + prev = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)tmp); + next = (GtkPaned*)tmp->child1; + g_object_ref(G_OBJECT(next)); + gtk_container_remove(GTK_CONTAINER(custom->focusedPane),(GtkWidget*)next); + gtk_container_remove(GTK_CONTAINER(prev),(GtkWidget*)custom->focusedPane); + gtk_paned_pack1(prev, (GtkWidget*)next, FALSE, TRUE); + custom->focusedPane = next; + g_object_unref(G_OBJECT(next)); + } + + custom->numChildren--; +} + + +void gtk_custom_widget_move_up(GtkCustom * custom) +{ + GtkWidget* upWidget, *downWidget; + GtkPaned * prev,*next, *prevPrev; + + if(custom->lastPane == custom->focusedPane) return; + + // move VPane + prev = (GtkPaned*)custom->focusedPane->child1; + g_object_ref(G_OBJECT(prev)); + gtk_container_remove(GTK_CONTAINER(custom->focusedPane),(GtkWidget*)prev); + + if(prev == custom->lastPane){ + prevPrev = NULL; + custom->lastPane = custom->focusedPane; + }else{ + prevPrev = (GtkPaned*)prev->child1; + g_object_ref(G_OBJECT(prevPrev)); + gtk_container_remove(GTK_CONTAINER(prev),(GtkWidget*)prevPrev); + } + + g_object_ref(G_OBJECT(custom->focusedPane)); + if(custom->firstPane == custom->focusedPane){ + gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)custom->focusedPane); + gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)prev,TRUE,TRUE,0); + custom->firstPane = prev; + }else{ + next = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)custom->focusedPane); + gtk_container_remove(GTK_CONTAINER(next),(GtkWidget*)custom->focusedPane); + gtk_paned_pack1(GTK_PANED(next), (GtkWidget*)prev, FALSE,TRUE); + } + gtk_paned_pack1(GTK_PANED(prev),(GtkWidget*)custom->focusedPane, FALSE,TRUE); + if(prevPrev) + gtk_paned_pack1(GTK_PANED(custom->focusedPane),(GtkWidget*)prevPrev, FALSE,TRUE); + + g_object_unref(G_OBJECT(prev)); + if(prevPrev) g_object_unref(G_OBJECT(prevPrev)); + g_object_unref(G_OBJECT(custom->focusedPane)); +} + + +void gtk_custom_widget_move_down(GtkCustom * custom) +{ + GtkWidget* upWidget, *downWidget; + GtkPaned * prev,*next, *nextNext; + + if(custom->firstPane == custom->focusedPane) return; + + //move VPane + next = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)custom->focusedPane); + g_object_ref(G_OBJECT(next)); + + if(custom->lastPane == custom->focusedPane){ + prev = NULL; + custom->lastPane = next; + }else{ + prev = (GtkPaned*)custom->focusedPane->child1; + g_object_ref(G_OBJECT(prev)); + gtk_container_remove(GTK_CONTAINER(custom->focusedPane),(GtkWidget*)prev); + } + + g_object_ref(G_OBJECT(custom->focusedPane)); + gtk_container_remove(GTK_CONTAINER(next),(GtkWidget*)custom->focusedPane); + + if(next == custom->firstPane){ + custom->firstPane = custom->focusedPane; + gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)next); + gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->focusedPane,TRUE,TRUE,0); + }else{ + nextNext = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)next); + gtk_container_remove(GTK_CONTAINER(nextNext),(GtkWidget*)next); + gtk_paned_pack1(nextNext, (GtkWidget*)custom->focusedPane, FALSE, TRUE); + } + gtk_paned_pack1(custom->focusedPane,(GtkWidget*)next, FALSE,TRUE); + if(prev) + gtk_paned_pack1(next,(GtkWidget*)prev, FALSE,TRUE); + + if(prev)g_object_unref(G_OBJECT(prev)); + g_object_unref(G_OBJECT(next)); + g_object_unref(G_OBJECT(custom->focusedPane)); +} + + +static void +gtk_custom_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GtkPaned *paned = GTK_PANED (widget); + GtkRequisition child_requisition; + + requisition->width = 0; + requisition->height = 0; + + if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1)) + { + gtk_widget_size_request (paned->child1, &child_requisition); + + requisition->height = child_requisition.height; + requisition->width = child_requisition.width; + } + + if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2)) + { + gtk_widget_size_request (paned->child2, &child_requisition); + + requisition->width = MAX (requisition->width, child_requisition.width); + requisition->height += child_requisition.height; + } + + requisition->height += GTK_CONTAINER (paned)->border_width * 2; + requisition->width += GTK_CONTAINER (paned)->border_width * 2; + + if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) && + paned->child2 && GTK_WIDGET_VISIBLE (paned->child2)) + { + gint handle_size; + + gtk_widget_style_get (widget, "handle_size", &handle_size, NULL); + requisition->height += handle_size; + } + +} + +static void +gtk_custom_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GtkPaned *paned = GTK_PANED (widget); + gint border_width = GTK_CONTAINER (paned)->border_width; + + widget->allocation = *allocation; + + if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) && + paned->child2 && GTK_WIDGET_VISIBLE (paned->child2)) + { + GtkRequisition child1_requisition; + GtkRequisition child2_requisition; + GtkAllocation child1_allocation; + GtkAllocation child2_allocation; + gint handle_size; + + gtk_widget_style_get (widget, "handle_size", &handle_size, NULL); + + gtk_widget_get_child_requisition (paned->child1, &child1_requisition); + gtk_widget_get_child_requisition (paned->child2, &child2_requisition); + + gtk_paned_compute_position (paned, + MAX (1, widget->allocation.height + - handle_size + - 2 * border_width), + child1_requisition.height, + child2_requisition.height); + + paned->handle_pos.x = widget->allocation.x + border_width; + paned->handle_pos.y = widget->allocation.y + paned->child1_size + border_width; + paned->handle_pos.width = MAX (1, (gint) widget->allocation.width - 2 * border_width); + paned->handle_pos.height = handle_size; + + if (GTK_WIDGET_REALIZED (widget)) + { + if (GTK_WIDGET_MAPPED (widget)) + gdk_window_show (paned->handle); + gdk_window_move_resize (paned->handle, + paned->handle_pos.x, + paned->handle_pos.y, + paned->handle_pos.width, + handle_size); + } + + child1_allocation.width = child2_allocation.width = MAX (1, (gint) allocation->width - border_width * 2); + child1_allocation.height = MAX (1, paned->child1_size); + child1_allocation.x = child2_allocation.x = widget->allocation.x + border_width; + child1_allocation.y = widget->allocation.y + border_width; + + child2_allocation.y = child1_allocation.y + paned->child1_size + paned->handle_pos.height; + child2_allocation.height = MAX (1, widget->allocation.y + widget->allocation.height - child2_allocation.y - border_width); + + if (GTK_WIDGET_MAPPED (widget) && + paned->child1->allocation.height < child1_allocation.height) + { + gtk_widget_size_allocate (paned->child2, &child2_allocation); + gtk_widget_size_allocate (paned->child1, &child1_allocation); + } + else + { + gtk_widget_size_allocate (paned->child1, &child1_allocation); + gtk_widget_size_allocate (paned->child2, &child2_allocation); + } + } + else + { + GtkAllocation child_allocation; + + if (GTK_WIDGET_REALIZED (widget)) + gdk_window_hide (paned->handle); + + if (paned->child1) + gtk_widget_set_child_visible (paned->child1, TRUE); + if (paned->child2) + gtk_widget_set_child_visible (paned->child2, TRUE); + + child_allocation.x = widget->allocation.x + border_width; + child_allocation.y = widget->allocation.y + border_width; + child_allocation.width = MAX (1, allocation->width - 2 * border_width); + child_allocation.height = MAX (1, allocation->height - 2 * border_width); + + if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1)) + gtk_widget_size_allocate (paned->child1, &child_allocation); + else if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2)) + gtk_widget_size_allocate (paned->child2, &child_allocation); + } +} + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.h b/ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.h new file mode 100644 index 00000000..2bd174bb --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/gtkcustom.h @@ -0,0 +1,66 @@ + +#ifndef __GTK_CUSTOM_H__ +#define __GTK_CUSTOM_H__ + + +#include +#include +#include +#include + + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + +#define GTK_TYPE_CUSTOM (gtk_custom_get_type ()) +#define GTK_CUSTOM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CUSTOM, GtkCustom)) +#define GTK_CUSTOM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CUSTOM, GtkCustomClass)) +#define GTK_IS_CUSTOM(obj ) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CUSTOM)) +#define GTK_IS_CUSTOM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CUSTOM)) +#define GTK_CUSTOM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CUSTOM, GtkCustomClass)) + + +typedef struct _GtkCustom GtkCustom; +typedef struct _GtkCustomClass GtkCustomClass; + +struct _GtkCustom +{ + GtkPaned container; + + /*< public >*/ + GtkPaned * firstPane; + GtkPaned * lastPane; + GtkPaned * focusedPane; + guint numChildren; + + GtkWidget * vbox; + // GtkWidget * scrollWindow; + // GtkWidget * viewport; + GtkWidget * hScrollbar; +}; + +struct _GtkCustomClass +{ + GtkPanedClass parent_class; +}; + + +GType gtk_custom_get_type (void) G_GNUC_CONST; +GtkWidget* gtk_custom_new (void); + +void gtk_custom_set_focus (GtkWidget * widget, gpointer user_data); +void gtk_custom_widget_add(GtkCustom * custom, GtkWidget * widget1); +void gtk_custom_widget_delete(GtkCustom * custom); +void gtk_custom_widget_move_up(GtkCustom * custom); +void gtk_custom_widget_move_down(GtkCustom * custom); + + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GTK_CUSTOM_H__ */ diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.c b/ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.c new file mode 100644 index 00000000..f73b2614 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.c @@ -0,0 +1,772 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include +#include + +#include "callbacks.h" +#include "interface.h" +#include "support.h" + +#define GLADE_HOOKUP_OBJECT(component,widget,name) \ + g_object_set_data_full (G_OBJECT (component), name, \ + gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \ + g_object_set_data (G_OBJECT (component), name, widget) + +GtkWidget* +create_MWindow (void) +{ + GtkWidget *MWindow; + GtkWidget *MVbox; + GtkWidget *MMenuBox; + GtkWidget *MenuMain; + GtkWidget *FileMenuTitle; + GtkWidget *FileMenuTitle_menu; + GtkWidget *FileMenuNewTitle; + GtkWidget *FileMenuNewTitle_menu; + GtkWidget *EmptyTraceset; + GtkWidget *CloneTraceset; + GtkWidget *FileMenuNewSep; + GtkWidget *Tab; + GtkWidget *OpenTraceset; + GtkWidget *Close; + GtkWidget *CloseTab; + GtkWidget *FileMenuSeparator1; + GtkWidget *AddTrace; + GtkWidget *RemoveTrace; + GtkWidget *Save; + GtkWidget *SaveAs; + GtkWidget *FileMenuSeparator2; + GtkWidget *Quit; + GtkWidget *EditMenuTitle; + GtkWidget *EditMenuTitle_menu; + GtkWidget *Cut; + GtkWidget *Copy; + GtkWidget *Paste; + GtkWidget *Delete; + GtkWidget *ViewMenuTitle; + GtkWidget *ViewMenuTitle_menu; + GtkWidget *ZoomIn; + GtkWidget *ZoomOut; + GtkWidget *ZoomExtended; + GtkWidget *ViewMenuSeparator; + GtkWidget *GoToTime; + GtkWidget *ShowTimeFrame; + GtkWidget *ToolMenuTitle; + GtkWidget *ToolMenuTitle_menu; + GtkWidget *MoveViewerUp; + GtkWidget *MoveViewerDown; + GtkWidget *RemoveViewer; + GtkWidget *ToolMenuSeparator; + GtkWidget *insert_viewer_test; + GtkWidget *PluginMenuTitle; + GtkWidget *PluginMenuTitle_menu; + GtkWidget *LoadModule; + GtkWidget *UnloadModule; + GtkWidget *AddModuleSearchPath; + GtkWidget *OptionMenuTitle; + GtkWidget *OptionMenuTitle_menu; + GtkWidget *Color; + GtkWidget *OptMenuSeparator; + GtkWidget *OpenFilter; + GtkWidget *SaveConfiguration; + GtkWidget *MenuHelp; + GtkWidget *HelpMenuTitle; + GtkWidget *HelpMenu; + GtkWidget *Content; + GtkWidget *HelpmenuSeparator; + GtkWidget *About; + GtkWidget *MToolbar1; + GtkWidget *tmp_toolbar_icon; + GtkWidget *tlbEmptyTraceset; + GtkWidget *tlbOpenTraceset; + GtkWidget *tlbAddTrace; + GtkWidget *tlbRemoveTrace; + GtkWidget *tlbSave; + GtkWidget *tlbSaveAs; + GtkWidget *tlbZoomIn; + GtkWidget *tlbZoomOut; + GtkWidget *tlbZoomExtended; + GtkWidget *tlbGoToTime; + GtkWidget *tlbShowTimeFrame; + GtkWidget *tlbMoveViewerUp; + GtkWidget *tlbMoveViewerDown; + GtkWidget *tlbRemoveViewer; + GtkWidget *MToolbar2; + GtkWidget *MNotebook; + // GtkWidget *empty_notebook_page; + // GtkWidget *label1; + GtkWidget *MStatusbar; + GtkAccelGroup *accel_group; + + accel_group = gtk_accel_group_new (); + + MWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_size_request (MWindow, 100, 50); + gtk_window_set_title (GTK_WINDOW (MWindow), _("Main window")); + gtk_window_set_default_size (GTK_WINDOW (MWindow), 600, 400); + + MVbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (MVbox); + gtk_container_add (GTK_CONTAINER (MWindow), MVbox); + + MMenuBox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (MMenuBox); + gtk_box_pack_start (GTK_BOX (MVbox), MMenuBox, FALSE, FALSE, 0); + + MenuMain = gtk_menu_bar_new (); + gtk_widget_show (MenuMain); + gtk_box_pack_start (GTK_BOX (MMenuBox), MenuMain, FALSE, FALSE, 0); + + FileMenuTitle = gtk_menu_item_new_with_mnemonic (_("_File")); + gtk_widget_show (FileMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuMain), FileMenuTitle); + + FileMenuTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (FileMenuTitle), FileMenuTitle_menu); + + FileMenuNewTitle = gtk_menu_item_new_with_mnemonic (_("New")); + gtk_widget_show (FileMenuNewTitle); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), FileMenuNewTitle); + + FileMenuNewTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (FileMenuNewTitle), FileMenuNewTitle_menu); + + EmptyTraceset = gtk_menu_item_new_with_mnemonic (_("Empty trace set")); + gtk_widget_show (EmptyTraceset); + gtk_container_add (GTK_CONTAINER (FileMenuNewTitle_menu), EmptyTraceset); + + CloneTraceset = gtk_menu_item_new_with_mnemonic (_("Clone trace set")); + gtk_widget_show (CloneTraceset); + gtk_container_add (GTK_CONTAINER (FileMenuNewTitle_menu), CloneTraceset); + + FileMenuNewSep = gtk_menu_item_new (); + gtk_widget_show (FileMenuNewSep); + gtk_container_add (GTK_CONTAINER (FileMenuNewTitle_menu), FileMenuNewSep); + gtk_widget_set_sensitive (FileMenuNewSep, FALSE); + + Tab = gtk_menu_item_new_with_mnemonic (_("Tab")); + gtk_widget_show (Tab); + gtk_container_add (GTK_CONTAINER (FileMenuNewTitle_menu), Tab); + + OpenTraceset = gtk_menu_item_new_with_mnemonic (_("Open")); + gtk_widget_show (OpenTraceset); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), OpenTraceset); + + Close = gtk_menu_item_new_with_mnemonic (_("Close")); + gtk_widget_show (Close); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), Close); + + CloseTab = gtk_menu_item_new_with_mnemonic (_("Close Tab")); + gtk_widget_show (CloseTab); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), CloseTab); + + FileMenuSeparator1 = gtk_menu_item_new (); + gtk_widget_show (FileMenuSeparator1); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), FileMenuSeparator1); + gtk_widget_set_sensitive (FileMenuSeparator1, FALSE); + + AddTrace = gtk_menu_item_new_with_mnemonic (_("Add Trace")); + gtk_widget_show (AddTrace); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), AddTrace); + + RemoveTrace = gtk_menu_item_new_with_mnemonic (_("Remove Trace")); + gtk_widget_show (RemoveTrace); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), RemoveTrace); + + Save = gtk_menu_item_new_with_mnemonic (_("Save")); + gtk_widget_show (Save); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), Save); + + SaveAs = gtk_menu_item_new_with_mnemonic (_("Save As")); + gtk_widget_show (SaveAs); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), SaveAs); + + FileMenuSeparator2 = gtk_menu_item_new (); + gtk_widget_show (FileMenuSeparator2); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), FileMenuSeparator2); + gtk_widget_set_sensitive (FileMenuSeparator2, FALSE); + + Quit = gtk_menu_item_new_with_mnemonic (_("Quit")); + gtk_widget_show (Quit); + gtk_container_add (GTK_CONTAINER (FileMenuTitle_menu), Quit); + + EditMenuTitle = gtk_menu_item_new_with_mnemonic (_("_Edit")); + gtk_widget_show (EditMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuMain), EditMenuTitle); + + EditMenuTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (EditMenuTitle), EditMenuTitle_menu); + + Cut = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group); + gtk_widget_show (Cut); + gtk_container_add (GTK_CONTAINER (EditMenuTitle_menu), Cut); + + Copy = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group); + gtk_widget_show (Copy); + gtk_container_add (GTK_CONTAINER (EditMenuTitle_menu), Copy); + + Paste = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group); + gtk_widget_show (Paste); + gtk_container_add (GTK_CONTAINER (EditMenuTitle_menu), Paste); + + Delete = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); + gtk_widget_show (Delete); + gtk_container_add (GTK_CONTAINER (EditMenuTitle_menu), Delete); + + ViewMenuTitle = gtk_menu_item_new_with_mnemonic (_("_View")); + gtk_widget_show (ViewMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuMain), ViewMenuTitle); + + ViewMenuTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (ViewMenuTitle), ViewMenuTitle_menu); + + ZoomIn = gtk_menu_item_new_with_mnemonic (_("Zoom in")); + gtk_widget_show (ZoomIn); + gtk_container_add (GTK_CONTAINER (ViewMenuTitle_menu), ZoomIn); + + ZoomOut = gtk_menu_item_new_with_mnemonic (_("Zoom out")); + gtk_widget_show (ZoomOut); + gtk_container_add (GTK_CONTAINER (ViewMenuTitle_menu), ZoomOut); + + ZoomExtended = gtk_menu_item_new_with_mnemonic (_("Zoom extended")); + gtk_widget_show (ZoomExtended); + gtk_container_add (GTK_CONTAINER (ViewMenuTitle_menu), ZoomExtended); + + ViewMenuSeparator = gtk_menu_item_new (); + gtk_widget_show (ViewMenuSeparator); + gtk_container_add (GTK_CONTAINER (ViewMenuTitle_menu), ViewMenuSeparator); + gtk_widget_set_sensitive (ViewMenuSeparator, FALSE); + + GoToTime = gtk_menu_item_new_with_mnemonic (_("Go to time")); + gtk_widget_show (GoToTime); + gtk_container_add (GTK_CONTAINER (ViewMenuTitle_menu), GoToTime); + + ShowTimeFrame = gtk_menu_item_new_with_mnemonic (_("Show time frame")); + gtk_widget_show (ShowTimeFrame); + gtk_container_add (GTK_CONTAINER (ViewMenuTitle_menu), ShowTimeFrame); + + ToolMenuTitle = gtk_menu_item_new_with_mnemonic (_("Tools")); + gtk_widget_show (ToolMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuMain), ToolMenuTitle); + + ToolMenuTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (ToolMenuTitle), ToolMenuTitle_menu); + + MoveViewerUp = gtk_menu_item_new_with_mnemonic (_("Move viewer up")); + gtk_widget_show (MoveViewerUp); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), MoveViewerUp); + + MoveViewerDown = gtk_menu_item_new_with_mnemonic (_("Move viewer down")); + gtk_widget_show (MoveViewerDown); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), MoveViewerDown); + + RemoveViewer = gtk_menu_item_new_with_mnemonic (_("Remove viewer")); + gtk_widget_show (RemoveViewer); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), RemoveViewer); + + ToolMenuSeparator = gtk_menu_item_new (); + gtk_widget_show (ToolMenuSeparator); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), ToolMenuSeparator); + gtk_widget_set_sensitive (ToolMenuSeparator, FALSE); + + insert_viewer_test = gtk_menu_item_new_with_mnemonic (_("Insert viewer test")); + gtk_widget_show (insert_viewer_test); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), insert_viewer_test); + + PluginMenuTitle = gtk_menu_item_new_with_mnemonic (_("Plugins")); + gtk_widget_show (PluginMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuMain), PluginMenuTitle); + + PluginMenuTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (PluginMenuTitle), PluginMenuTitle_menu); + + LoadModule = gtk_menu_item_new_with_mnemonic (_("Load module")); + gtk_widget_show (LoadModule); + gtk_container_add (GTK_CONTAINER (PluginMenuTitle_menu), LoadModule); + + UnloadModule = gtk_menu_item_new_with_mnemonic (_("Unload module")); + gtk_widget_show (UnloadModule); + gtk_container_add (GTK_CONTAINER (PluginMenuTitle_menu), UnloadModule); + + AddModuleSearchPath = gtk_menu_item_new_with_mnemonic (_("Add module search path")); + gtk_widget_show (AddModuleSearchPath); + gtk_container_add (GTK_CONTAINER (PluginMenuTitle_menu), AddModuleSearchPath); + + OptionMenuTitle = gtk_menu_item_new_with_mnemonic (_("Options")); + gtk_widget_show (OptionMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuMain), OptionMenuTitle); + + OptionMenuTitle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (OptionMenuTitle), OptionMenuTitle_menu); + + Color = gtk_menu_item_new_with_mnemonic (_("Color")); + gtk_widget_show (Color); + gtk_container_add (GTK_CONTAINER (OptionMenuTitle_menu), Color); + + OptMenuSeparator = gtk_menu_item_new (); + gtk_widget_show (OptMenuSeparator); + gtk_container_add (GTK_CONTAINER (OptionMenuTitle_menu), OptMenuSeparator); + gtk_widget_set_sensitive (OptMenuSeparator, FALSE); + + OpenFilter = gtk_menu_item_new_with_mnemonic (_("Filter")); + gtk_widget_show (OpenFilter); + gtk_container_add (GTK_CONTAINER (OptionMenuTitle_menu), OpenFilter); + + SaveConfiguration = gtk_menu_item_new_with_mnemonic (_("Save configuration")); + gtk_widget_show (SaveConfiguration); + gtk_container_add (GTK_CONTAINER (OptionMenuTitle_menu), SaveConfiguration); + + MenuHelp = gtk_menu_bar_new (); + gtk_widget_show (MenuHelp); + gtk_box_pack_end (GTK_BOX (MMenuBox), MenuHelp, FALSE, FALSE, 0); + + HelpMenuTitle = gtk_menu_item_new_with_mnemonic (_("_Help")); + gtk_widget_show (HelpMenuTitle); + gtk_container_add (GTK_CONTAINER (MenuHelp), HelpMenuTitle); + + HelpMenu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (HelpMenuTitle), HelpMenu); + + Content = gtk_menu_item_new_with_mnemonic (_("Content")); + gtk_widget_show (Content); + gtk_container_add (GTK_CONTAINER (HelpMenu), Content); + + HelpmenuSeparator = gtk_menu_item_new (); + gtk_widget_show (HelpmenuSeparator); + gtk_container_add (GTK_CONTAINER (HelpMenu), HelpmenuSeparator); + gtk_widget_set_sensitive (HelpmenuSeparator, FALSE); + + About = gtk_menu_item_new_with_mnemonic (_("About...")); + gtk_widget_show (About); + gtk_container_add (GTK_CONTAINER (HelpMenu), About); + + MToolbar1 = gtk_toolbar_new (); + gtk_widget_show (MToolbar1); + gtk_box_pack_start (GTK_BOX (MVbox), MToolbar1, FALSE, FALSE, 0); + gtk_toolbar_set_style (GTK_TOOLBAR (MToolbar1), GTK_TOOLBAR_ICONS); + + tmp_toolbar_icon = create_pixmap (MWindow, "filenew.png"); + tlbEmptyTraceset = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("New window with empty trace set"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbEmptyTraceset); + gtk_container_set_border_width (GTK_CONTAINER (tlbEmptyTraceset), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "fileopen.png"); + tlbOpenTraceset = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("open a trace set"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbOpenTraceset); + gtk_container_set_border_width (GTK_CONTAINER (tlbOpenTraceset), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "edit_add_22.png"); + tlbAddTrace = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Add a trace "), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbAddTrace); + gtk_container_set_border_width (GTK_CONTAINER (tlbAddTrace), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "edit_remove_22.png"); + tlbRemoveTrace = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Remove a trace"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbRemoveTrace); + gtk_container_set_border_width (GTK_CONTAINER (tlbRemoveTrace), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "filesave.png"); + tlbSave = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("save the current trace set"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbSave); + gtk_container_set_border_width (GTK_CONTAINER (tlbSave), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "filesaveas.png"); + tlbSaveAs = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("save as "), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbSaveAs); + gtk_container_set_border_width (GTK_CONTAINER (tlbSaveAs), 1); + + gtk_toolbar_append_space (GTK_TOOLBAR (MToolbar1)); + + tmp_toolbar_icon = create_pixmap (MWindow, "stock_zoom_in_24.png"); + tlbZoomIn = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Zoom in"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbZoomIn); + gtk_container_set_border_width (GTK_CONTAINER (tlbZoomIn), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "stock_zoom_out_24.png"); + tlbZoomOut = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Zoom out"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbZoomOut); + gtk_container_set_border_width (GTK_CONTAINER (tlbZoomOut), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "stock_zoom_fit_24.png"); + tlbZoomExtended = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Zoom extended"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbZoomExtended); + gtk_container_set_border_width (GTK_CONTAINER (tlbZoomExtended), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "gtk-jump-to.png"); + tlbGoToTime = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Go to time"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbGoToTime); + gtk_container_set_border_width (GTK_CONTAINER (tlbGoToTime), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "mini-display.xpm"); + tlbShowTimeFrame = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Show time frame"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbShowTimeFrame); + gtk_container_set_border_width (GTK_CONTAINER (tlbShowTimeFrame), 1); + + gtk_toolbar_append_space (GTK_TOOLBAR (MToolbar1)); + + tmp_toolbar_icon = create_pixmap (MWindow, "1uparrow.png"); + tlbMoveViewerUp = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Move up current viewer"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbMoveViewerUp); + gtk_container_set_border_width (GTK_CONTAINER (tlbMoveViewerUp), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "1downarrow.png"); + tlbMoveViewerDown = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Move down current viewer"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbMoveViewerDown); + gtk_container_set_border_width (GTK_CONTAINER (tlbMoveViewerDown), 1); + + tmp_toolbar_icon = create_pixmap (MWindow, "remove.png"); + tlbRemoveViewer = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + _("Delete current viewer"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE); + gtk_widget_show (tlbRemoveViewer); + gtk_container_set_border_width (GTK_CONTAINER (tlbRemoveViewer), 1); + + MToolbar2 = gtk_toolbar_new (); + gtk_widget_show (MToolbar2); + gtk_box_pack_start (GTK_BOX (MVbox), MToolbar2, FALSE, FALSE, 0); + gtk_toolbar_set_style (GTK_TOOLBAR (MToolbar2), GTK_TOOLBAR_BOTH); + + MNotebook = gtk_notebook_new (); + gtk_widget_show (MNotebook); + gtk_box_pack_start (GTK_BOX (MVbox), MNotebook, TRUE, TRUE, 0); +/* + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (MNotebook), empty_notebook_page); + + label1 = gtk_label_new (""); + gtk_widget_show (label1); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (MNotebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (MNotebook), 0), label1); + gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); +*/ + MStatusbar = gtk_statusbar_new (); + gtk_widget_show (MStatusbar); + gtk_box_pack_start (GTK_BOX (MVbox), MStatusbar, FALSE, FALSE, 0); + + g_signal_connect ((gpointer) MWindow, "destroy", + G_CALLBACK (on_MWindow_destroy), + NULL); + g_signal_connect ((gpointer) EmptyTraceset, "activate", + G_CALLBACK (on_empty_traceset_activate), + NULL); + g_signal_connect ((gpointer) CloneTraceset, "activate", + G_CALLBACK (on_clone_traceset_activate), + NULL); + g_signal_connect ((gpointer) Tab, "activate", + G_CALLBACK (on_tab_activate), + NULL); + g_signal_connect ((gpointer) OpenTraceset, "activate", + G_CALLBACK (on_open_activate), + NULL); + g_signal_connect ((gpointer) Close, "activate", + G_CALLBACK (on_close_activate), + NULL); + g_signal_connect ((gpointer) CloseTab, "activate", + G_CALLBACK (on_close_tab_activate), + NULL); + g_signal_connect ((gpointer) AddTrace, "activate", + G_CALLBACK (on_add_trace_activate), + NULL); + g_signal_connect ((gpointer) RemoveTrace, "activate", + G_CALLBACK (on_remove_trace_activate), + NULL); + g_signal_connect ((gpointer) Save, "activate", + G_CALLBACK (on_save_activate), + NULL); + g_signal_connect ((gpointer) SaveAs, "activate", + G_CALLBACK (on_save_as_activate), + NULL); + g_signal_connect ((gpointer) Quit, "activate", + G_CALLBACK (on_quit_activate), + NULL); + g_signal_connect ((gpointer) Cut, "activate", + G_CALLBACK (on_cut_activate), + NULL); + g_signal_connect ((gpointer) Copy, "activate", + G_CALLBACK (on_copy_activate), + NULL); + g_signal_connect ((gpointer) Paste, "activate", + G_CALLBACK (on_paste_activate), + NULL); + g_signal_connect ((gpointer) Delete, "activate", + G_CALLBACK (on_delete_activate), + NULL); + g_signal_connect ((gpointer) ZoomIn, "activate", + G_CALLBACK (on_zoom_in_activate), + NULL); + g_signal_connect ((gpointer) ZoomOut, "activate", + G_CALLBACK (on_zoom_out_activate), + NULL); + g_signal_connect ((gpointer) ZoomExtended, "activate", + G_CALLBACK (on_zoom_extended_activate), + NULL); + g_signal_connect ((gpointer) GoToTime, "activate", + G_CALLBACK (on_go_to_time_activate), + NULL); + g_signal_connect ((gpointer) ShowTimeFrame, "activate", + G_CALLBACK (on_show_time_frame_activate), + NULL); + g_signal_connect ((gpointer) MoveViewerUp, "activate", + G_CALLBACK (on_move_viewer_up_activate), + NULL); + g_signal_connect ((gpointer) MoveViewerDown, "activate", + G_CALLBACK (on_move_viewer_down_activate), + NULL); + g_signal_connect ((gpointer) RemoveViewer, "activate", + G_CALLBACK (on_remove_viewer_activate), + NULL); + g_signal_connect ((gpointer) insert_viewer_test, "activate", + G_CALLBACK (on_insert_viewer_test_activate), + NULL); + g_signal_connect ((gpointer) LoadModule, "activate", + G_CALLBACK (on_load_module_activate), + NULL); + g_signal_connect ((gpointer) UnloadModule, "activate", + G_CALLBACK (on_unload_module_activate), + NULL); + g_signal_connect ((gpointer) AddModuleSearchPath, "activate", + G_CALLBACK (on_add_module_search_path_activate), + NULL); + g_signal_connect ((gpointer) Color, "activate", + G_CALLBACK (on_color_activate), + NULL); + g_signal_connect ((gpointer) OpenFilter, "activate", + G_CALLBACK (on_filter_activate), + NULL); + g_signal_connect ((gpointer) SaveConfiguration, "activate", + G_CALLBACK (on_save_configuration_activate), + NULL); + g_signal_connect ((gpointer) Content, "activate", + G_CALLBACK (on_content_activate), + NULL); + g_signal_connect ((gpointer) About, "activate", + G_CALLBACK (on_about_activate), + NULL); + g_signal_connect ((gpointer) tlbEmptyTraceset, "clicked", + G_CALLBACK (on_button_new_clicked), + NULL); + g_signal_connect ((gpointer) tlbOpenTraceset, "clicked", + G_CALLBACK (on_button_open_clicked), + NULL); + g_signal_connect ((gpointer) tlbAddTrace, "clicked", + G_CALLBACK (on_button_add_trace_clicked), + NULL); + g_signal_connect ((gpointer) tlbRemoveTrace, "clicked", + G_CALLBACK (on_button_remove_trace_clicked), + NULL); + g_signal_connect ((gpointer) tlbSave, "clicked", + G_CALLBACK (on_button_save_clicked), + NULL); + g_signal_connect ((gpointer) tlbSaveAs, "clicked", + G_CALLBACK (on_button_save_as_clicked), + NULL); + g_signal_connect ((gpointer) tlbZoomIn, "clicked", + G_CALLBACK (on_button_zoom_in_clicked), + NULL); + g_signal_connect ((gpointer) tlbZoomOut, "clicked", + G_CALLBACK (on_button_zoom_out_clicked), + NULL); + g_signal_connect ((gpointer) tlbZoomExtended, "clicked", + G_CALLBACK (on_button_zoom_extended_clicked), + NULL); + g_signal_connect ((gpointer) tlbGoToTime, "clicked", + G_CALLBACK (on_button_go_to_time_clicked), + NULL); + g_signal_connect ((gpointer) tlbShowTimeFrame, "clicked", + G_CALLBACK (on_button_show_time_frame_clicked), + NULL); + g_signal_connect ((gpointer) tlbMoveViewerUp, "clicked", + G_CALLBACK (on_button_move_up_clicked), + NULL); + g_signal_connect ((gpointer) tlbMoveViewerDown, "clicked", + G_CALLBACK (on_button_move_down_clicked), + NULL); + g_signal_connect ((gpointer) tlbRemoveViewer, "clicked", + G_CALLBACK (on_button_delete_viewer_clicked), + NULL); + g_signal_connect ((gpointer) MNotebook, "switch_page", + G_CALLBACK (on_MNotebook_switch_page), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (MWindow, MWindow, "MWindow"); + GLADE_HOOKUP_OBJECT (MWindow, MVbox, "MVbox"); + GLADE_HOOKUP_OBJECT (MWindow, MMenuBox, "MMenuBox"); + GLADE_HOOKUP_OBJECT (MWindow, MenuMain, "MenuMain"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuTitle, "FileMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuTitle_menu, "FileMenuTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuNewTitle, "FileMenuNewTitle"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuNewTitle_menu, "FileMenuNewTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, EmptyTraceset, "EmptyTraceset"); + GLADE_HOOKUP_OBJECT (MWindow, CloneTraceset, "CloneTraceset"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuNewSep, "FileMenuNewSep"); + GLADE_HOOKUP_OBJECT (MWindow, Tab, "Tab"); + GLADE_HOOKUP_OBJECT (MWindow, OpenTraceset, "OpenTraceset"); + GLADE_HOOKUP_OBJECT (MWindow, Close, "Close"); + GLADE_HOOKUP_OBJECT (MWindow, CloseTab, "CloseTab"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuSeparator1, "FileMenuSeparator1"); + GLADE_HOOKUP_OBJECT (MWindow, AddTrace, "AddTrace"); + GLADE_HOOKUP_OBJECT (MWindow, RemoveTrace, "RemoveTrace"); + GLADE_HOOKUP_OBJECT (MWindow, Save, "Save"); + GLADE_HOOKUP_OBJECT (MWindow, SaveAs, "SaveAs"); + GLADE_HOOKUP_OBJECT (MWindow, FileMenuSeparator2, "FileMenuSeparator2"); + GLADE_HOOKUP_OBJECT (MWindow, Quit, "Quit"); + GLADE_HOOKUP_OBJECT (MWindow, EditMenuTitle, "EditMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, EditMenuTitle_menu, "EditMenuTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, Cut, "Cut"); + GLADE_HOOKUP_OBJECT (MWindow, Copy, "Copy"); + GLADE_HOOKUP_OBJECT (MWindow, Paste, "Paste"); + GLADE_HOOKUP_OBJECT (MWindow, Delete, "Delete"); + GLADE_HOOKUP_OBJECT (MWindow, ViewMenuTitle, "ViewMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, ViewMenuTitle_menu, "ViewMenuTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, ZoomIn, "ZoomIn"); + GLADE_HOOKUP_OBJECT (MWindow, ZoomOut, "ZoomOut"); + GLADE_HOOKUP_OBJECT (MWindow, ZoomExtended, "ZoomExtended"); + GLADE_HOOKUP_OBJECT (MWindow, ViewMenuSeparator, "ViewMenuSeparator"); + GLADE_HOOKUP_OBJECT (MWindow, GoToTime, "GoToTime"); + GLADE_HOOKUP_OBJECT (MWindow, ShowTimeFrame, "ShowTimeFrame"); + GLADE_HOOKUP_OBJECT (MWindow, ToolMenuTitle, "ToolMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, ToolMenuTitle_menu, "ToolMenuTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, MoveViewerUp, "MoveViewerUp"); + GLADE_HOOKUP_OBJECT (MWindow, MoveViewerDown, "MoveViewerDown"); + GLADE_HOOKUP_OBJECT (MWindow, RemoveViewer, "RemoveViewer"); + GLADE_HOOKUP_OBJECT (MWindow, ToolMenuSeparator, "ToolMenuSeparator"); + GLADE_HOOKUP_OBJECT (MWindow, insert_viewer_test, "insert_viewer_test"); + GLADE_HOOKUP_OBJECT (MWindow, PluginMenuTitle, "PluginMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, PluginMenuTitle_menu, "PluginMenuTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, LoadModule, "LoadModule"); + GLADE_HOOKUP_OBJECT (MWindow, UnloadModule, "UnloadModule"); + GLADE_HOOKUP_OBJECT (MWindow, AddModuleSearchPath, "AddModuleSearchPath"); + GLADE_HOOKUP_OBJECT (MWindow, OptionMenuTitle, "OptionMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, OptionMenuTitle_menu, "OptionMenuTitle_menu"); + GLADE_HOOKUP_OBJECT (MWindow, Color, "Color"); + GLADE_HOOKUP_OBJECT (MWindow, OptMenuSeparator, "OptMenuSeparator"); + GLADE_HOOKUP_OBJECT (MWindow, OpenFilter, "OpenFilter"); + GLADE_HOOKUP_OBJECT (MWindow, SaveConfiguration, "SaveConfiguration"); + GLADE_HOOKUP_OBJECT (MWindow, MenuHelp, "MenuHelp"); + GLADE_HOOKUP_OBJECT (MWindow, HelpMenuTitle, "HelpMenuTitle"); + GLADE_HOOKUP_OBJECT (MWindow, HelpMenu, "HelpMenu"); + GLADE_HOOKUP_OBJECT (MWindow, Content, "Content"); + GLADE_HOOKUP_OBJECT (MWindow, HelpmenuSeparator, "HelpmenuSeparator"); + GLADE_HOOKUP_OBJECT (MWindow, About, "About"); + GLADE_HOOKUP_OBJECT (MWindow, MToolbar1, "MToolbar1"); + GLADE_HOOKUP_OBJECT (MWindow, tlbEmptyTraceset, "tlbEmptyTraceset"); + GLADE_HOOKUP_OBJECT (MWindow, tlbOpenTraceset, "tlbOpenTraceset"); + GLADE_HOOKUP_OBJECT (MWindow, tlbAddTrace, "tlbAddTrace"); + GLADE_HOOKUP_OBJECT (MWindow, tlbRemoveTrace, "tlbRemoveTrace"); + GLADE_HOOKUP_OBJECT (MWindow, tlbSave, "tlbSave"); + GLADE_HOOKUP_OBJECT (MWindow, tlbSaveAs, "tlbSaveAs"); + GLADE_HOOKUP_OBJECT (MWindow, tlbZoomIn, "tlbZoomIn"); + GLADE_HOOKUP_OBJECT (MWindow, tlbZoomOut, "tlbZoomOut"); + GLADE_HOOKUP_OBJECT (MWindow, tlbZoomExtended, "tlbZoomExtended"); + GLADE_HOOKUP_OBJECT (MWindow, tlbGoToTime, "tlbGoToTime"); + GLADE_HOOKUP_OBJECT (MWindow, tlbShowTimeFrame, "tlbShowTimeFrame"); + GLADE_HOOKUP_OBJECT (MWindow, tlbMoveViewerUp, "tlbMoveViewerUp"); + GLADE_HOOKUP_OBJECT (MWindow, tlbMoveViewerDown, "tlbMoveViewerDown"); + GLADE_HOOKUP_OBJECT (MWindow, tlbRemoveViewer, "tlbRemoveViewer"); + GLADE_HOOKUP_OBJECT (MWindow, MToolbar2, "MToolbar2"); + GLADE_HOOKUP_OBJECT (MWindow, MNotebook, "MNotebook"); + // GLADE_HOOKUP_OBJECT (MWindow, label1, "label1"); + GLADE_HOOKUP_OBJECT (MWindow, MStatusbar, "MStatusbar"); + + gtk_window_add_accel_group (GTK_WINDOW (MWindow), accel_group); + + return MWindow; +} + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.h b/ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.h new file mode 100644 index 00000000..d0f3c636 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/interface.h @@ -0,0 +1,5 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +GtkWidget* create_MWindow (void); diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/main.c b/ltt/branches/poly/lttv/modules/gui/mainWin/src/main.c new file mode 100644 index 00000000..816c6f1c --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/main.c @@ -0,0 +1,96 @@ +/* + * Initial main.c file generated by Glade. Edit as required. + * Glade will not overwrite this file. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#include "interface.h" +#include "support.h" +#include "mainWindow.h" +#include "callbacks.h" + +/* global variable */ +systemView * gSysView; + +typedef view_constructor (* constructor)(); +constructor get_constructor = NULL; +typedef void (*call_Event_Selected_Hook)(void * call_data); +call_Event_Selected_Hook selected_hook = NULL; +GModule *gm; +view_constructor gConstructor = NULL; + +int +main (int argc, char *argv[]) +{ + GModule *gm; + GtkWidget * ToolMenuTitle_menu, *insert_view; + GtkWidget *window1; + mainWindow * mw = g_new(mainWindow, 1); + gSysView = g_new(systemView, 1); + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); + textdomain (GETTEXT_PACKAGE); +#endif + + gtk_set_locale (); + gtk_init (&argc, &argv); + + add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps"); + add_pixmap_directory ("pixmaps"); + + /* + * The following code was added by Glade to create one of each component + * (except popup menus), just so that you see something after building + * the project. Delete any components that you don't want shown initially. + */ + window1 = create_MWindow (); + gtk_widget_show (window1); + + mw->MWindow = window1; + mw->SystemView = gSysView; + mw->Tab = NULL; + mw->CurrentTab = NULL; + // mw->Attributes = lttv_attributes_new(); + + //test + + gm = g_module_open("/home1/yangxx/poly/lttv/modules/libguiEvents.la",0); + printf("Main : the address of gm : %d\n", gm); + if(!g_module_symbol(gm, "get_constructor", (gpointer)&get_constructor)){ + g_error("can not get constructor\n"); + } + if(!g_module_symbol(gm, "call_Event_Selected_Hook", (gpointer)&selected_hook)){ + g_error("can not get selected hook\n"); + } + + gConstructor = get_constructor(); + ToolMenuTitle_menu = lookup_widget(mw->MWindow,"ToolMenuTitle_menu"); + insert_view = gtk_menu_item_new_with_mnemonic (_("insert_view")); + gtk_widget_show (insert_view); + gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), insert_view); + g_signal_connect ((gpointer) insert_view, "activate", + G_CALLBACK (insertViewTest), + NULL); + //end + + gSysView->EventDB = NULL; + gSysView->SystemInfo = NULL; + gSysView->Options = NULL; + gSysView->Window = mw; + gSysView->Next = NULL; + + g_object_set_data(G_OBJECT(window1), "systemView", (gpointer)gSysView); + g_object_set_data(G_OBJECT(window1), "mainWindow", (gpointer)mw); + + gtk_main (); + return 0; +} + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/mainWindow.h b/ltt/branches/poly/lttv/modules/gui/mainWin/src/mainWindow.h new file mode 100644 index 00000000..2ab0ab7d --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/mainWindow.h @@ -0,0 +1,76 @@ +#ifndef _MAIN_WINDOW_ +#define _MAIN_WINDOW_ + +#include + +#include +#include +#include +#include +#include + + +typedef struct _TimeInterval{ + LttTime startTime; + LttTime endTime; +} TimeInterval; + + +typedef struct _systemView systemView; +typedef struct _tab tab; + +typedef struct _mainWindow{ + GtkWidget* MWindow; /* Main Window */ + systemView * SystemView; /* System view displayed in this window*/ + + /* Status bar information */ + // guint MainSBarContextID; /* Context ID of main status bar */ + // guint BegTimeSBarContextID; /* Context ID of BegTime status bar */ + // guint EndTimeSBarContextID; /* Context ID of EndTime status bar */ + + /* Child windows */ + //openTracesetWindow* OpenTracesetWindow;/* Window to get prof and proc file*/ + //viewTimeFrameWindow* ViewTimeFrameWindow;/*Window to select time frame */ + //gotoEventWindow* GotoEventWindow; /*search for event description*/ + //openFilterWindow* OpenFilterWindow; /* Open a filter selection window */ + GtkWidget* HelpContents;/* Window to display help contents */ + GtkWidget* AboutBox; /* Window about information */ + + LttvTracesetContext * traceset_context; + LttvTraceset * traceset; /* trace set associated with the window */ + // lttv_trace_filter * filter; /* trace filter associated with the window */ + + + tab * Tab; + tab * CurrentTab; + LttvIAttribute * Attributes; + +} mainWindow; + +typedef GtkWidget * (*view_constructor)(mainWindow * main_win); + +struct _systemView{ + gpointer EventDB; + gpointer * SystemInfo; + gpointer * Options; + mainWindow * Window; + struct _systemView * Next; +}; + +struct _tab{ + GtkWidget * label; + GtkCustom * custom; + + LttTime traceStartTime; + LttTime traceEndTime; + LttTime startTime; + LttTime endTime; + LttTime currentTime; + LttvIAttribute * Attributes; + + struct _tab * Next; +}; + +#endif /* _MAIN_WINDOW_ */ + + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/mainwin b/ltt/branches/poly/lttv/modules/gui/mainWin/src/mainwin new file mode 100755 index 0000000000000000000000000000000000000000..be37e4ea3bb7d809cc19e242aa2e8fc75cf38a78 GIT binary patch literal 670932 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�t9-iEupdqlp!! zX?V?4W>T1;D|M$$nMq+c4R_gutqf`O&{eS4Cb~=m?4_#!*2)?w?4#jfn|I(9z`k@v zSS5?_qc(J-OeBjhi{sakxd3k+Zov8Gf>_nP3-0szz@cy@1rLk>pFVI1(Oiwv)NLIF z3uY=_rf{(bEL)*amPlF!wEAg!y5Q^^3YCiTUf_KizL@dK1i!mn@Qs$7DE83cei@>8AAvwxzrq`@GjHCnOMOJlfIKi21iM|}w4U>cnz%zh2wH6+veEV9~vI|*E~Padv$$v2PARC3RO9)y?YhJhq-YP)P;Ea=ZMrPlacrY z8Tm*=xYmz|;NKMr@vtNU1P439Q;rdIxRaJWK z#-#97c1Q)Y`~7EY1m%EOGwEeiV}Elcn&f|1s8mB=3iZ(|{8xSdsiWdqxjKe`=#Mfw z-N^qb`b|hX-xz`{cI2+#|8|z)G!@ea{Y&xxSWlLnG(n_bI+%aOWDWgii7HpKuJA30 zT=RSQ;K5Fl+bfltp^)n7pZ>qpqw0=P5gpsV6#b7StjH{)`ypm9{ouc%|6hwaACa9; z$Do++aa#;JGpLik^Itmu$1I(plF!+s_i>97O4d>d9qzxBa0U23*FP^*LG;UvPXGL` z=>L(2Zjf?^*O}`Q;fdH9mX+=@@p-TIfi8b0wbt za>I{W*zwR(!`QnYHz*V~QFDdDLB6@dAh?~v{1xDHuF$YM(1@sIL}_B;{Xk>8DwHX% zqK_9&7@|;?S|$`u)|3BiwM;0SqR{}gOeieZXs}u)6i(GB5B?uXne_2NmZN9h+%J>L zsg9xs5jq=OLoFn}hM@Y)32Jp0!Vc!HK3JgziE7$c6zQAx6@QEpw$Qiw`a1{L2Ws>J zHcW((hhWQ>5yTA8Suz0y@xDez0y;xctG5)xEnW!(YRzXjaKT7!4U!9H@lBm8E5mI- zakC!uFlJG^gAgzon(T#JUCG$(lBR3q5iCA=`Ge8TP1n;H@&ip* zRm`2-rmI&fN@=;~d_6f@+kc36jmh{UG?4YZ%Q;*TQVKkav&ik3K`=36=*Zq@G7j^N4ORO*L!=q*34i@1|Hx?lT9or`JqgaG{ zF{s$(f)7}PE^o33E8#S&$~o{P4*4Yt>y*c4vIuS8U=fxbMLinXIsDd;|G=_p%E_ZyGk>FuZh7efYbFNGT}w9klQlE!UDiwx>ck^I zLc7$KwclsWO!Z^UEZ)tUnY5S}Axvq&ix3|6hxy5F9nl@+_ur#8$d=F$F5f^ejgX1g z(G}!B4&ID&Yce{5bf9xImYq>8O=NmHZ^?NamDx<5UWz^-kKd0jAfNsVJwQ%~gptYJ z0kD7BARgu~e;LTzbArH)mRsJ#GjX}6v0=o@I!L#T{Nq=waplYCgYnYei8Jc*rRRC8 z&Q0h{lyko1-8zMz@Vj!aqQ=_GABN#NGI=Zn+edQk2;4v>mqVtb+yTSxB!5YO<;zfX zyUvnF(Yna{9>R4ZathK)lgm*9>GHsbct&aj#I9mfo|n_7uqjhva;ALj7@KnPH8$mj zmTbyU2v?EUCb2269Z>t>rHGhv809YhOLf@dzd7Gw_su+syVh@5-AHsR2l_{&5VZbk zybbUGs<-%859gxAZqxG8p3m#o}NKx}3ccsrXl>>RE6B!4Q+G@P?PO zAF^0{f~M{{co0F4`4Xf!S+=82ihp-Q&a>kpg0;@4)APcnL3)Y6?d>_FALwrT&-Z9XBf-X)!e0Ek!QoJfN56T5@*Ao0I%-{({t}c z1T)RAlwhf6=G%b1%$o|9c@kjf#r-Te(K9F*Fb6kpGK1xwKYIh_nUM-k^Ms879B$46 zRLgN*q+C44T%|CUY7o@I5~%-LZm=CPV+ht=i*+JixH48+efzp&na z(p`PCY288Xc{v3od(xZ<2|jdjPoxG_Lkv0n`hk7z9t4p@3I6$40|nC;stgEP2Txnl zQu5TQOZLPxE=)$p(ZP?!$UM_kTpjUD*Ya2J&*rL9jDL2>;h)3x=#%*8a!HDWxt8q5 zzhu`l7`gD8T!$C%4}(TzZH&Z-YD8{9OChomdCx5daP7|TB@E!&o#Xu(2t#(b#b7VV zmWNy*$SK#U!qErBu^>1~=BWc|C9Ajuq|@hh2PLaDvK!6c*o4usnPHTgB@5KTqU0Oj zGlrIlkoek#NfMuZfH~_ zJ_rE%N23y4YE@>G+|;O4oc#m5TN;&lxCL5bm>N#>a1XS^v|zcX2Dem%Ssn8iTlh53 zphkdI%t%1x&e|V^s;Xuuh2hSs+z0G52Pq79=9a*I7KS@(xC1!A9H;njXNxfkmsB_B zDhzk_1?;7yhPh5*xU(_Iz=7s|h2hTLe-Sv?@J4?4cykuRQM9~KMI^=;VY)6<4NH5R(`Hx zI3Z59@OKzK5`a6JqgDKCrf287z^Ud!g@1+1XMJ_C@E@jU?j+ze3*Rt354;bYVLq$m zXWBf^vwbryJlp0O_z!Ro^R(j6wRv931mQh2`2Gl2Ee+se;kn`gp#;B2$zR+fL6 z&69%15ha7n=M-LP^E?7)S~A3ZN8vR#&+nLsmE@aWD!kt2+4U4~p@lcwJkvi1E-`tY zOoVT8U83dUds($t$fM9w6 zD<-#$L2gYl9f3vW4lBs%B(wipWNzbvoJTUN=yhAFVMh70tFgY79a$RcV^(3 zKY+VSWdTC4c-ICl0H8o|WdTC4c)bSR1fsy)$^wL7@uCg9{!4+UDhm*T#Va@b?8_+d zMr8p)uz2%`pM4(%zO5`k2o`VW@Uy>90e`raJL-WDEMCZgtU@5TJq2`cV$f;4jqW)= z6+wN($C{)y2EjoecIz!HvrFa+UK_GHLEln@?wnX<9s9B7-RJ zkxXBC2RVoZt5llrC`FHXr<7IFnjpLBJ@2SCD!;wM>&rq52nExR-l>J<)S~}NbpSQf z&)(LI9M2_{-u5;%Xb+$>^*6Lcf6f>owU$!!!FsA`d7f862&N~ta$voSasd>_AdDk_ zV(fC4EX3trCF`sWWdj#lm8`dbU0rBZvcZB5b)i+sMhp7ao6`_k*rZQg^M-p@J-?fv zY_=%;47=f2hJ;?jpzSDG##8q26%tB8`Pv*gzQ>qf#E3;7fVPBD^@B$oj>z zfA6pxK>F*2JfW8C-7^3L>+6O1412P7_&XrzuNU%Tg~?tU%zdPFbqv0`p6tEneh^Y< zU3L>+T~9WekJ@1vuU|2Y_2x+Z^nPR)D`ye;MMcKQ^aT*WsT7+Sy&G}6X?P7M2!a7K z*C{Sew7gE3^|^w7*u)X$t+y7wVG|EF1MKsM;?5M}%1Xe#fjg;rwh(cj0uD-0aIO#= z>j4fOs^EN~Huy&taN8bF%!S(FA6cm3GNHEkM;2+gQm8%tk;61xBaGlVNYV`AuX7RV zcw`J4MY$Ll@??-P4B$7I<_PRxldJkR+sb}vg~`U8mt zQDCGFQH&z-NEjHM^%Lk4=kF82i!G!WU#KkYGGB?6is)`YX}Y_XdCh7->AGv6Hd=>2FO2tzdij&Y**$50T|cXrgbKPGyoW4tZR*An>l$3*YgA3!M3 z1iaHS(K~!S2(s1iuRrI{cU>nJrz_yjJkv_uo|ebtGA&r?fB zl7PKCk%84!=_rk+2?siTX(^GqabXrVX-Y?Hh{JWeZUT(G_6_+xRy$ysI=;J)0|i%-Z!8U$OR9@obacP8|dB z<~?`ex;y*J5;yWydOYg~pELO)tEEIs#?p1KJ5cX40 zJad79+k|*K7Vv%zcjBZSJb&o}n-v!){`j(O>4TcPSNpiqx!P?V)IP5CVGR#!A6Gh0 z!=u{Al|G{3tMGBmkQu~Y;d3S|j++_N#y%VE+YI z4`Ub^a|x@0(b_MKuJB7k`{B;WIQ?o^syO;JP`q{mX(FpPP=ZF8f*0A1w(e2O67HXY zlJxoIZ0~&-c}82KB09qW@BH6Eu)gVw&M?6H4pJX&jf!}oYk;?^2Lx+WL}wV_od^pU zZGE!_one5t`B@OGZ~EdxI0KC4kL@vxGwTiGv^lz!s+!ShmaFu3n+svfap1TdETtpn z9-}k&A_}%qggEyqV0R5+DP6w-%z9sOVJUvhZ*TP;QaCK-F?7t)eY7wv#XB3Yul+fy zf~7oxsvbQcOhH%*Kc_ugNtDQu+C>h!z_e^r~+=pov0PHM9novYy~*wHh{ff>YK z=U7%z6k8vbun`p8b%EbtW>Sj;y+OG=RQBK(I!sq`&r^c=wj`|81k{-WI-IQV zqH4!Xf#di$pz|3q&(Xv&^#tfLwL5g>jU=U>0}(=HAVDk zz&;$SlxLfF5-?js+$HnCdw~5okH`LvDefceuOaS|+4U0O01a`MOb1L~$Ebkl)Lx-q?v!H&jQ0|1P4r|I2+43Du!fVzq@>LXBwv&a}V6lGX5 zP%IB0swgvifTCQy-Mm{-#!*JOdAnI#QFwNDjB@pM)1xQ@6G2hl-fo7Fg66#&^%UF% zKbT43*Es^MJSHj$jS;jj%=eQCj&JJK2w_AEg8$x!;NWG3amgIh%6WD@jJFm2jOv(U z#t#LT7Q*f@W|B7e)4Ds1Q71>RIjFnC73Qe$s&%6SFpg(diI^@J^zf zC{?4u>U&LNyYP4sW=$e)K6q)`R*OUstZ{6*o>7%J>--KB{Sp;EKN7)i$CbiT!~Zyv z!q}Py>>mm#gjXTlJm-L6Y>36J204#V^5FI=1f;$f}jZ z=hzM!+i$aiSV?4(JLm-kv65gbjkUZKRuUXq##&wqD+!J*V~6TCoT*!BY@UX*;lt)b ziy6dU=Ratyu~D>)pvlC=U&2P-=DU%4O>DWR;o$k%S&m@lNJj=`B`M65rYM^Pc{?bM zl!J!R>r~T} zgDPuB2c>+*Ti=7J=E_(gnW8^tD`g!xQ>D)^n%6soJ9Tdw#zC_z+PM+cKepAIsA^T~ zWvM-oJLV-H?Nru<#)4Qvj3w-#ZS1IPSuh z_0e!IdfIlBZvVYF`7o}fdeAs7+Irq4W=zJHqT0Lc*`xh z)Fm_Ht!)ao_#gp1YxWdk1ROwe_VHYT+fH@r^aBuWz2{oeK5+w}8)i;;?w20S6RH6T4y7;|Do0^QWh~I2|ZQ z^Rh%R#Is6e08&ye!7zlh(4Y8wqVSU|9$G7=1G2nQtL$3A|P zJe9^=uI-1Ik%JHnN+X`I3pk3;-cgnDp!h!l3G_r(lAC$a4bI5AW3fX7%?5Pl z{f!nG<3$xC?r_SpcJz+sf02jK3h;wjX=acTxIHPk9inQ8a@ilu8vU23CGaH$Sjqn> zfXG!rcC*TFXCBmW5Q16tRt#Do$O#l?8{8JYqok_16=jBa7RA{t|4khH8RWB}^zjdt z6V!F2vca@PThx6ZIL4!!o<~-qCN@{*II)$_R|jIao!EL6_%z3ETY;jVRmfj8`ovh> z%r4dF6WeIy7CaU+F;1fpkxCS=QK(2KO3)}w^dM@hQH1D2l&Dc-F@PvZqe#QO010dV z%aF5a9dMg1MG&RCAOHNDfC9r|aoo(MNmmd=VU{2N92fDk8)b4#idHX7OlrgNkK^pD zGJFOrP9q%STz(YYcG3`en6@Rqyai>lQBR1<@V*#|K%e=; z#c@b;HUzpHu27a(js2oYS7H^)7W_=fq%SoZp!&e1tJ+=%t3EL4YmM?$ADHxwMn#6Z z5cQ$=j~Q|!o2OSjc12M+mAh`QOBx3h7(3VcGD6k@CXXW1(hL(@14v9YyVyq!9;0R9T{*~I_B z2WvlBw1xj*-OdSw&VV0GqqwtVmhRulqlw(XLzJ4J1k*Y+8I&df4sIQVUdAcd$&q3- zoXX@VUzZE{11Po{=F;qP_dX32S6?B2G2=C$#EuHN#62$owa-<^E$V#*l%i3HNZ$jL zs!^!0tq1BdNlAt&uRS?U+hK&V*vaV{H8$KgnN>BtV#s;A95I{P5i>|xgKA5w#Fru9 z{|*FTnk-K+vuOq~o^QtH0wtLFy@Pz)9#9!x3NV|Nz@7Tj$YZAO;2}y8D2^5Qd1DZs zTTE%9T-KBpJbeo!`JY-rYW%-!KAO}bY+Sfo$#77 zuEHf$!xP`0Gy=Ycn7zEIoQASsvSvSF7(Zc}c z=DXjFDyfOspVdj>nR_tQ3;G53G1H2kn?90raYFVRIPzpeI8`o z0E%BXGpQ#~l=TUG@c#&V^SG{x?|=MW=2gC~;wv&GDF`q8Kvc@B@QkK9LGYzqiqfa4H9&A~#-m4VG~DoDuCL+cjDPrD z!x-M^GQwH!y#f^ZBO`D1c@$8z3r01X6jI|2*Q$jtx7~29T2$w957(+i0E^t=TD7PJ zrxzq=a-ry-RqYZ|t$!YW?LzLtfA2>@21`>;eJKM{V0r@uzD88aNCnk?`F8|4Cm<;1 z8N;YGLKLYH<%-m*Rk$uT>LV_LQ_VyxkBC0X$XngTa5JLGO-4TIRuE8AFO2qd5eb!c zL^Em0>Rj3p%>@M*e(Ujy>87XEcpKhounB+NLX5|1_=S&Q3rWZm-4*c?Gse>9AOk#gb4 z$Y9+A;SY~ljM+3 zQj2K0;_pE~jecj8$kjGV>!wLuZKJeqin~cD0b%iLaa?@*qTfxTy6I`e895IYPpvZZT4&(xiu167B2DL=coEs>>=(<)S3Nq>$DlN;P z(V@>EkYl}#KZOHPw_~2+1jg9MAFCmdUt@yygi=IrRU3U_Og%wxj>yGp%YVnzaZCuO zI3`q!92{(lplLoxacl!lacudGyk{;#rwn`s;~+cMjE&G65v(p>;|Anbv}Z~EHUftj zHrmhG^FfL8@y}@-MZ*^3Yh$Iuj*Th*T4MwqD1^meoaBF8`KhMFv*RL#OXIon$LXd> zfCi4&@?tR87%yF9e0dikZEbvHP8T zfnw#o>a69Bj}sK2UW1}JzL}&_OXWd#8{g_BelL)DWW2T#1#vdV$4jO$*Z2q7)FUDO zS*tMF9^Zf#2kriT7i901Afr=JnSALZ6>p#deL(P~EDNtuiuTLTP!Q!`4zǷy!r+-%Ce54v!8-JO5m0*Y(OVbxVVRBLuKK>@0l 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 bqKB{bV%x+Zx^L~zRQfv*Z?NCqy3T(9s_AdJ literal 0 HcmV?d00001 diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/support.c b/ltt/branches/poly/lttv/modules/gui/mainWin/src/support.c new file mode 100644 index 00000000..00aff298 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/support.c @@ -0,0 +1,144 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include + +#include "support.h" + +GtkWidget* +lookup_widget (GtkWidget *widget, + const gchar *widget_name) +{ + GtkWidget *parent, *found_widget; + + for (;;) + { + if (GTK_IS_MENU (widget)) + parent = gtk_menu_get_attach_widget (GTK_MENU (widget)); + else + parent = widget->parent; + if (!parent) + parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey"); + if (parent == NULL) + break; + widget = parent; + } + + found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), + widget_name); + if (!found_widget) + g_warning ("Widget not found: %s", widget_name); + return found_widget; +} + +static GList *pixmaps_directories = NULL; + +/* Use this function to set the directory containing installed pixmaps. */ +void +add_pixmap_directory (const gchar *directory) +{ + pixmaps_directories = g_list_prepend (pixmaps_directories, + g_strdup (directory)); +} + +/* This is an internally used function to find pixmap files. */ +static gchar* +find_pixmap_file (const gchar *filename) +{ + GList *elem; + + /* We step through each of the pixmaps directory to find it. */ + elem = pixmaps_directories; + while (elem) + { + gchar *pathname = g_strdup_printf ("%s%s%s", (gchar*)elem->data, + G_DIR_SEPARATOR_S, filename); + if (g_file_test (pathname, G_FILE_TEST_EXISTS)) + return pathname; + g_free (pathname); + elem = elem->next; + } + return NULL; +} + +/* This is an internally used function to create pixmaps. */ +GtkWidget* +create_pixmap (GtkWidget *widget, + const gchar *filename) +{ + gchar *pathname = NULL; + GtkWidget *pixmap; + + if (!filename || !filename[0]) + return gtk_image_new (); + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning (_("Couldn't find pixmap file: %s"), filename); + return gtk_image_new (); + } + + pixmap = gtk_image_new_from_file (pathname); + g_free (pathname); + return pixmap; +} + +/* This is an internally used function to create pixmaps. */ +GdkPixbuf* +create_pixbuf (const gchar *filename) +{ + gchar *pathname = NULL; + GdkPixbuf *pixbuf; + GError *error = NULL; + + if (!filename || !filename[0]) + return NULL; + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning (_("Couldn't find pixmap file: %s"), filename); + return NULL; + } + + pixbuf = gdk_pixbuf_new_from_file (pathname, &error); + if (!pixbuf) + { + fprintf (stderr, "Failed to load pixbuf file: %s: %s\n", + pathname, error->message); + g_error_free (error); + } + g_free (pathname); + return pixbuf; +} + +/* This is used to set ATK action descriptions. */ +void +glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description) +{ + gint n_actions, i; + + n_actions = atk_action_get_n_actions (action); + for (i = 0; i < n_actions; i++) + { + if (!strcmp (atk_action_get_name (action, i), action_name)) + atk_action_set_description (action, i, description); + } +} + diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/support.h b/ltt/branches/poly/lttv/modules/gui/mainWin/src/support.h new file mode 100644 index 00000000..92201b97 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/support.h @@ -0,0 +1,67 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include + +/* + * Standard gettext macros. + */ +#ifdef ENABLE_NLS +# include +# undef _ +# define _(String) dgettext (PACKAGE, String) +# ifdef gettext_noop +# define N_(String) gettext_noop (String) +# else +# define N_(String) (String) +# endif +#else +# define textdomain(String) (String) +# define gettext(String) (String) +# define dgettext(Domain,Message) (Message) +# define dcgettext(Domain,Message,Type) (Message) +# define bindtextdomain(Domain,Directory) (Domain) +# define _(String) (String) +# define N_(String) (String) +#endif + + +/* + * Public Functions. + */ + +/* + * This function returns a widget in a component created by Glade. + * Call it with the toplevel widget in the component (i.e. a window/dialog), + * or alternatively any widget in the component, and the name of the widget + * you want returned. + */ +GtkWidget* lookup_widget (GtkWidget *widget, + const gchar *widget_name); + + +/* Use this function to set the directory containing installed pixmaps. */ +void add_pixmap_directory (const gchar *directory); + + +/* + * Private Functions. + */ + +/* This is used to create the pixmaps used in the interface. */ +GtkWidget* create_pixmap (GtkWidget *widget, + const gchar *filename); + +/* This is used to create the pixbufs used in the interface. */ +GdkPixbuf* create_pixbuf (const gchar *filename); + +/* This is used to set ATK action descriptions. */ +void glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description); + -- 2.34.1