From 687881fc63d91c249f273a0a3d7a6cecb58ee813 Mon Sep 17 00:00:00 2001 From: Christopher Michael Date: Sun, 3 Jan 2010 22:24:07 +0000 Subject: [PATCH] Rework illume2: - Policies are now loadable .so's ;) SVN revision: 44864 --- src/modules/illume2/E_Illume.h | 131 +++++ src/modules/illume2/E_Illume.pc.in | 12 + src/modules/illume2/Makefile.am | 62 ++ src/modules/illume2/e-module-illume2.edj | Bin 0 -> 10097 bytes src/modules/illume2/e_kbd.c | 652 +++++++++++++++++++++ src/modules/illume2/e_kbd.h | 56 ++ src/modules/illume2/e_kbd_dbus.c | 269 +++++++++ src/modules/illume2/e_kbd_dbus.h | 7 + src/modules/illume2/e_mod_animation.c | 121 ++++ src/modules/illume2/e_mod_animation.h | 6 + src/modules/illume2/e_mod_border.c | 473 +++++++++++++++ src/modules/illume2/e_mod_config.c | 212 +++++++ src/modules/illume2/e_mod_config.h | 11 + src/modules/illume2/e_mod_layout.c | 488 +++++++++++++++ src/modules/illume2/e_mod_layout.h | 7 + src/modules/illume2/e_mod_main.c | 112 ++++ src/modules/illume2/e_mod_main.h | 36 ++ src/modules/illume2/e_mod_policy.c | 113 ++++ src/modules/illume2/e_mod_policy.h | 6 + src/modules/illume2/e_mod_policy_settings.c | 120 ++++ src/modules/illume2/e_mod_policy_settings.h | 6 + src/modules/illume2/e_mod_select_window.c | 269 +++++++++ src/modules/illume2/e_mod_select_window.h | 15 + src/modules/illume2/e_mod_windows.c | 217 +++++++ src/modules/illume2/e_mod_windows.h | 6 + src/modules/illume2/e_quickpanel.c | 415 +++++++++++++ src/modules/illume2/e_quickpanel.h | 29 + src/modules/illume2/keyboards/Makefile.am | 11 + .../illume2/keyboards/ignore_built_in_keyboards | 1 + src/modules/illume2/module.desktop.in | 8 + src/modules/illume2/policies/Makefile.am | 2 + src/modules/illume2/policies/illume/Makefile.am | 20 + src/modules/illume2/policies/illume/illume.c | 44 ++ src/modules/illume2/policies/illume/illume.h | 10 + src/modules/illume2/policies/illume/layout.c | 615 +++++++++++++++++++ src/modules/illume2/policies/illume/layout.h | 25 + src/modules/illume2/policies/samsung/Makefile.am | 20 + src/modules/illume2/policies/samsung/layout.c | 615 +++++++++++++++++++ src/modules/illume2/policies/samsung/layout.h | 25 + src/modules/illume2/policies/samsung/samsung.c | 44 ++ src/modules/illume2/policies/samsung/samsung.h | 10 + 41 files changed, 5301 insertions(+) create mode 100644 src/modules/illume2/E_Illume.h create mode 100644 src/modules/illume2/E_Illume.pc.in create mode 100644 src/modules/illume2/Makefile.am create mode 100644 src/modules/illume2/e-module-illume2.edj create mode 100644 src/modules/illume2/e_kbd.c create mode 100644 src/modules/illume2/e_kbd.h create mode 100644 src/modules/illume2/e_kbd_dbus.c create mode 100644 src/modules/illume2/e_kbd_dbus.h create mode 100644 src/modules/illume2/e_mod_animation.c create mode 100644 src/modules/illume2/e_mod_animation.h create mode 100644 src/modules/illume2/e_mod_border.c create mode 100644 src/modules/illume2/e_mod_config.c create mode 100644 src/modules/illume2/e_mod_config.h create mode 100644 src/modules/illume2/e_mod_layout.c create mode 100644 src/modules/illume2/e_mod_layout.h create mode 100644 src/modules/illume2/e_mod_main.c create mode 100644 src/modules/illume2/e_mod_main.h create mode 100644 src/modules/illume2/e_mod_policy.c create mode 100644 src/modules/illume2/e_mod_policy.h create mode 100644 src/modules/illume2/e_mod_policy_settings.c create mode 100644 src/modules/illume2/e_mod_policy_settings.h create mode 100644 src/modules/illume2/e_mod_select_window.c create mode 100644 src/modules/illume2/e_mod_select_window.h create mode 100644 src/modules/illume2/e_mod_windows.c create mode 100644 src/modules/illume2/e_mod_windows.h create mode 100644 src/modules/illume2/e_quickpanel.c create mode 100644 src/modules/illume2/e_quickpanel.h create mode 100644 src/modules/illume2/keyboards/Makefile.am create mode 100644 src/modules/illume2/keyboards/ignore_built_in_keyboards create mode 100644 src/modules/illume2/module.desktop.in create mode 100644 src/modules/illume2/policies/Makefile.am create mode 100644 src/modules/illume2/policies/illume/Makefile.am create mode 100644 src/modules/illume2/policies/illume/illume.c create mode 100644 src/modules/illume2/policies/illume/illume.h create mode 100644 src/modules/illume2/policies/illume/layout.c create mode 100644 src/modules/illume2/policies/illume/layout.h create mode 100644 src/modules/illume2/policies/samsung/Makefile.am create mode 100644 src/modules/illume2/policies/samsung/layout.c create mode 100644 src/modules/illume2/policies/samsung/layout.h create mode 100644 src/modules/illume2/policies/samsung/samsung.c create mode 100644 src/modules/illume2/policies/samsung/samsung.h diff --git a/src/modules/illume2/E_Illume.h b/src/modules/illume2/E_Illume.h new file mode 100644 index 0000000..18cac21 --- /dev/null +++ b/src/modules/illume2/E_Illume.h @@ -0,0 +1,131 @@ +#ifndef E_ILLUME_H +# define E_ILLUME_H + +# include "e.h" + +# define E_ILLUME_LAYOUT_API_VERSION 1 +# define E_ILLUME_LAYOUT_TYPE 0xE0b200b + +typedef enum _E_Illume_Animation_Class +{ + E_ILLUME_ANIM_APP, + E_ILLUME_ANIM_KEYBOARD, + E_ILLUME_ANIM_TOP_SHELF, + E_ILLUME_ANIM_BOTTOM_PANEL, + E_ILLUME_ANIM_DIALOG, + E_ILLUME_ANIM_QUICKPANEL, + E_ILLUME_ANIM_OTHER +} E_Illume_Animation_Class; + +typedef struct _E_Illume_Layout_Api E_Illume_Layout_Api; +typedef struct _E_Illume_Layout_Policy E_Illume_Layout_Policy; +typedef struct _E_Illume_Config E_Illume_Config; + +struct _E_Illume_Layout_Api +{ + int version; + const char *label, *name; +}; + +struct _E_Illume_Layout_Policy +{ + E_Object e_obj_inherit; + + E_Illume_Layout_Api *api; + + void *handle; + + struct + { + void *(*init) (E_Illume_Layout_Policy *p); + int (*shutdown) (E_Illume_Layout_Policy *p); + void (*config) (E_Container *con, const char *params); + + void (*border_add) (E_Border *bd); + void (*border_del) (E_Border *bd); + void (*border_focus_in) (E_Border *bd); + void (*border_focus_out) (E_Border *bd); + void (*border_activate) (E_Border *bd); + void (*zone_layout) (E_Zone *zone); + void (*zone_move_resize) (E_Zone *zone); + void (*drag_start) (E_Border *bd); + void (*drag_end) (E_Border *bd); + } funcs; +}; + +struct _E_Illume_Config +{ + int version; + + struct + { + struct + { + int duration; + } kbd, softkey, quickpanel; + } sliding; + + struct + { + const char *name; + struct + { + const char *class; + const char *name; + const char *title; + int win_type; + struct + { + int class, name, title, win_type; + } match; + } vkbd, softkey, home, indicator; + struct + { + int dual, side; + } mode; + } policy; + + // Not User Configurable. Placeholders + const char *mod_dir; + E_Config_Dialog *cfd; +}; + +EAPI Eina_List *e_illume_layout_policies_get(void); + +EAPI int e_illume_border_is_dialog(E_Border *bd); +EAPI int e_illume_border_is_keyboard(E_Border *bd); +EAPI int e_illume_border_is_bottom_panel(E_Border *bd); +EAPI int e_illume_border_is_top_shelf(E_Border *bd); +EAPI int e_illume_border_is_home(E_Border *bd); +EAPI int e_illume_border_is_conformant(E_Border *bd); +EAPI int e_illume_border_is_quickpanel(E_Border *bd); +EAPI int e_illume_border_is_valid(E_Border *bd); + +EAPI Eina_List *e_illume_border_valid_borders_get(E_Zone *zone); +EAPI E_Border *e_illume_border_valid_border_get(E_Zone *zone); +EAPI int e_illume_border_valid_count_get(E_Zone *zone); +EAPI Eina_List *e_illume_border_quickpanel_borders_get(E_Zone *zone); +EAPI int e_illume_border_quickpanel_count_get(E_Zone *zone); + +EAPI E_Border *e_illume_border_at_xy_get(E_Zone *zone, int x, int y); +EAPI E_Border *e_illume_border_in_region_get(E_Zone *zone, int x, int y, int w, int h); +EAPI E_Border *e_illume_border_keyboard_get(E_Zone *zone); +EAPI E_Border *e_illume_border_top_shelf_get(E_Zone *zone); +EAPI E_Border *e_illume_border_bottom_panel_get(E_Zone *zone); + +EAPI void e_illume_border_top_shelf_pos_get(E_Zone *zone, int *x, int *y); +EAPI void e_illume_border_top_shelf_size_get(E_Zone *zone, int *x, int *y); +EAPI void e_illume_border_bottom_panel_pos_get(E_Zone *zone, int *x, int *y); +EAPI void e_illume_border_bottom_panel_size_get(E_Zone *zone, int *x, int *y); + +EAPI void e_illume_border_slide_to(E_Border *bd, int x, int y, E_Illume_Animation_Class aclass); +EAPI void e_illume_border_min_get(E_Border *bd, int *mw, int *mh); +EAPI void e_illume_border_max_get(E_Border *bd, int *mw, int *mh); + +EAPI void e_illume_border_app1_safe_region_get(E_Zone *zone, int *x, int *y, int *w, int *h); +EAPI void e_illume_border_app2_safe_region_get(E_Zone *zone, int *x, int *y, int *w, int *h); +EAPI void e_illume_kbd_safe_app_region_get(E_Zone *zone, int *x, int *y, int *w, int *h); + +extern EAPI E_Illume_Config *il_cfg; + +#endif diff --git a/src/modules/illume2/E_Illume.pc.in b/src/modules/illume2/E_Illume.pc.in new file mode 100644 index 0000000..87f1d07 --- /dev/null +++ b/src/modules/illume2/E_Illume.pc.in @@ -0,0 +1,12 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@/@PACKAGE@ + +Name: e17-illume2 +Description: Illume2 Module for E17 +Requires: enlightenment +Version: @VERSION@ +Libs: -L${libdir} +Libs.private: +Cflags: -I${includedir} diff --git a/src/modules/illume2/Makefile.am b/src/modules/illume2/Makefile.am new file mode 100644 index 0000000..db4b8b3 --- /dev/null +++ b/src/modules/illume2/Makefile.am @@ -0,0 +1,62 @@ +MAINTAINERCLEANFILES = Makefile.in E_Illume.pc +MODULE = illume2 +SUBDIRS = keyboards policies + +# data files for the module +filesdir = $(libdir)/enlightenment/modules/$(MODULE) +files_DATA = e-module-$(MODULE).edj module.desktop + +EXTRA_DIST = $(files_DATA) + +# the module .so file +INCLUDES = -I. \ + -I$(top_srcdir) \ + -I$(top_srcdir)/src/modules/$(MODULE) \ + -I$(top_srcdir)/src/bin \ + -I$(top_srcdir)/src/lib \ + -I$(top_srcdir)/src/modules \ + @e_cflags@ + +pkgdir = $(libdir)/enlightenment/modules/$(MODULE)/$(MODULE_ARCH) +pkg_LTLIBRARIES = module.la + +EILLUMEHEADERS = E_Illume.h + +module_la_SOURCES = $(EILLUMEHEADERS) \ + e_mod_border.c \ + e_mod_main.h \ + e_mod_main.c \ + e_mod_config.h \ + e_mod_config.c \ + e_mod_animation.h \ + e_mod_animation.c \ + e_kbd.h \ + e_kbd.c \ + e_kbd_dbus.h \ + e_kbd_dbus.c \ + e_quickpanel.h \ + e_quickpanel.c \ + e_mod_layout.h \ + e_mod_layout.c \ + e_mod_policy.h \ + e_mod_policy.c \ + e_mod_policy_settings.h \ + e_mod_policy_settings.c \ + e_mod_windows.h \ + e_mod_windows.c \ + e_mod_select_window.h \ + e_mod_select_window.c + +module_la_LIBADD = @e_libs@ @dlopen_libs@ +module_la_LDFLAGS = -module -avoid-version +module_la_DEPENDENCIES = $(top_builddir)/config.h + +installed_headersdir = $(prefix)/include/@PACKAGE@ +installed_headers_DATA = $(EILLUMEHEADERS) + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = E_Illume.pc + +uninstall: + rm -rf $(DESTDIR)$(libdir)/enlightenment/modules/$(MODULE) + rm -rf $(DESTDIR)$(libdir)/enlightenment/modules/$(MODULE)/policies/ diff --git a/src/modules/illume2/e-module-illume2.edj b/src/modules/illume2/e-module-illume2.edj new file mode 100644 index 0000000000000000000000000000000000000000..d958437393b7e42be7c1666dd6be752d1a20a066 GIT binary patch literal 10097 zcmZ{p2|UzW^uQ;wlx0Lw6nd#%uaIQP+G~BKqEu9vHyC3WhMB>Pv6WYnP*0I1^t9Wa zB!q?vEw+%dFOwy*XW#zkH%o8w|NnoV&vnlE{?0x3-gD2rzv(^2ZuA}$3MB+B8iiW9 z8HHL>ghGj!pits8V3N?5pirxNP$($@P7}WbY#B6oHul0FaZVEt2e}d&JR8TMn-mHq z-~+Fd07yWCIGcq*IzyWU{x8Vo9FBt6;?F@Bg{HFr4@j7k_)Cz;SPEQb3+z4Eh@T;s zWdW-J8=1#>E;|BdE7($qjXa=70viM=%pq)c5ZD+nq^~B|ZyKfxb7jwYKbM^Y6Ul`j zUtb)s6~Gjr-QxPW1KS2RGQZ!rY$LFpV6TGaz-5phi9=u`>)*^}6~N5F7D8;~0Ug#L zVF_|0hp<^CFkfIw&}dvgh$9gPHX2$Km&F511{)cJ%4PomgM9ro#ui{m?vWa>;rhYe zOE4GtA#;8WOoZzLwSrm)4A~E4e|@?92AH40mPBmi0o@x|7uPSG%YFwo3XFe0RDew( ze(a8%zA!IIq;904U4Vw{4XjggHApc&KQgclz>xj8#vKD{RniD-Q9i%5zz!_xYY6N( zF!tKGePJIZk=%>(^<@FGUlb4OQ<4a58J}MiFpouk5x|gr6YvEs{GfpZA`BXy+ZXCj@(#}rB(nDbz#bqBnhV#@7+5OU{Oi>L_7q{z zC|p07uVmgLzan7Bx#Z71*plUom=`d19RMeD_ai2<#WImm@avfGz+GIfHBl5_zC5(Aps3PC{Mb`a%7o4Eu_8b}4oZHt97}VQOwcBaClcD`2-4 zF*9Iy7BPsAe!Pgmc}8afLv!Op?oeyMd@iRgz?RJ1X72rkv%Tg?+maNix||Xl=7m!kQb?~JO&auqf3Dyd&ECREwJB# z@vj31>?km#w&AWpA$cnRW&x7_Y<&fWK^QbA?)>I};TQSA{z{Q}45U7^H^88Nf7+uC zU;&F*53t}xYyjBbi&!Br$iq+ZdV$?t#M*!%=aRoRx_~`f#9)u4n80{74rd7U2-sVY z$i5M{>)iqja>!u|@0<3WaR%PkxZ!708(UclNKq zRxe`mz%~NouNSaa>;$%wJ6|Nu5@3Ju`htWtpgMt_0*Ty(Aza@_z_4H=6AFZ84ecwK z$hlm@^*IiDAFvP}z?>b~1F+2tmi397G2H&6V$vR-*`x9FS z>0;$zK~6fg$2YBEcQM>+GQz-+weN){2u%nWl4EvXkVt-^ z4rG1-$?gl104*CBlIIo3T#yI!a$rcDRUE=*7Qm34%J8udU^)ZipWkj^p1}C;p=4ke zfbr*k1280~ymP4wI@GRABuMtR8>AyN_>ChI2au@gpVRBWz5rwA0HhYQEx=$toZo~XVb4%FVDo&;6m%mvrpO-f z-?3MKiShYu0)06!DUj?v2Z`tqZzVD(c!xq_EwdvLi8wndf#gb2-;N@x!6vqRaDT-?AWqdakB3dBP>;ILE=G7bYa%7tX_ zLBwGQb|hCdH&;9g=Sn5hQQQHjbT=GNcf*pgE+~RMYCkfAL&$tE`v_#1B8g1L>}PjF zIume||I>xD1dKg_j6w$E_?ThIRLtHVEB#*q*<<~`POvgwj@WV8-UpDS+hQp=lq=Q+ zhhi@Q=imVIgtdB5a2T8?Op}5lN9__|`LoL#}V;2;xr6qG&A0qa4eq9{~&rN*Ao zcG`Bgt=qZ86HD~Kp*#r`f-MXQuhevrmslc9NR7sobd&>uhO<}m;z~!93&9mE%Ic;HbQ}T#NgTV9(>AvDuDA@%U`+d;WMk)cE7=P~*j8YjjTW07Ti6$o4q08j+`v zc?y-M*zy!t5(drz5t2qEs!?1>B&s7vcOy|SuvVBb`xRnhZ7DpH?+qX2^+EOm!twfW zO{5Q3Mf&hmS3GPgXL!gn)}EuYOA<<#L{=jsB@7bJm9|`on(P=HgZl=y zjB{^rf`Wc zR4m*HYK|lq5+3J@gS(4Mc(FO}e{2EU`@i^{w>+E9ci-;AQS8VBH{{d8yPq)jz)<#N zES?>O_MeJeB~S%FUfGd6T#*v`0qFm!Y+pW`;Vcc)^%;r_+Gv{xcciQnkL{VwHwVa1-MUqtV%#fr9zu2?O*rQdXZ8~#S=SDTyE zfitFW$JX?OUzc@x(%hy?$k^0)Rb{xE7^!*utN`&?b;@s>lAf)sjeLCWMBIV6w5+Wa z$`yC#&cxjOdo7{9FgNCu0zKZ&tiq=`sY9UrH~RWjTYpj8t^0>v?moSpvo}+^ zG1!H=#_ma?!X1%2a(B=&-#3UWi`$k-d0$#_K$5LQ9lx+dWke%H%|&ZOHFZnQ zc&j(ZoEqEpeD^37E7x;NmhjDlN__uaAk}R4x8n5Uvw8)}3RDU0LxZwkoA3L1J#4jp z%sg1rdQf+_?!M@QC%bOFi!+Nhe|}r8C;x7_#nUPI+d5CDA}7Oysiq0@BHzBQXkS*7 zf1*LB!z_HOG%_xZQr(4%OsUpwJCGk;bmDTG)-#7gIAOP zsXbhC6vmT^>90S{){`r@CU5o|bDj#$~d?^lhrrG0gW9O_WL@#XrhA`ryapPoa6= zp1kjHZGLW@)&H!~raG6>ox4uo(?H+O;NN-{F@647gHtly(EIzt>F;07B^0z%QvL@T#EX{clPh40Miq=VsU!jfw(gN^6&`k$Q(^`97McAm{{^_w|7 z+cz6d9I^xb}->Aq~>)#>c^m38fCSiS*u&tgA zga>Eig2dOHNcN`|VhmUM&l(0Ucs9CNu$Y~Z=SCKqrzRGx1TQ`8%y~=6XvHV^IvHIP zn;hNmJbzoyt)I7xLRdF>g&jNj)!yvpOAUy9U$3oC9;vg zu&YhHp67l)e(cC?{fpTjy@y*!%(=&3YaUocY&K2XbS%y?RLOYW|7l|QR8d3D&CN0riPQUai&f4FMW|NZs_iUFr(=n%`n69&wUORak(8;d(po34NnOluddN_ zQq*k=5PZDF{Qk+AL8iYJq55u&?DsXA4oAv2?+uddydETJG}+cDX*@fGBlML`+9^xW zOw@WZZ>P-Oh*8a`G+>?@d3LTV>qWa>zkZQ=VDbfwkem&zUF$)D-}DnGZ`Was(zTRV z-|905Z)rK#9bOoj8<07s+deL1YT!hilE5dQiCo>?3nj|4q_@mIIUzZr z$(k_5c_U_6ZTQ!E9rR~Qg8*i}93wY6f1SK~rP0tS@)M?(*eSh>Q*^J zdhu1!ScP8w%KY$WZEs5^*{lWc*RY5$gm&ucNR8Gq#mql-wRPybzMb0m{=#2$dbNFq^CUwgAN_sOuT67| ze7f#fVCLzDn}d^;mJPqAC^TJtj#sOopNdLx_h#yvCDr=coEq$LI~HI(pnHQ^Jcd56 zx7~k!R^jh~kda-jc}@>3M}s|m-feO5(SI{bM=_&G5J;QW<}&nWu;BtO^iy;G4Z2^K zoSb!MnsrFUmVY3k zs~TsMgdgoc^T~Abq}$m)Ur3X-+YFQYueOyHHWfB@?ew!?{qpH=vwUfbh7Y~5=S>?3 zVx+8#+L+}}!s3W(W$_tXm9*arZXBL$mnR+A+*+|imsR6)|Vs) z`g|5gS7n#ceMUudUO7GfSA;;T;fDBGzeCrI(~s5Xh?+LM zSyf42cz?b-E7+^9bhGTbR_TX<vD-0=4j5{lT>nhBd1_s;oZ8J9kJkj515JS{S$h z=B_pVEH#@_ISV51WGuMpe8=k!nUAxa-r?1OD~ zmm@1eVGwbA96OIlV;2xz& z{$3F~-fl8abVl#2GxYsZ=1`q1I2&rdcDb9sS6fX%wup~F-Ln01XNUEw_NEqwMvh-o zk~F}y4OWYUew_+y3p_ulzI^gYYG2~#@zXLs7E!q^;UewfA5w9$iatu=Hk+LGhn zO01>tJ5rEdP~t^MF^+52k<{za$3Hetc{_On6FL`7oRBXdxoT8?`R4tPpIf`JhOmvQ zm5Ga+O=pvITuAQVE|xl7Im#UpJJ5bP!Sm^H<+|^J{Z;qxjqQ~jPRW0|NfZ5azhsrE zYNxOB+^nD0_{Amj(@DAckx8@GwCMrG3Za~kqzu+&_13+?xrP!06hpaPQBhQ=ZH(Yd&la7j^X4Uzo84chps*` zP_o5b4m_K)UVbMz%D5$)`Lwj!p}iuhZd;ve=Qa@?{9MJ;xV|N>6*>#6Z)6S_3;Cz9 zBK2G!zrsyKiBuF9uzdR+(|cHDZ*qV2?T@~Caem~g>`phe_UwmG)TJsn*X)jexTfw} zPOM41+&876=t;fSJcFT`eZluMkFcom)|1U^6DK~kk&0Z3S_Abj_%HPmUPyW6<<>mc zC|K!Tn%A)Y`m;HkJyFhr&#PhwN?vcSyOtl_8uQ?>g|7fJ>hfj@x0T&>xn{PQy2*;M zIL*=LnW9Gbb6>o^Go+=+dMRhY()P2e%G0-8(Ik^1KEJBzTq#q*EDdU^l2JL+@FCt) zL91QP=#G&8kdTs|<}=J`6!p2LxGRFEP4uAW)Pu=;D$E{NG5sHRy=caO#I5E84 z4sDHXKJJCfif1m&1d3b`>9fp|yupYco%I(ObUw(~kDeO}_9Ij%P_N;gf>%G%vAuu# zb9%kPL!n~9R8}~X;dFm=G5_bt#Wn8Nw<=XR^wqr3xlu=egTe#(RPeNH{k12+heV z&2HST)^bCvqV9IaXgd9{5lPfvv3(UKUUNBq&@Zn>k@O*|;`@F5xlV^*=H$?}L0Kj% zz~n<>mSk?$Chc<(n*VBT=}x9BeXeKTl{DP=>N@RI3}ZK=!R0E`Z>;r}psmX3&TN&@ z`(r56kpAh}^!Y~;PRw1cq_ZvNrXj*kFT9h{T9(ZbBH6+tiN}Kus6VZ{pg7wszie>t z7Dn>l70I^Er-q9HGg{^jbc4!?U-@Jn;kO=*ApuPyPeuJ>~1zx*?A(q9_eYP`lW*)sF2pe6IlTtsT%6_K*@ z@jB>R`n9GD{X(k!F5l|Qvz$`&lC&T1>P;G69kup&RA^Su%gs*0l_O$Rk2)Lsox6Q1 zKU}{XJfk}0WuBwny{o^*+P~MQeOq1K>v4SDwvkUw>QSA((KB_cW)7(5sG}Y4$xgZ? z_>C0#GqBcM)E(P(FpQlHxftEN@w~8IpFh)%zqlN(QM1{~X**s=Af0ULM?Y9FY~=e< zDQhxC`C#hiQM)tUZN$`wg>2hfmhGyoof_&Pn~&uLyKiW%Yi*v0+qEY(QDI$*(wD#J z`)2$`?`0T$h5!6KNLax2k@kk(fh@6e?RB@;f&v^qqNtzz8Mo(*=weUuCD&@cCtub=InfL<0r#P znym3)$3s;Yr`UmxzHQQ&mYw)j6}@>GBmZXX-SFVSOu@Z-rIbL~L}mv%X0@30)e!BH zKa^NPdTSP*x7oZmw|-88>!vDFJ1Z4!RlJ)ytrIrhmT#1LMb_x6__T=K5|)77QkLrW zd5=3y6ZIpf#h8(iirtSAB5jnyGcr<0`Q}2$L&NYi4>;G8# zeA3`t+`L%Bj%=B|f0)=K|BLb#G+M*O<3~+iZ%V9e9%G)s>^Z$(YmjQn}xkH(XW=WDrj|_yXSLgF zGIcSwtOIL4m^4vOj4$7^+^Bc|_ZJ6lD{Q$QRN;vJvKy7?aXeQNaKG?i|#s?G!r)}kxjdjv;m zE1%!kQBW$JU?zguli{$UC%2DyRwU(3U#{I$;hw{CIrswcT`Q?t*lk@dP4p%q)e{RW z=ag55dbI|^R)Yh*m^s#k7q|rnS3ct}hV?@NtkzSat>Lk*?6PiAEUeLHFn1+ygY_RRa=?4%PE%!+Z%0_ x%2bXny|f)&hCj%nC^toPEV(O`NK{ZRM`u-{-Wsh^E)Q~0QkR8aopZ8%{{z#?SqT6D literal 0 HcmV?d00001 diff --git a/src/modules/illume2/e_kbd.c b/src/modules/illume2/e_kbd.c new file mode 100644 index 0000000..908ed39 --- /dev/null +++ b/src/modules/illume2/e_kbd.c @@ -0,0 +1,652 @@ +#include "E_Illume.h" +#include "e_kbd.h" +#include "e_kbd_dbus.h" + +#define ICONIFY_TO_HIDE 0 + +/* local function prototypes */ +static void _e_kbd_cb_free(E_Kbd *kbd); +static int _e_kbd_cb_delayed_hide(void *data); +static int _e_kbd_cb_animate(void *data); +static E_Kbd *_e_kbd_by_border_get(E_Border *bd); +static void _e_kbd_layout_send(E_Kbd *kbd); +static void _e_kbd_border_show(E_Border *bd); +static void _e_kbd_border_hide(E_Border *bd); +static void _e_kbd_border_adopt(E_Kbd *kbd, E_Border *bd); +static int _e_kbd_border_is_keyboard(E_Border *bd); +static void _e_kbd_hide(E_Kbd *kbd); +static void _e_kbd_slide(E_Kbd *kbd, int visible, double len); +static void _e_kbd_all_show(void); +static void _e_kbd_all_hide(void); +static void _e_kbd_all_toggle(void); +static void _e_kbd_all_layout_set(E_Kbd_Layout layout); + +/* handlers */ +static int _e_kbd_cb_client_message(void *data, int type, void *event); +static int _e_kbd_cb_border_remove(void *data, int type, void *event); +static int _e_kbd_cb_border_focus_in(void *data, int type, void *event); +static int _e_kbd_cb_border_focus_out(void *data, int type, void *event); +static int _e_kbd_cb_border_property(void *data, int type, void *event); + +/* hooks */ +static void _e_kbd_cb_border_pre_post_fetch(void *data, void *data2); + +/* local variables */ +static Eina_List *kbds = NULL, *handlers = NULL, *hooks = NULL; +static E_Border *focused_border = NULL; +static Ecore_X_Atom focused_vkbd_state = 0; + +/* public functions */ +int +e_kbd_init(void) +{ + handlers = + eina_list_append(handlers, + ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, + _e_kbd_cb_client_message, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_REMOVE, + _e_kbd_cb_border_remove, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_FOCUS_IN, + _e_kbd_cb_border_focus_in, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_FOCUS_OUT, + _e_kbd_cb_border_focus_out, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_PROPERTY, + _e_kbd_cb_border_property, NULL)); + + hooks = + eina_list_append(hooks, + e_border_hook_add(E_BORDER_HOOK_EVAL_PRE_POST_FETCH, + _e_kbd_cb_border_pre_post_fetch, NULL)); + + e_kbd_dbus_init(); + + return 1; +} + +int +e_kbd_shutdown(void) +{ + E_Kbd *kbd; + Ecore_Event_Handler *handler; + E_Border_Hook *hook; + + e_kbd_dbus_shutdown(); + + EINA_LIST_FREE(handlers, handler) + ecore_event_handler_del(handler); + + EINA_LIST_FREE(hooks, hook) + e_border_hook_del(hook); + + EINA_LIST_FREE(kbds, kbd) + e_object_del(E_OBJECT(kbd)); + + return 1; +} + +E_Kbd * +e_kbd_new(void) +{ + E_Kbd *kbd; + + kbd = E_OBJECT_ALLOC(E_Kbd, E_KBD_TYPE, _e_kbd_cb_free); + if (!kbd) return NULL; + kbds = eina_list_append(kbds, kbd); + kbd->layout = E_KBD_LAYOUT_ALPHA; + return kbd; +} + +void +e_kbd_all_enable(void) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + e_kbd_enable(kbd); +} + +void +e_kbd_all_disable(void) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + e_kbd_disable(kbd); +} + +void +e_kbd_show(E_Kbd *kbd) +{ + if (kbd->timer) ecore_timer_del(kbd->timer); + kbd->timer = NULL; + if ((kbd->visible) || (kbd->disabled)) return; + _e_kbd_layout_send(kbd); + if (il_cfg->sliding.kbd.duration <= 0) + { + if (kbd->border) + { + e_border_fx_offset(kbd->border, 0, 0); + _e_kbd_border_show(kbd->border); + } + kbd->visible = 1; + } + else + { + if (kbd->border) _e_kbd_border_show(kbd->border); + _e_kbd_slide(kbd, 1, (double)il_cfg->sliding.kbd.duration / 1000.0); + } +} + +void +e_kbd_hide(E_Kbd *kbd) +{ + if (!kbd->visible) return; + if (!kbd->timer) + kbd->timer = ecore_timer_add(0.2, _e_kbd_cb_delayed_hide, kbd); +} + +void +e_kbd_enable(E_Kbd *kbd) +{ + if (!kbd->disabled) return; + kbd->disabled = 0; + if (!kbd->visible) e_kbd_show(kbd); +} + +void +e_kbd_disable(E_Kbd *kbd) +{ + if (kbd->disabled) return; + if (kbd->visible) e_kbd_hide(kbd); + kbd->disabled = 1; +} + +void +e_kbd_layout_set(E_Kbd *kbd, E_Kbd_Layout layout) +{ + kbd->layout = layout; + _e_kbd_layout_send(kbd); +} + +void +e_kbd_fullscreen_set(E_Zone *zone, int fullscreen) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + if ((!!fullscreen) != kbd->fullscreen) + { + kbd->fullscreen = fullscreen; + if (kbd->fullscreen) + e_border_layer_set(kbd->border, 250); + else + e_border_layer_set(kbd->border, 100); + } +} + +EAPI void +e_illume_kbd_safe_app_region_get(E_Zone *zone, int *x, int *y, int *w, int *h) +{ + Eina_List *l; + E_Kbd *kbd; + + if (x) *x = zone->x; + if (y) *y = zone->y; + if (w) *w = zone->w; + if (h) *h = zone->h; + EINA_LIST_FOREACH(kbds, l, kbd) + { + if (!kbd->border) continue; + if (kbd->border->zone != zone) continue; + if ((kbd->visible) && (!kbd->animator) && (!kbd->disabled)) + { + if (h) + { + *h -= kbd->border->h; + if (*h < 0) *h = 0; + } + } + return; + } +} + +/* local functions */ +static void +_e_kbd_cb_free(E_Kbd *kbd) +{ + E_Border *bd; + + if (kbd->animator) ecore_animator_del(kbd->animator); + kbd->animator = NULL; + if (kbd->timer) ecore_timer_del(kbd->timer); + kbd->timer = NULL; + EINA_LIST_FREE(kbd->waiting_borders, bd) + bd->stolen = 0; + E_FREE(kbd); +} + +static int +_e_kbd_cb_delayed_hide(void *data) +{ + E_Kbd *kbd; + + if (!(kbd = data)) return 0; + _e_kbd_hide(kbd); + kbd->timer = NULL; + return 0; +} + +static int +_e_kbd_cb_animate(void *data) +{ + E_Kbd *kbd; + double t, v; + + kbd = data; + t = ecore_loop_time_get() - kbd->start; + if (t > kbd->len) t = kbd->len; + if (kbd->len > 0.0) + { + v = t / kbd->len; + v = 1.0 - v; + v = v * v * v * v; + v = 1.0 - v; + } + else + { + t = kbd->len; + v = 1.0; + } + kbd->adjust = (kbd->adjust_end * v) + (kbd->adjust_start * (1.0 - v)); + if (kbd->border) + e_border_fx_offset(kbd->border, 0, kbd->border->h - kbd->adjust); + if (t == kbd->len) + { + kbd->animator = NULL; + if (kbd->visible) + { + _e_kbd_border_hide(kbd->border); + kbd->visible = 0; + } + else + kbd->visible = 1; + _e_kbd_layout_send(kbd); + return 0; + } + return 1; +} + +static E_Kbd * +_e_kbd_by_border_get(E_Border *bd) +{ + Eina_List *l, *ll; + E_Border *over; + E_Kbd *kbd; + + if (!bd->stolen) return NULL; + EINA_LIST_FOREACH(kbds, l, kbd) + { + if (kbd->border == bd) return kbd; + EINA_LIST_FOREACH(kbd->waiting_borders, ll, over) + if (over == bd) return kbd; + } + return NULL; +} + +static void +_e_kbd_layout_send(E_Kbd *kbd) +{ + Ecore_X_Virtual_Keyboard_State type; + + if ((kbd->visible) && (!kbd->disabled)) + { + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_ON; + if (kbd->layout == E_KBD_LAYOUT_DEFAULT) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_ON; + else if (kbd->layout == E_KBD_LAYOUT_ALPHA) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA; + else if (kbd->layout == E_KBD_LAYOUT_NUMERIC) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC; + else if (kbd->layout == E_KBD_LAYOUT_PIN) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN; + else if (kbd->layout == E_KBD_LAYOUT_PHONE_NUMBER) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER; + else if (kbd->layout == E_KBD_LAYOUT_HEX) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX; + else if (kbd->layout == E_KBD_LAYOUT_TERMINAL) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL; + else if (kbd->layout == E_KBD_LAYOUT_PASSWORD) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD; + else if (kbd->layout == E_KBD_LAYOUT_NONE) + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF; + } + else + type = ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF; + if (kbd->border) + ecore_x_e_virtual_keyboard_state_send(kbd->border->client.win, type); +} + +static void +_e_kbd_border_show(E_Border *bd) +{ + if (!bd) return; + e_border_uniconify(bd); + e_border_show(bd); + e_border_raise(bd); +} + +static void +_e_kbd_border_hide(E_Border *bd) +{ + if (!bd) return; +#ifdef ICONIFY_TO_HIDE + e_border_iconify(bd); +#else + e_border_hide(bd, 2); +#endif +} + +static void +_e_kbd_border_adopt(E_Kbd *kbd, E_Border *bd) +{ + kbd->border = bd; + bd->sticky = 1; + if (kbd->fullscreen) + e_border_layer_set(kbd->border, 250); + else + e_border_layer_set(kbd->border, 100); + if (!kbd->visible) + { + e_border_fx_offset(kbd->border, 0, kbd->border->h); + _e_kbd_layout_send(kbd); + } + kbd->h = kbd->border->h; +} + +static int +_e_kbd_border_is_keyboard(E_Border *bd) +{ + if ((bd->client.vkbd.vkbd) || /* explicit hint that its a virtual keyboard */ + /* legacy */ + ( /* trap the matchbox qwerty and multitap kbd's */ + (((bd->client.icccm.title) && (!strcmp(bd->client.icccm.title, "Keyboard"))) || + ((bd->client.icccm.name) && ((!strcmp(bd->client.icccm.name, "multitap-pad"))))) + && (bd->client.netwm.state.skip_taskbar) + && (bd->client.netwm.state.skip_pager))) + return 1; + return 0; +} + +static void +_e_kbd_hide(E_Kbd *kbd) +{ + if (kbd->timer) ecore_timer_del(kbd->timer); + kbd->timer = NULL; + if ((!kbd->visible) || (kbd->disabled)) return; + _e_kbd_layout_send(kbd); + if (il_cfg->sliding.kbd.duration <= 0) + { + if (kbd->border) + { + e_border_fx_offset(kbd->border, 0, kbd->border->h); + _e_kbd_border_hide(kbd->border); + } + kbd->visible = 0; + } + else + _e_kbd_slide(kbd, 0, (double)il_cfg->sliding.kbd.duration / 1000.0); +} + +static void +_e_kbd_slide(E_Kbd *kbd, int visible, double len) +{ + kbd->start = ecore_loop_time_get(); + kbd->len = len; + kbd->adjust_start = kbd->adjust; + kbd->adjust_end = 0; + if ((visible) && (kbd->border)) + kbd->adjust_end = kbd->border->h; + if (!kbd->animator) + kbd->animator = ecore_animator_add(_e_kbd_cb_animate, kbd); +} + +static void +_e_kbd_all_show(void) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + e_kbd_show(kbd); +} + +static void +_e_kbd_all_hide(void) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + e_kbd_hide(kbd); +} + +static void +_e_kbd_all_toggle(void) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + { + if (kbd->visible) e_kbd_hide(kbd); + else e_kbd_show(kbd); + } +} + +static void +_e_kbd_all_layout_set(E_Kbd_Layout layout) +{ + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + e_kbd_layout_set(kbd, layout); +} + +/* handlers */ +static int +_e_kbd_cb_client_message(void *data, int type, void *event) +{ + Ecore_X_Event_Client_Message *ev; + + ev = event; + if (ev->win != ecore_x_window_root_first_get()) return 1; + if ((ev->message_type == ecore_x_atom_get("_MB_IM_INVOKER_COMMAND")) || + (ev->message_type == ecore_x_atom_get("_MTP_IM_INVOKER_COMMAND"))) + { + if (ev->data.l[0] == 1) _e_kbd_all_show(); + else if (ev->data.l[0] == 2) _e_kbd_all_hide(); + else if (ev->data.l[0] == 3) _e_kbd_all_toggle(); + } + return 1; +} + +static int +_e_kbd_cb_border_remove(void *data, int type, void *event) +{ + E_Event_Border_Remove *ev; + E_Kbd *kbd; + + ev = event; + if (ev->border == focused_border) + { + focused_border = NULL; + focused_vkbd_state = 0; + return 1; + } + if (!(kbd = _e_kbd_by_border_get(ev->border))) return 1; + if (kbd->border == ev->border) + { + kbd->border = NULL; + if (kbd->waiting_borders) + { + E_Border *bd; + + bd = kbd->waiting_borders->data; + kbd->waiting_borders = + eina_list_remove_list(kbd->waiting_borders, kbd->waiting_borders); + _e_kbd_border_adopt(kbd, bd); + } + if (kbd->visible) + { + _e_kbd_border_hide(ev->border); + e_kbd_hide(kbd); + } + } + else + kbd->waiting_borders = eina_list_remove(kbd->waiting_borders, ev->border); + return 1; +} + +static int +_e_kbd_cb_border_focus_in(void *data, int type, void *event) +{ + E_Event_Border_Focus_In *ev; + + ev = event; + if (_e_kbd_by_border_get(ev->border)) return 1; + focused_border = ev->border; + focused_vkbd_state = ev->border->client.vkbd.state; + if (focused_vkbd_state == 0) return 1; + if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + _e_kbd_all_layout_set(E_KBD_LAYOUT_NONE); + _e_kbd_all_hide(); + return 1; + } + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA) + _e_kbd_all_layout_set(E_KBD_LAYOUT_ALPHA); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC) + _e_kbd_all_layout_set(E_KBD_LAYOUT_NUMERIC); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN) + _e_kbd_all_layout_set(E_KBD_LAYOUT_PIN); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER) + _e_kbd_all_layout_set(E_KBD_LAYOUT_PHONE_NUMBER); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX) + _e_kbd_all_layout_set(E_KBD_LAYOUT_HEX); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL) + _e_kbd_all_layout_set(E_KBD_LAYOUT_TERMINAL); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD) + _e_kbd_all_layout_set(E_KBD_LAYOUT_PASSWORD); + else + _e_kbd_all_layout_set(E_KBD_LAYOUT_DEFAULT); + _e_kbd_all_show(); + return 1; +} + +static int +_e_kbd_cb_border_focus_out(void *data, int type, void *event) +{ + E_Event_Border_Focus_Out *ev; + + ev = event; + if (_e_kbd_by_border_get(ev->border)) return 1; + _e_kbd_all_layout_set(E_KBD_LAYOUT_NONE); + _e_kbd_all_hide(); + focused_border = NULL; + focused_vkbd_state = 0; + return 1; +} + +static int +_e_kbd_cb_border_property(void *data, int type, void *event) +{ + E_Event_Border_Property *ev; + + ev = event; + if (_e_kbd_by_border_get(ev->border)) return 1; + if (!ev->border->focused) return 1; + if ((ev->border == focused_border) && + (ev->border->client.vkbd.state == focused_vkbd_state)) return 1; + focused_vkbd_state = ev->border->client.vkbd.state; + if ((ev->border->need_fullscreen) || (ev->border->fullscreen)) + e_kbd_fullscreen_set(ev->border->zone, 1); + else + e_kbd_fullscreen_set(ev->border->zone, 0); + if (ev->border->client.vkbd.state == 0) return 1; + /* app wants kbd off - then kbd off it is */ + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + _e_kbd_all_hide(); + /* app wants something else than off... */ + else + { + if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ALPHA) + _e_kbd_all_layout_set(E_KBD_LAYOUT_ALPHA); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_NUMERIC) + _e_kbd_all_layout_set(E_KBD_LAYOUT_NUMERIC); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PIN) + _e_kbd_all_layout_set(E_KBD_LAYOUT_PIN); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PHONE_NUMBER) + _e_kbd_all_layout_set(E_KBD_LAYOUT_PHONE_NUMBER); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_HEX) + _e_kbd_all_layout_set(E_KBD_LAYOUT_HEX); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_TERMINAL) + _e_kbd_all_layout_set(E_KBD_LAYOUT_TERMINAL); + else if (ev->border->client.vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_PASSWORD) + _e_kbd_all_layout_set(E_KBD_LAYOUT_PASSWORD); + else + _e_kbd_all_layout_set(E_KBD_LAYOUT_DEFAULT); + _e_kbd_all_show(); + } + return 1; +} + +/* hooks */ +static void +_e_kbd_cb_border_pre_post_fetch(void *data, void *data2) +{ + E_Border *bd; + + if (!(bd = data2)) return; + if (!bd->new_client) return; + if (_e_kbd_by_border_get(bd)) return; + if (_e_kbd_border_is_keyboard(bd)) + { + Eina_List *l; + E_Kbd *kbd; + + EINA_LIST_FOREACH(kbds, l, kbd) + { + if (!kbd->border) + _e_kbd_border_adopt(kbd, bd); + else + kbd->waiting_borders = eina_list_append(kbd->waiting_borders, bd); + bd->stolen = 1; + if (bd->remember) + { + if (bd->bordername) + { + eina_stringshare_del(bd->bordername); + bd->bordername = NULL; + bd->client.border.changed = 1; + } + e_remember_unuse(bd->remember); + bd->remember = NULL; + } + eina_stringshare_replace(&bd->bordername, "borderless"); + bd->client.border.changed = 1; + return; + } + } +} diff --git a/src/modules/illume2/e_kbd.h b/src/modules/illume2/e_kbd.h new file mode 100644 index 0000000..bfd18e1 --- /dev/null +++ b/src/modules/illume2/e_kbd.h @@ -0,0 +1,56 @@ +#ifndef E_KBD_H +#define E_KBD_H + +#define E_KBD_TYPE 0xE1b0988 + +typedef enum _E_Kbd_Layout E_Kbd_Layout; +enum _E_Kbd_Layout +{ + E_KBD_LAYOUT_NONE, + E_KBD_LAYOUT_DEFAULT, + E_KBD_LAYOUT_ALPHA, + E_KBD_LAYOUT_NUMERIC, + E_KBD_LAYOUT_PIN, + E_KBD_LAYOUT_PHONE_NUMBER, + E_KBD_LAYOUT_HEX, + E_KBD_LAYOUT_TERMINAL, + E_KBD_LAYOUT_PASSWORD, + E_KBD_LAYOUT_IP, + E_KBD_LAYOUT_HOST, + E_KBD_LAYOUT_FILE, + E_KBD_LAYOUT_URL, + E_KBD_LAYOUT_KEYPAD, + E_KBD_LAYOUT_J2ME +}; + +typedef struct _E_Kbd E_Kbd; +struct _E_Kbd +{ + E_Object e_obj_inherit; + E_Border *border; + Ecore_Timer *timer; + Ecore_Animator *animator; + E_Kbd_Layout layout; + Eina_List *waiting_borders; + + double start, len; + int h, adjust, adjust_start, adjust_end; + unsigned char visible : 1; + unsigned char disabled : 1; + unsigned char fullscreen : 1; +}; + +int e_kbd_init(void); +int e_kbd_shutdown(void); + +E_Kbd *e_kbd_new(void); +void e_kbd_all_enable(void); +void e_kbd_all_disable(void); +void e_kbd_show(E_Kbd *kbd); +void e_kbd_hide(E_Kbd *kbd); +void e_kbd_enable(E_Kbd *kbd); +void e_kbd_disable(E_Kbd *kbd); +void e_kbd_layout_set(E_Kbd *kbd, E_Kbd_Layout layout); +void e_kbd_fullscreen_set(E_Zone *zone, int fullscreen); + +#endif diff --git a/src/modules/illume2/e_kbd_dbus.c b/src/modules/illume2/e_kbd_dbus.c new file mode 100644 index 0000000..ea91ba0 --- /dev/null +++ b/src/modules/illume2/e_kbd_dbus.c @@ -0,0 +1,269 @@ +#include "E_Illume.h" +#include "e_kbd.h" +#include "e_kbd_dbus.h" + +/* local variables */ +static int have_real_kbd = 0; +static E_DBus_Connection *dbus_conn = NULL; +static E_DBus_Signal_Handler *dbus_dev_add = NULL; +static E_DBus_Signal_Handler *dbus_dev_del = NULL; +static E_DBus_Signal_Handler *dbus_dev_chg = NULL; +static Eina_List *dbus_kbds = NULL, *ignore_kbds = NULL; + +/* local function prototypes */ +static void _e_kbd_dbus_cb_input_kbd(void *data, void *reply, DBusError *err); +static void _e_kbd_dbus_cb_input_kbd_is(void *data, void *reply, DBusError *err); +static void _e_kbd_dbus_ignore_kbds_load(void); +static void _e_kbd_dbus_ignore_kbds_file_load(const char *file); +static void _e_kbd_dbus_kbd_add(const char *udi); +static void _e_kbd_dbus_kbd_del(const char *udi); +static void _e_kbd_dbus_kbd_eval(void); +static void _e_kbd_dbus_dev_add(void *data, DBusMessage *msg); +static void _e_kbd_dbus_dev_del(void *data, DBusMessage *msg); +static void _e_kbd_dbus_dev_chg(void *data, DBusMessage *msg); + +/* public functions */ +void +e_kbd_dbus_init(void) +{ + /* load the 'ignore' keyboard files */ + _e_kbd_dbus_ignore_kbds_load(); + + /* attempt to connect to the system dbus */ + if (!(dbus_conn = e_dbus_bus_get(DBUS_BUS_SYSTEM))) return; + + /* ask HAL for any input keyboards */ + e_hal_manager_find_device_by_capability(dbus_conn, "input.keyboard", + _e_kbd_dbus_cb_input_kbd, NULL); + + /* setup dbus signal handlers for when a device gets added/removed/changed */ + dbus_dev_add = + e_dbus_signal_handler_add(dbus_conn, "org.freedesktop.Hal", + "/org/freedesktop/Hal/Manager", + "org.freedesktop.Hal.Manager", + "DeviceAdded", _e_kbd_dbus_dev_add, NULL); + dbus_dev_del = + e_dbus_signal_handler_add(dbus_conn, "org.freedesktop.Hal", + "/org/freedesktop/Hal/Manager", + "org.freedesktop.Hal.Manager", + "DeviceRemoved", _e_kbd_dbus_dev_del, NULL); + dbus_dev_chg = + e_dbus_signal_handler_add(dbus_conn, "org.freedesktop.Hal", + "/org/freedesktop/Hal/Manager", + "org.freedesktop.Hal.Manager", + "NewCapability", _e_kbd_dbus_dev_chg, NULL); +} + +void +e_kbd_dbus_shutdown(void) +{ + char *str; + + /* remove the dbus signal handlers if we can */ + if (dbus_conn) + { + e_dbus_signal_handler_del(dbus_conn, dbus_dev_add); + e_dbus_signal_handler_del(dbus_conn, dbus_dev_del); + e_dbus_signal_handler_del(dbus_conn, dbus_dev_chg); + } + + /* free the list of ignored keyboards */ + EINA_LIST_FREE(ignore_kbds, str) + eina_stringshare_del(str); + + /* free the list of keyboards */ + EINA_LIST_FREE(dbus_kbds, str) + eina_stringshare_del(str); +} + +/* local functions */ +static void +_e_kbd_dbus_cb_input_kbd(void *data, void *reply, DBusError *err) +{ + E_Hal_Manager_Find_Device_By_Capability_Return *ret = reply; + Eina_List *l; + char *dev; + + if ((!ret) || (!ret->strings)) return; + + /* if dbus errored then cleanup and get out */ + if (dbus_error_is_set(err)) + { + dbus_error_free(err); + return; + } + + /* for each returned keyboard, add it and evaluate it */ + EINA_LIST_FOREACH(ret->strings, l, dev) + { + _e_kbd_dbus_kbd_add(dev); + _e_kbd_dbus_kbd_eval(); + } +} + +static void +_e_kbd_dbus_cb_input_kbd_is(void *data, void *reply, DBusError *err) +{ + E_Hal_Device_Query_Capability_Return *ret = reply; + char *udi = data; + + /* if dbus errored then cleanup and get out */ + if (dbus_error_is_set(err)) + { + dbus_error_free(err); + if (udi) free(udi); + return; + } + + /* if it's an input keyboard, than add it and eval */ + if ((ret) && (ret->boolean)) + { + _e_kbd_dbus_kbd_add(udi); + _e_kbd_dbus_kbd_eval(); + } +} + +static void +_e_kbd_dbus_ignore_kbds_load(void) +{ + char buff[PATH_MAX]; + + /* load the 'ignore' file from the user's home dir */ + e_user_dir_concat_static(buff, "keyboards/ignore_built_in_keyboards"); + _e_kbd_dbus_ignore_kbds_file_load(buff); + + /* load the 'ignore' file from the system/module dir */ + snprintf(buff, sizeof(buff), + "%s/keyboards/ignore_built_in_keyboards", il_cfg->mod_dir); + _e_kbd_dbus_ignore_kbds_file_load(buff); +} + +static void +_e_kbd_dbus_ignore_kbds_file_load(const char *file) +{ + char buf[PATH_MAX]; + FILE *f; + + /* can this file be opened */ + if (!(f = fopen(file, "r"))) return; + + /* parse out the info in the ignore file */ + while (fgets(buf, sizeof(buf), f)) + { + char *p; + int len; + + if (buf[0] == '#') continue; + len = strlen(buf); + if (len > 0) + { + if (buf[len - 1] == '\n') buf[len - 1] = 0; + } + p = buf; + while (isspace(*p)) p++; + + /* append this kbd to the ignore list */ + if (*p) + ignore_kbds = eina_list_append(ignore_kbds, eina_stringshare_add(p)); + } + fclose(f); +} + +static void +_e_kbd_dbus_kbd_add(const char *udi) +{ + const char *str; + Eina_List *l; + + EINA_LIST_FOREACH(dbus_kbds, l, str) + if (!strcmp(str, udi)) return; + dbus_kbds = eina_list_append(dbus_kbds, eina_stringshare_add(udi)); +} + +static void +_e_kbd_dbus_kbd_del(const char *udi) +{ + const char *str; + Eina_List *l; + + EINA_LIST_FOREACH(dbus_kbds, l, str) + if (!strcmp(str, udi)) + { + eina_stringshare_del(str); + dbus_kbds = eina_list_remove_list(dbus_kbds, l); + return; + } +} + +static void +_e_kbd_dbus_kbd_eval(void) +{ + Eina_List *l, *ll; + const char *g, *gg; + int have_real = 0; + + have_real = eina_list_count(dbus_kbds); + EINA_LIST_FOREACH(dbus_kbds, l, g) + EINA_LIST_FOREACH(ignore_kbds, ll, gg) + if (e_util_glob_match(g, gg)) + { + have_real--; + break; + } + if (have_real != have_real_kbd) + { + have_real_kbd = have_real; +#if 0 + if (have_real_kbd) e_kbd_all_disable(); + else +#endif + e_kbd_all_enable(); + } +} + +static void +_e_kbd_dbus_dev_add(void *data, DBusMessage *msg) +{ + DBusError err; + char *udi; + int ret; + + dbus_error_init(&err); + dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &udi, DBUS_TYPE_INVALID); + ret = e_hal_device_query_capability(dbus_conn, udi, "input.keyboard", + _e_kbd_dbus_cb_input_kbd_is, udi); +} + +static void +_e_kbd_dbus_dev_del(void *data, DBusMessage *msg) +{ + DBusError err; + char *udi; + + dbus_error_init(&err); + dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &udi, DBUS_TYPE_INVALID); + if (udi) + { + _e_kbd_dbus_kbd_del(udi); + _e_kbd_dbus_kbd_eval(); + free(udi); + } +} + +static void +_e_kbd_dbus_dev_chg(void *data, DBusMessage *msg) +{ + DBusError err; + char *udi, *cap; + + dbus_error_init(&err); + dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &udi, + DBUS_TYPE_STRING, &cap, DBUS_TYPE_INVALID); + if (!strcmp(cap, "input.keyboard")) + { + _e_kbd_dbus_kbd_add(udi); + _e_kbd_dbus_kbd_eval(); + } + if (cap) free(cap); + if (udi) free(udi); +} diff --git a/src/modules/illume2/e_kbd_dbus.h b/src/modules/illume2/e_kbd_dbus.h new file mode 100644 index 0000000..c863c27 --- /dev/null +++ b/src/modules/illume2/e_kbd_dbus.h @@ -0,0 +1,7 @@ +#ifndef E_KBD_DBUS_H +#define E_KBD_DBUS_H + +void e_kbd_dbus_init(void); +void e_kbd_dbus_shutdown(void); + +#endif diff --git a/src/modules/illume2/e_mod_animation.c b/src/modules/illume2/e_mod_animation.c new file mode 100644 index 0000000..414b117 --- /dev/null +++ b/src/modules/illume2/e_mod_animation.c @@ -0,0 +1,121 @@ +#include "E_Illume.h" +#include "e_mod_animation.h" + +/* local function prototypes */ +static void *_il_config_animation_create(E_Config_Dialog *cfd); +static void _il_config_animation_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata); +static Evas_Object *_il_config_animation_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata); +static void _il_config_animation_change(void *data, Evas_Object *obj, void *event); +static int _il_config_animation_change_timeout(void *data); + +/* local variables */ +Ecore_Timer *_anim_change_timer = NULL; + +/* public functions */ +void +il_config_animation_show(E_Container *con, const char *params) +{ + E_Config_Dialog *cfd; + E_Config_Dialog_View *v; + + if (e_config_dialog_find("E", "_config_illume_animation_settings")) return; + v = E_NEW(E_Config_Dialog_View, 1); + v->create_cfdata = _il_config_animation_create; + v->free_cfdata = _il_config_animation_free; + v->basic.create_widgets = _il_config_animation_ui; + v->basic_only = 1; + v->normal_win = 1; + v->scroll = 1; + cfd = e_config_dialog_new(con, _("Animation Settings"), "E", + "_config_illume_animation_settings", + "enlightenment/animation_settings", 0, v, NULL); + e_dialog_resizable_set(cfd->dia, 1); +} + +/* local function prototypes */ +static void * +_il_config_animation_create(E_Config_Dialog *cfd) +{ + return NULL; +} + +static void +_il_config_animation_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata) +{ + if (_anim_change_timer) ecore_timer_del(_anim_change_timer); +} + +static Evas_Object * +_il_config_animation_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata) +{ + Evas_Object *list, *of, *ow; + E_Radio_Group *rg; + + list = e_widget_list_add(evas, 0, 0); + + of = e_widget_framelist_add(evas, _("Keyboard"), 0); + rg = e_widget_radio_group_new(&(il_cfg->sliding.kbd.duration)); + ow = e_widget_radio_add(evas, _("Slow"), 2000, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Medium"), 1000, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Fast"), 500, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Very Fast"), 250, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Off"), 0, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + of = e_widget_framelist_add(evas, _("Quickpanel"), 0); + rg = e_widget_radio_group_new(&(il_cfg->sliding.quickpanel.duration)); + ow = e_widget_radio_add(evas, _("Slow"), 2000, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Medium"), 1000, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Fast"), 500, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Very Fast"), 250, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + ow = e_widget_radio_add(evas, _("Off"), 0, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_animation_change, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + return list; +} + +static void +_il_config_animation_change(void *data, Evas_Object *obj, void *event) +{ + if (_anim_change_timer) ecore_timer_del(_anim_change_timer); + _anim_change_timer = + ecore_timer_add(0.5, _il_config_animation_change_timeout, data); +} + +static int +_il_config_animation_change_timeout(void *data) +{ + e_config_save_queue(); + _anim_change_timer = NULL; + return 0; +} diff --git a/src/modules/illume2/e_mod_animation.h b/src/modules/illume2/e_mod_animation.h new file mode 100644 index 0000000..cf8a36e --- /dev/null +++ b/src/modules/illume2/e_mod_animation.h @@ -0,0 +1,6 @@ +#ifndef E_MOD_ANIM_H +#define E_MOD_ANIM_H + +void il_config_animation_show(E_Container *con, const char *params); + +#endif diff --git a/src/modules/illume2/e_mod_border.c b/src/modules/illume2/e_mod_border.c new file mode 100644 index 0000000..8835238 --- /dev/null +++ b/src/modules/illume2/e_mod_border.c @@ -0,0 +1,473 @@ +#include "E_Illume.h" +#include "e_kbd.h" + +////////////////////////////////////////////////////////////////////////////// +// :: Convenience routines to make it easy to write layout logic code :: + +// activate a window - meant for main app and home app windows +void +e_illume_border_activate(E_Border *bd) +{ + e_desk_show(bd->desk); + e_border_uniconify(bd); + e_border_raise(bd); + e_border_show(bd); + e_border_focus_set(bd, 1, 1); +} + +// activate a window that isnt meant to get the focus - like panels, kbd etc. +void +e_illume_border_show(E_Border *bd) +{ + e_desk_show(bd->desk); + e_border_uniconify(bd); + e_border_raise(bd); + e_border_show(bd); +} + +// get a window away from being visile (but maintain it) +void +e_illume_border_deactivate(E_Border *bd) +{ + e_border_iconify(bd); +} + +// get window info - is this one a dialog? +EAPI int +e_illume_border_is_dialog(E_Border *bd) +{ + int isdialog = 0, i; + + if (bd->client.icccm.transient_for != 0) isdialog = 1; + if (bd->client.netwm.type == ECORE_X_WINDOW_TYPE_DIALOG) + { + isdialog = 1; + if (bd->client.netwm.extra_types) + { + for (i = 0; i < bd->client.netwm.extra_types_num; i++) + { + if (bd->client.netwm.extra_types[i] == + ECORE_X_WINDOW_TYPE_UNKNOWN) continue; + if ((bd->client.netwm.extra_types[i] != + ECORE_X_WINDOW_TYPE_DIALOG) && + (bd->client.netwm.extra_types[i] != + ECORE_X_WINDOW_TYPE_SPLASH)) + { + return 0; + } + } + } + } + return isdialog; +} + +// get window info - is this a vkbd window +EAPI int +e_illume_border_is_keyboard(E_Border *bd) +{ + if (bd->client.vkbd.vkbd) return 1; + if (il_cfg->policy.vkbd.match.title) + { + if ((bd->client.icccm.title) && + (!strcmp(bd->client.icccm.title, il_cfg->policy.vkbd.title))) + return 1; + } + if (il_cfg->policy.vkbd.match.name) + { + if ((bd->client.icccm.name) && + (!strcmp(bd->client.icccm.name, il_cfg->policy.vkbd.name))) + return 1; + } + if (il_cfg->policy.vkbd.match.class) + { + if ((bd->client.icccm.class) && + (!strcmp(bd->client.icccm.class, il_cfg->policy.vkbd.class))) + return 1; + } + if ((bd->client.icccm.name) && + ((!strcmp(bd->client.icccm.name, "multitap-pad"))) + && (bd->client.netwm.state.skip_taskbar) + && (bd->client.netwm.state.skip_pager)) + return 1; + return 0; +} + +// get window info - is it a bottom app panel window (eg qtopia softmenu) +EAPI int +e_illume_border_is_bottom_panel(E_Border *bd) +{ + if (il_cfg->policy.softkey.match.title) + { + if ((bd->client.icccm.title) && + (!strcmp(bd->client.icccm.title, il_cfg->policy.softkey.title))) + return 1; + } + if (il_cfg->policy.softkey.match.name) + { + if ((bd->client.icccm.name) && + (!strcmp(bd->client.icccm.name, il_cfg->policy.softkey.name))) + return 1; + } + if (il_cfg->policy.softkey.match.class) + { + if ((bd->client.icccm.class) && + (!strcmp(bd->client.icccm.class, il_cfg->policy.softkey.class))) + return 1; + } + if (((bd->client.netwm.type == ECORE_X_WINDOW_TYPE_DOCK) || + (bd->client.qtopia.soft_menu))) + return 1; + return 0; +} + +// get window info - is it a top shelf window +EAPI int +e_illume_border_is_top_shelf(E_Border *bd) +{ + if (il_cfg->policy.indicator.match.title) + { + if ((bd->client.icccm.title) && + (!strcmp(bd->client.icccm.title, il_cfg->policy.indicator.title))) + return 1; + } + if (il_cfg->policy.indicator.match.name) + { + if ((bd->client.icccm.name) && + (!strcmp(bd->client.icccm.name, il_cfg->policy.indicator.name))) + return 1; + } + if (il_cfg->policy.indicator.match.class) + { + if ((bd->client.icccm.class) && + (!strcmp(bd->client.icccm.class, il_cfg->policy.indicator.class))) + return 1; + } + return 0; +} + +// get window info - is it a home window +EAPI int +e_illume_border_is_home(E_Border *bd) +{ + if (il_cfg->policy.home.match.title) + { + if ((bd->client.icccm.title) && + (!strcmp(bd->client.icccm.title, il_cfg->policy.home.title))) + return 1; + } + if (il_cfg->policy.home.match.name) + { + if ((bd->client.icccm.name) && + (!strcmp(bd->client.icccm.name, il_cfg->policy.home.name))) + return 1; + } + if (il_cfg->policy.home.match.class) + { + if ((bd->client.icccm.class) && + (!strcmp(bd->client.icccm.class, il_cfg->policy.home.class))) + return 1; + } + return 0; +} + +EAPI int +e_illume_border_is_conformant(E_Border *bd) +{ + if (strstr(bd->client.icccm.class, "config")) return EINA_FALSE; + return ecore_x_e_illume_conformant_get(bd->client.win); +} + +EAPI int +e_illume_border_is_quickpanel(E_Border *bd) +{ + if (strstr(bd->client.icccm.class, "config")) return EINA_FALSE; + return ecore_x_e_illume_quickpanel_get(bd->client.win); +} + +EAPI int +e_illume_border_is_valid(E_Border *bd) +{ + if (!bd) return EINA_FALSE; + if (e_illume_border_is_dialog(bd)) return EINA_FALSE; + if (e_illume_border_is_keyboard(bd)) return EINA_FALSE; + if (e_illume_border_is_bottom_panel(bd)) return EINA_FALSE; + if (e_illume_border_is_top_shelf(bd)) return EINA_FALSE; + if (e_illume_border_is_quickpanel(bd)) return EINA_FALSE; + return EINA_TRUE; +} + +EAPI Eina_List * +e_illume_border_valid_borders_get(E_Zone *zone) +{ + Eina_List *bds, *l, *ret = NULL; + E_Border *bd; + + bds = e_border_client_list(); + EINA_LIST_FOREACH(bds, l, bd) + { + if (!bd) continue; + if (bd->zone != zone) continue; + if (e_illume_border_is_top_shelf(bd)) continue; + if (e_illume_border_is_bottom_panel(bd)) continue; + if (e_illume_border_is_keyboard(bd)) continue; + if (e_illume_border_is_dialog(bd)) continue; + if (e_illume_border_is_quickpanel(bd)) continue; + ret = eina_list_append(ret, bd); + } + return ret; +} + +EAPI E_Border * +e_illume_border_valid_border_get(E_Zone *zone) +{ + Eina_List *bds, *l; + E_Border *bd, *ret = NULL; + + bds = e_border_client_list(); + EINA_LIST_FOREACH(bds, l, bd) + { + if (!bd) continue; + if (bd->zone != zone) continue; + if (e_illume_border_is_top_shelf(bd)) continue; + if (e_illume_border_is_bottom_panel(bd)) continue; + if (e_illume_border_is_keyboard(bd)) continue; + if (e_illume_border_is_dialog(bd)) continue; + if (e_illume_border_is_quickpanel(bd)) continue; + ret = bd; + break; + } + return ret; +} + +EAPI int +e_illume_border_valid_count_get(E_Zone *zone) +{ + Eina_List *l; + int count; + + l = e_illume_border_valid_borders_get(zone); + count = eina_list_count(l); + eina_list_free(l); + return count; +} + +EAPI Eina_List * +e_illume_border_quickpanel_borders_get(E_Zone *zone) +{ + Eina_List *bds, *l, *ret = NULL; + E_Border *bd; + + bds = e_border_client_list(); + EINA_LIST_FOREACH(bds, l, bd) + { + if (!bd) continue; + if (bd->zone != zone) continue; + if (!e_illume_border_is_quickpanel(bd)) continue; + ret = eina_list_append(ret, bd); + } + return ret; +} + +EAPI int +e_illume_border_quickpanel_count_get(E_Zone *zone) +{ + Eina_List *l; + int count; + + l = e_illume_border_quickpanel_borders_get(zone); + count = eina_list_count(l); + eina_list_free(l); + return count; +} + +EAPI E_Border * +e_illume_border_at_xy_get(E_Zone *zone, int x, int y) +{ + Eina_List *bds, *l; + E_Border *bd, *b = NULL; + + bds = e_illume_border_valid_borders_get(zone); + EINA_LIST_FOREACH(bds, l, bd) + { + if (((bd->fx.x == x) && (bd->fx.y == y)) || + ((bd->x == x) && (bd->y == y))) + { + b = bd; + break; + } + } + eina_list_free(bds); + return b; +} + +EAPI E_Border * +e_illume_border_in_region_get(E_Zone *zone, int x, int y, int w, int h) +{ + Eina_List *bds, *l; + E_Border *bd, *b = NULL; + + bds = e_illume_border_valid_borders_get(zone); + EINA_LIST_FOREACH(bds, l, bd) + { + if (E_INSIDE(bd->x, bd->fx.y, x, y, w, h)) + { + b = bd; + break; + } + } + eina_list_free(bds); + return b; +} + +EAPI E_Border * +e_illume_border_top_shelf_get(E_Zone *zone) +{ + Eina_List *bds, *l; + E_Border *bd, *b = NULL; + + bds = e_border_client_list(); + EINA_LIST_FOREACH(bds, l, bd) + { + if (bd->zone != zone) continue; + if (!e_illume_border_is_top_shelf(bd)) continue; + b = bd; + break; + } + return b; +} + +EAPI E_Border * +e_illume_border_bottom_panel_get(E_Zone *zone) +{ + Eina_List *bds, *l; + E_Border *bd, *b = NULL; + + bds = e_border_client_list(); + EINA_LIST_FOREACH(bds, l, bd) + { + if (bd->zone != zone) continue; + if (!e_illume_border_is_bottom_panel(bd)) continue; + b = bd; + break; + } + return b; +} + +EAPI void +e_illume_border_top_shelf_pos_get(E_Zone *zone, int *x, int *y) +{ + E_Border *bd; + + if (!(bd = e_illume_border_top_shelf_get(zone))) return; + if (x) *x = bd->x; + if (y) *y = bd->y; +} + +EAPI void +e_illume_border_top_shelf_size_get(E_Zone *zone, int *w, int *h) +{ + E_Border *bd; + + if (!(bd = e_illume_border_top_shelf_get(zone))) return; + if (w) *w = bd->w; + if (h) *h = bd->h; +} + +EAPI void +e_illume_border_bottom_panel_pos_get(E_Zone *zone, int *x, int *y) +{ + E_Border *bd; + + if (!(bd = e_illume_border_bottom_panel_get(zone))) return; + if (x) *x = bd->x; + if (y) *y = bd->y; +} + +EAPI void +e_illume_border_bottom_panel_size_get(E_Zone *zone, int *w, int *h) +{ + E_Border *bd; + + if (!(bd = e_illume_border_bottom_panel_get(zone))) return; + if (w) *w = bd->w; + if (h) *h = bd->h; +} + +EAPI void +e_illume_border_slide_to(E_Border *bd, int x, int y, E_Illume_Animation_Class aclass) +{ + // FIXME: do + // 1. if an existing slide exists, use is current offset x,y as current border pos, new x,y as new pos and start slide again +} + +EAPI void +e_illume_border_min_get(E_Border *bd, int *mw, int *mh) +{ + if (mw) + { + if (bd->client.icccm.base_w > bd->client.icccm.min_w) + *mw = bd->client.icccm.base_w; + else + *mw = bd->client.icccm.min_w; + } + if (mh) + { + if (bd->client.icccm.base_h > bd->client.icccm.min_h) + *mh = bd->client.icccm.base_h; + else + *mh = bd->client.icccm.min_h; + } +} + +EAPI void +e_illume_border_max_get(E_Border *bd, int *mw, int *mh) +{ + if (mw) + { + if (bd->client.icccm.base_w > bd->client.icccm.max_w) + *mw = bd->client.icccm.base_w; + else + *mw = bd->client.icccm.max_w; + } + if (mh) + { + if (bd->client.icccm.base_h > bd->client.icccm.max_h) + *mh = bd->client.icccm.base_h; + else + *mh = bd->client.icccm.max_h; + } +} + +EAPI void +e_illume_border_app1_safe_region_get(E_Zone *zone, int *x, int *y, int *w, int *h) +{ + int ty, nx, ny, nw, nh; + + if (!zone) return; + e_illume_kbd_safe_app_region_get(zone, &nx, &ny, &nw, &nh); + e_illume_border_top_shelf_pos_get(zone, NULL, &ty); + if (nh >= zone->h) nh = (ny + ty); + if (x) *x = nx; + if (y) *y = ny; + if (w) *w = nw; + if (h) *h = nh; +} + +EAPI void +e_illume_border_app2_safe_region_get(E_Zone *zone, int *x, int *y, int *w, int *h) +{ + int ty, th, bh; + int nx, ny, nw, nh; + + if (!zone) return; + e_illume_kbd_safe_app_region_get(zone, &nx, NULL, &nw, &nh); + e_illume_border_top_shelf_pos_get(zone, NULL, &ty); + e_illume_border_top_shelf_size_get(zone, NULL, &th); + e_illume_border_bottom_panel_size_get(zone, NULL, &bh); + ny = (ty + th); + nh = (nh - ny - bh); + if (x) *x = nx; + if (y) *y = ny; + if (w) *w = nw; + if (h) *h = nh; +} diff --git a/src/modules/illume2/e_mod_config.c b/src/modules/illume2/e_mod_config.c new file mode 100644 index 0000000..3b0faba --- /dev/null +++ b/src/modules/illume2/e_mod_config.c @@ -0,0 +1,212 @@ +#include "E_Illume.h" +//#include "e_mod_main.h" +#include "e_mod_config.h" +#include "e_mod_animation.h" +#include "e_mod_policy.h" +#include "e_mod_policy_settings.h" +#include "e_mod_windows.h" + +/* local variables */ +EAPI E_Illume_Config *il_cfg = NULL; +static E_Config_DD *conf_edd = NULL; + +/* public functions */ +int +e_mod_config_init(E_Module *m) +{ + conf_edd = E_CONFIG_DD_NEW("Illume_Cfg", E_Illume_Config); + #undef T + #undef D + #define T E_Illume_Config + #define D conf_edd + E_CONFIG_VAL(D, T, version, INT); + E_CONFIG_VAL(D, T, sliding.kbd.duration, INT); + E_CONFIG_VAL(D, T, sliding.softkey.duration, INT); + E_CONFIG_VAL(D, T, sliding.quickpanel.duration, INT); + E_CONFIG_VAL(D, T, policy.name, STR); + E_CONFIG_VAL(D, T, policy.mode.dual, INT); + E_CONFIG_VAL(D, T, policy.mode.side, INT); + E_CONFIG_VAL(D, T, policy.vkbd.class, STR); + E_CONFIG_VAL(D, T, policy.vkbd.name, STR); + E_CONFIG_VAL(D, T, policy.vkbd.title, STR); + E_CONFIG_VAL(D, T, policy.vkbd.win_type, INT); + E_CONFIG_VAL(D, T, policy.vkbd.match.class, INT); + E_CONFIG_VAL(D, T, policy.vkbd.match.name, INT); + E_CONFIG_VAL(D, T, policy.vkbd.match.title, INT); + E_CONFIG_VAL(D, T, policy.vkbd.match.win_type, INT); + E_CONFIG_VAL(D, T, policy.softkey.class, STR); + E_CONFIG_VAL(D, T, policy.softkey.name, STR); + E_CONFIG_VAL(D, T, policy.softkey.title, STR); + E_CONFIG_VAL(D, T, policy.softkey.win_type, INT); + E_CONFIG_VAL(D, T, policy.softkey.match.class, INT); + E_CONFIG_VAL(D, T, policy.softkey.match.name, INT); + E_CONFIG_VAL(D, T, policy.softkey.match.title, INT); + E_CONFIG_VAL(D, T, policy.softkey.match.win_type, INT); + E_CONFIG_VAL(D, T, policy.home.class, STR); + E_CONFIG_VAL(D, T, policy.home.name, STR); + E_CONFIG_VAL(D, T, policy.home.title, STR); + E_CONFIG_VAL(D, T, policy.home.win_type, INT); + E_CONFIG_VAL(D, T, policy.home.match.class, INT); + E_CONFIG_VAL(D, T, policy.home.match.name, INT); + E_CONFIG_VAL(D, T, policy.home.match.title, INT); + E_CONFIG_VAL(D, T, policy.home.match.win_type, INT); + E_CONFIG_VAL(D, T, policy.indicator.class, STR); + E_CONFIG_VAL(D, T, policy.indicator.name, STR); + E_CONFIG_VAL(D, T, policy.indicator.title, STR); + E_CONFIG_VAL(D, T, policy.indicator.win_type, INT); + E_CONFIG_VAL(D, T, policy.indicator.match.class, INT); + E_CONFIG_VAL(D, T, policy.indicator.match.name, INT); + E_CONFIG_VAL(D, T, policy.indicator.match.title, INT); + E_CONFIG_VAL(D, T, policy.indicator.match.win_type, INT); + + il_cfg = e_config_domain_load("module.illume2", conf_edd); + if ((il_cfg) && + ((il_cfg->version >> 16) < IL_CONFIG_MAJ)) + { + E_FREE(il_cfg); + il_cfg = NULL; + } + if (!il_cfg) + { + il_cfg = E_NEW(E_Illume_Config, 1); + il_cfg->version = 0; + il_cfg->sliding.kbd.duration = 1000; + il_cfg->sliding.softkey.duration = 1000; + } + if (il_cfg) + { + /* Add new config variables here */ + if ((il_cfg->version & 0xffff) < 1) + { + il_cfg->policy.name = eina_stringshare_add("Illume"); + il_cfg->policy.vkbd.class = + eina_stringshare_add("Virtual-Keyboard"); + il_cfg->policy.vkbd.name = + eina_stringshare_add("Virtual-Keyboard"); + il_cfg->policy.vkbd.title = + eina_stringshare_add("Virtual Keyboard"); + il_cfg->policy.vkbd.win_type = ECORE_X_WINDOW_TYPE_NORMAL; + il_cfg->policy.vkbd.match.class = 0; + il_cfg->policy.vkbd.match.name = 1; + il_cfg->policy.vkbd.match.title = 1; + il_cfg->policy.vkbd.match.win_type = 0; + il_cfg->policy.softkey.class = + eina_stringshare_add("Illume-Softkey"); + il_cfg->policy.softkey.name = + eina_stringshare_add("Illume-Softkey"); + il_cfg->policy.softkey.title = + eina_stringshare_add("Illume Softkey"); + il_cfg->policy.softkey.win_type = ECORE_X_WINDOW_TYPE_DOCK; + il_cfg->policy.softkey.match.class = 0; + il_cfg->policy.softkey.match.name = 1; + il_cfg->policy.softkey.match.title = 1; + il_cfg->policy.softkey.match.win_type = 0; + il_cfg->policy.home.class = + eina_stringshare_add("Illume-Home"); + il_cfg->policy.home.name = + eina_stringshare_add("Illume-Home"); + il_cfg->policy.home.title = + eina_stringshare_add("Illume Home"); + il_cfg->policy.home.win_type = ECORE_X_WINDOW_TYPE_NORMAL; + il_cfg->policy.home.match.class = 0; + il_cfg->policy.home.match.name = 1; + il_cfg->policy.home.match.title = 1; + il_cfg->policy.home.match.win_type = 0; + il_cfg->policy.indicator.class = + eina_stringshare_add("Illume-Indicator"); + il_cfg->policy.indicator.name = + eina_stringshare_add("Illume-Indicator"); + il_cfg->policy.indicator.title = + eina_stringshare_add("Illume Indicator"); + il_cfg->policy.indicator.win_type = ECORE_X_WINDOW_TYPE_DOCK; + il_cfg->policy.indicator.match.class = 0; + il_cfg->policy.indicator.match.name = 1; + il_cfg->policy.indicator.match.title = 1; + il_cfg->policy.indicator.match.win_type = 0; + } + if ((il_cfg->version & 0xffff) < 2) + { + il_cfg->policy.mode.dual = 0; + il_cfg->policy.mode.side = 0; + } + if ((il_cfg->version & 0xffff) < 3) + { + il_cfg->sliding.quickpanel.duration = 1000; + } + il_cfg->version = (IL_CONFIG_MAJ << 16) | IL_CONFIG_MIN; + } + il_cfg->mod_dir = eina_stringshare_add(m->dir); + + e_configure_registry_category_add("illume", 0, _("Illume"), NULL, + "enlightenment/display"); + e_configure_registry_generic_item_add("illume/animation", 0, _("Animation"), + NULL, "enlightenment/animation", + il_config_animation_show); + e_configure_registry_generic_item_add("illume/windows", 0, _("Windows"), + NULL, "enlightenment/windows", + il_config_windows_show); + e_configure_registry_generic_item_add("illume/policy", 0, _("Policy"), + NULL, "enlightenment/policy", + il_config_policy_show); + e_configure_registry_generic_item_add("illume/policy_settings", 0, + _("Policy Settings"), + NULL, "enlightenment/policy", + il_config_policy_settings_show); + return 1; +} + +int +e_mod_config_shutdown(void) +{ + e_configure_registry_item_del("illume/policy_settings"); + e_configure_registry_item_del("illume/policy"); + e_configure_registry_item_del("illume/windows"); + e_configure_registry_item_del("illume/animation"); + e_configure_registry_category_del("illume"); + + if (il_cfg->policy.name) eina_stringshare_del(il_cfg->policy.name); + + if (il_cfg->policy.vkbd.class) + eina_stringshare_del(il_cfg->policy.vkbd.class); + if (il_cfg->policy.vkbd.name) + eina_stringshare_del(il_cfg->policy.vkbd.name); + if (il_cfg->policy.vkbd.title) + eina_stringshare_del(il_cfg->policy.vkbd.title); + + if (il_cfg->policy.softkey.class) + eina_stringshare_del(il_cfg->policy.softkey.class); + if (il_cfg->policy.softkey.name) + eina_stringshare_del(il_cfg->policy.softkey.name); + if (il_cfg->policy.softkey.title) + eina_stringshare_del(il_cfg->policy.softkey.title); + + if (il_cfg->policy.home.class) + eina_stringshare_del(il_cfg->policy.home.class); + if (il_cfg->policy.home.name) + eina_stringshare_del(il_cfg->policy.home.name); + if (il_cfg->policy.home.title) + eina_stringshare_del(il_cfg->policy.home.title); + + if (il_cfg->policy.indicator.class) + eina_stringshare_del(il_cfg->policy.indicator.class); + if (il_cfg->policy.indicator.name) + eina_stringshare_del(il_cfg->policy.indicator.name); + if (il_cfg->policy.indicator.title) + eina_stringshare_del(il_cfg->policy.indicator.title); + + if (il_cfg->mod_dir) eina_stringshare_del(il_cfg->mod_dir); + il_cfg->mod_dir = NULL; + + E_FREE(il_cfg); + il_cfg = NULL; + + E_CONFIG_DD_FREE(conf_edd); + return 1; +} + +int +e_mod_config_save(void) +{ + e_config_domain_save("module.illume2", conf_edd, il_cfg); + return 1; +} diff --git a/src/modules/illume2/e_mod_config.h b/src/modules/illume2/e_mod_config.h new file mode 100644 index 0000000..fcf02ec --- /dev/null +++ b/src/modules/illume2/e_mod_config.h @@ -0,0 +1,11 @@ +#ifndef E_MOD_CONFIG_H +# define E_MOD_CONFIG_H + +# define IL_CONFIG_MIN 3 +# define IL_CONFIG_MAJ 0 + +int e_mod_config_init(E_Module *m); +int e_mod_config_shutdown(void); +int e_mod_config_save(void); + +#endif diff --git a/src/modules/illume2/e_mod_layout.c b/src/modules/illume2/e_mod_layout.c new file mode 100644 index 0000000..2941564 --- /dev/null +++ b/src/modules/illume2/e_mod_layout.c @@ -0,0 +1,488 @@ +#include "E_Illume.h" +#include "e_mod_main.h" +#include "e_mod_layout.h" + +/* local function prototypes */ +static void _e_mod_layout_free(E_Illume_Layout_Policy *p); +static int _e_mod_layout_policy_load(const char *file); +static void _e_mod_layout_handlers_add(void); +static void _e_mod_layout_handlers_del(void); +static void _e_mod_layout_hooks_add(void); +static void _e_mod_layout_hooks_del(void); +static void _e_mod_layout_cb_hook_container_layout(void *data, void *data2); +static void _e_mod_layout_cb_hook_post_fetch(void *data, void *data2); +static void _e_mod_layout_cb_hook_post_border_assign(void *data, void *data2); +static int _e_mod_layout_cb_border_add(void *data, int type, void *event); +static int _e_mod_layout_cb_border_del(void *data, int type, void *event); +static int _e_mod_layout_cb_border_focus_in(void *data, int type, void *event); +static int _e_mod_layout_cb_border_focus_out(void *data, int type, void *event); +static int _e_mod_layout_cb_zone_move_resize(void *data, int type, void *event); +static int _e_mod_layout_cb_client_message(void *data, int type, void *event); + +/* local variables */ +static Eina_List *hooks = NULL, *handlers = NULL; +static E_Illume_Layout_Policy *policy = NULL; + +int +e_mod_layout_init(void) +{ + Ecore_X_Window xwin; + Ecore_X_Illume_Mode mode; + Eina_List *files; + char buff[PATH_MAX], dir[PATH_MAX], *file; + int ret = 0; + + snprintf(buff, sizeof(buff), "%s.so", il_cfg->policy.name); + snprintf(dir, sizeof(dir), "%s/enlightenment/modules/illume2/policies", + e_prefix_lib_get()); + + files = ecore_file_ls(dir); + EINA_LIST_FREE(files, file) + { + if (strcmp(file, buff)) + { + free(file); + continue; + } + E_ILLUME_INF("Found Policy: %s", file); + snprintf(dir, sizeof(dir), + "%s/enlightenment/modules/illume2/policies/%s", + e_prefix_lib_get(), file); + break; + } + if (!file) + { + snprintf(dir, sizeof(dir), + "%s/enlightenment/modules/illume2/policies/illume.so", + e_prefix_lib_get()); + } + else + free(file); + + ret = _e_mod_layout_policy_load(dir); + if (!ret) return ret; + + _e_mod_layout_hooks_add(); + _e_mod_layout_handlers_add(); + + xwin = ecore_x_window_root_first_get(); + if (il_cfg->policy.mode.dual == 0) + mode = ECORE_X_ILLUME_MODE_SINGLE; + else + { + if (il_cfg->policy.mode.side == 0) + mode = ECORE_X_ILLUME_MODE_DUAL_TOP; + else + mode = ECORE_X_ILLUME_MODE_DUAL_LEFT; + } + ecore_x_e_illume_mode_set(xwin, mode); + + return ret; +} + +void +e_mod_layout_shutdown(void) +{ + _e_mod_layout_handlers_del(); + _e_mod_layout_hooks_del(); + if (policy) e_object_del(E_OBJECT(policy)); + policy = NULL; +} + +EAPI Eina_List * +e_illume_layout_policies_get(void) +{ + Eina_List *l = NULL, *files; + char dir[PATH_MAX], *file; + + snprintf(dir, sizeof(dir), "%s/enlightenment/modules/illume2/policies", + e_prefix_lib_get()); + + files = ecore_file_ls(dir); + EINA_LIST_FREE(files, file) + { + E_Illume_Layout_Policy *p; + + if (!strstr(file, ".so")) continue; + snprintf(dir, sizeof(dir), + "%s/enlightenment/modules/illume2/policies/%s", + e_prefix_lib_get(), file); + p = E_OBJECT_ALLOC(E_Illume_Layout_Policy, E_ILLUME_LAYOUT_TYPE, + _e_mod_layout_free); + p->handle = dlopen(dir, RTLD_NOW | RTLD_GLOBAL); + if (!p->handle) + { + E_ILLUME_ERR("Error opening policy: %s", file); + e_object_del(E_OBJECT(p)); + p = NULL; + continue; + } + p->api = dlsym(p->handle, "e_layapi"); + if (!p->api) + { + E_ILLUME_ERR("Policy does not support needed functions: %s", file); + e_object_del(E_OBJECT(p)); + p = NULL; + continue; + } + if (p->api->version < E_ILLUME_LAYOUT_API_VERSION) + { + E_ILLUME_ERR("Policy is too old: %s", file); + e_object_del(E_OBJECT(p)); + p = NULL; + continue; + } + l = eina_list_append(l, p); + } + + return l; +} + +/* local functions */ +static void +_e_mod_layout_free(E_Illume_Layout_Policy *p) +{ + if (p->funcs.shutdown) p->funcs.shutdown(p); + p->funcs.shutdown = NULL; + p->api = NULL; + p->funcs.init = NULL; + if (p->handle) dlclose(p->handle); + p->handle = NULL; + E_FREE(p); +} + +static int +_e_mod_layout_policy_load(const char *file) +{ + if (!file) return 0; + policy = E_OBJECT_ALLOC(E_Illume_Layout_Policy, E_ILLUME_LAYOUT_TYPE, + _e_mod_layout_free); + policy->handle = dlopen(file, RTLD_NOW | RTLD_GLOBAL); + if (!policy->handle) + { + E_ILLUME_ERR("Error opening policy: %s", file); + e_object_del(E_OBJECT(policy)); + policy = NULL; + return 0; + } + policy->api = dlsym(policy->handle, "e_layapi"); + policy->funcs.init = dlsym(policy->handle, "e_layapi_init"); + policy->funcs.shutdown = dlsym(policy->handle, "e_layapi_shutdown"); + if ((!policy->funcs.init) || (!policy->funcs.shutdown) || (!policy->api)) + { + E_ILLUME_ERR("Policy does not support needed functions: %s", file); + e_object_del(E_OBJECT(policy)); + policy = NULL; + return 0; + } + if (policy->api->version < E_ILLUME_LAYOUT_API_VERSION) + { + E_ILLUME_ERR("Policy is too old: %s", file); + e_object_del(E_OBJECT(policy)); + policy = NULL; + return 0; + } + policy->funcs.init(policy); + return 1; +} + +static void +_e_mod_layout_handlers_add(void) +{ + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_ADD, + _e_mod_layout_cb_border_add, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_REMOVE, + _e_mod_layout_cb_border_del, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_FOCUS_IN, + _e_mod_layout_cb_border_focus_in, + NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_BORDER_FOCUS_OUT, + _e_mod_layout_cb_border_focus_out, + NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(E_EVENT_ZONE_MOVE_RESIZE, + _e_mod_layout_cb_zone_move_resize, + NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, + _e_mod_layout_cb_client_message, + NULL)); +} + +static void +_e_mod_layout_handlers_del(void) +{ + Ecore_Event_Handler *handler; + + EINA_LIST_FREE(handlers, handler) + ecore_event_handler_del(handler); +} + +static void +_e_mod_layout_hooks_add(void) +{ + hooks = + eina_list_append(hooks, + e_border_hook_add(E_BORDER_HOOK_EVAL_POST_FETCH, + _e_mod_layout_cb_hook_post_fetch, NULL)); + hooks = + eina_list_append(hooks, + e_border_hook_add(E_BORDER_HOOK_EVAL_POST_BORDER_ASSIGN, + _e_mod_layout_cb_hook_post_border_assign, NULL)); + hooks = + eina_list_append(hooks, + e_border_hook_add(E_BORDER_HOOK_CONTAINER_LAYOUT, + _e_mod_layout_cb_hook_container_layout, NULL)); +} + +static void +_e_mod_layout_hooks_del(void) +{ + E_Border_Hook *hook; + + EINA_LIST_FREE(hooks, hook) + e_border_hook_del(hook); +} + +static void +_e_mod_layout_cb_hook_container_layout(void *data, void *data2) +{ + Eina_List *l; + E_Zone *zone; + E_Container *con; + + if (!(con = data2)) return; + EINA_LIST_FOREACH(con->zones, l, zone) + { + if ((policy) && (policy->funcs.zone_layout)) + policy->funcs.zone_layout(zone); + } +} + +static void +_e_mod_layout_cb_hook_post_fetch(void *data, void *data2) +{ + E_Border *bd; + + if (!(bd = data2)) return; + if (bd->stolen) return; + if (bd->new_client) + { + if (bd->remember) + { + if (bd->bordername) + { + eina_stringshare_del(bd->bordername); + bd->bordername = NULL; + bd->client.border.changed = 1; + } + e_remember_unuse(bd->remember); + bd->remember = NULL; + } + eina_stringshare_replace(&bd->bordername, "borderless"); + bd->client.border.changed = 1; + bd->client.e.state.centered = 0; + } +} + +static void +_e_mod_layout_cb_hook_post_border_assign(void *data, void *data2) +{ + E_Border *bd; + + if (!(bd = data2)) return; + if (bd->stolen) return; + bd->placed = 1; + bd->client.e.state.centered = 0; + if (bd->remember) + { + e_remember_unuse(bd->remember); + bd->remember = NULL; + } + bd->lock_border = 1; + bd->lock_client_location = 1; + bd->lock_client_size = 1; + bd->lock_client_desk = 1; + bd->lock_client_sticky = 1; + bd->lock_client_shade = 1; + bd->lock_client_maximize = 1; + bd->lock_user_location = 1; + bd->lock_user_size = 1; + bd->lock_user_sticky = 1; +} + +static int +_e_mod_layout_cb_border_add(void *data, int type, void *event) +{ + E_Event_Border_Add *ev; + + ev = event; + if (ev->border->stolen) return 1; + if ((policy) && (policy->funcs.border_add)) + policy->funcs.border_add(ev->border); + return 1; +} + +static int +_e_mod_layout_cb_border_del(void *data, int type, void *event) +{ + E_Event_Border_Remove *ev; + + ev = event; + if (ev->border->stolen) return 1; + if ((policy) && (policy->funcs.border_del)) + policy->funcs.border_del(ev->border); + return 1; +} + +static int +_e_mod_layout_cb_border_focus_in(void *data, int type, void *event) +{ + E_Event_Border_Focus_In *ev; + + ev = event; + if (ev->border->stolen) return 1; + if ((policy) && (policy->funcs.border_focus_in)) + policy->funcs.border_focus_in(ev->border); + return 1; +} + +static int +_e_mod_layout_cb_border_focus_out(void *data, int type, void *event) +{ + E_Event_Border_Focus_Out *ev; + + ev = event; + if (ev->border->stolen) return 1; + if ((policy) && (policy->funcs.border_focus_out)) + policy->funcs.border_focus_out(ev->border); + return 1; +} + +static int +_e_mod_layout_cb_zone_move_resize(void *data, int type, void *event) +{ + E_Event_Zone_Move_Resize *ev; + + ev = event; + if ((policy) && (policy->funcs.zone_move_resize)) + policy->funcs.zone_move_resize(ev->zone); + return 1; +} + +static int +_e_mod_layout_cb_client_message(void *data, int type, void *event) +{ + Ecore_X_Event_Client_Message *ev; + + ev = event; + if (ev->message_type == ECORE_X_ATOM_NET_ACTIVE_WINDOW) + { + E_Border *bd; + + bd = e_border_find_by_client_window(ev->win); + if ((!bd) || (bd->stolen)) return 1; + if ((policy) && (policy->funcs.border_activate)) + policy->funcs.border_activate(bd); + } + else if (ev->message_type == ECORE_X_ATOM_E_ILLUME_MODE) + { + E_Border *bd; + E_Zone *zone; + int lock = 1; + + zone = e_util_zone_current_get(e_manager_current_get()); + + if (ev->data.l[0] == ECORE_X_ATOM_E_ILLUME_MODE_SINGLE) + il_cfg->policy.mode.dual = 0; + else if (ev->data.l[0] == ECORE_X_ATOM_E_ILLUME_MODE_DUAL_TOP) + { + if (e_illume_border_valid_count_get(zone) < 2) + ecore_x_e_illume_home_send(ecore_x_window_root_first_get()); + il_cfg->policy.mode.dual = 1; + il_cfg->policy.mode.side = 0; + lock = 0; + } + else if (ev->data.l[0] == ECORE_X_ATOM_E_ILLUME_MODE_DUAL_LEFT) + { + if (e_illume_border_valid_count_get(zone) < 2) + ecore_x_e_illume_home_send(ecore_x_window_root_first_get()); + il_cfg->policy.mode.dual = 1; + il_cfg->policy.mode.side = 1; + } + else /* unknown */ + il_cfg->policy.mode.dual = 0; + e_config_save_queue(); + + bd = e_illume_border_top_shelf_get(zone); + if (bd) + ecore_x_e_illume_drag_locked_set(bd->client.win, lock); + bd = e_illume_border_bottom_panel_get(zone); + if (bd) + ecore_x_e_illume_drag_locked_set(bd->client.win, lock); + } + else if (ev->message_type == ECORE_X_ATOM_E_ILLUME_BACK) + { + E_Border *bd, *fbd; + Eina_List *focused, *l; + + if (!(bd = e_border_focused_get())) return 1; + focused = e_border_focus_stack_get(); + EINA_LIST_REVERSE_FOREACH(focused, l, fbd) + { + E_Border *fb; + + if (e_object_is_del(E_OBJECT(fbd))) continue; + if ((!fbd->client.icccm.accepts_focus) && + (!fbd->client.icccm.take_focus)) continue; + if (fbd->client.netwm.state.skip_taskbar) continue; + if (fbd == bd) + { + if (!(fb = focused->next->data)) continue; + if (e_object_is_del(E_OBJECT(fb))) continue; + if ((!fb->client.icccm.accepts_focus) && + (!fb->client.icccm.take_focus)) continue; + if (fb->client.netwm.state.skip_taskbar) continue; + e_border_raise(fb); + e_border_focus_set(fb, 1, 1); + break; + } + } + } + else if (ev->message_type == ECORE_X_ATOM_E_ILLUME_CLOSE) + { + E_Border *bd; + + if (!(bd = e_border_focused_get())) return 1; + e_border_act_close_begin(bd); + } + else if (ev->message_type == ECORE_X_ATOM_E_ILLUME_DRAG_START) + { + E_Border *bd; + + bd = e_border_find_by_client_window(ev->win); + if ((!bd) || (bd->stolen)) return 1; + if ((policy) && (policy->funcs.drag_start)) + policy->funcs.drag_start(bd); + } + else if (ev->message_type == ECORE_X_ATOM_E_ILLUME_DRAG_END) + { + E_Border *bd; + + bd = e_border_find_by_client_window(ev->win); + if ((!bd) || (bd->stolen)) return 1; + if ((policy) && (policy->funcs.drag_end)) + policy->funcs.drag_end(bd); + } + return 1; +} diff --git a/src/modules/illume2/e_mod_layout.h b/src/modules/illume2/e_mod_layout.h new file mode 100644 index 0000000..2c30323 --- /dev/null +++ b/src/modules/illume2/e_mod_layout.h @@ -0,0 +1,7 @@ +#ifndef E_MOD_LAYOUT_H +# define E_MOD_LAYOUT_H + +int e_mod_layout_init(void); +void e_mod_layout_shutdown(void); + +#endif diff --git a/src/modules/illume2/e_mod_main.c b/src/modules/illume2/e_mod_main.c new file mode 100644 index 0000000..a5be889 --- /dev/null +++ b/src/modules/illume2/e_mod_main.c @@ -0,0 +1,112 @@ +#include "E_Illume.h" +#include "e_mod_main.h" +#include "e_kbd.h" +#include "e_quickpanel.h" +#include "e_mod_layout.h" +#include "e_mod_config.h" + +/* local variables */ +static E_Kbd *kbd = NULL; +static E_Quickpanel *qp = NULL; +int _e_illume_log_dom = -1; + +EAPI E_Module_Api e_modapi = { E_MODULE_API_VERSION, "Illume2" }; + +EAPI void * +e_modapi_init(E_Module *m) +{ + /* set eina logging for error reporting/debugging */ + if (_e_illume_log_dom < 0) + { + _e_illume_log_dom = + eina_log_domain_register("illume2", E_ILLUME_DEFAULT_LOG_COLOR); + if (_e_illume_log_dom < 0) + { + EINA_LOG_CRIT("Could not register log domain for illume2"); + return NULL; + } + } + + /* set module priority very high so it loads before other illume modules */ + e_module_priority_set(m, 100); + + /* init the config subsystem */ + if (!e_mod_config_init(m)) return NULL; + + /* init the keyboard subsystem */ + e_kbd_init(); + + /* init the quickpanel subsystem */ + e_quickpanel_init(); + + /* init the layout subsystem */ + if (!e_mod_layout_init()) + { + /* shutdown the quickpanel subsystem */ + e_quickpanel_shutdown(); + + /* shutdown kbd subsystem */ + e_kbd_shutdown(); + + /* shutdown config subsystem */ + e_mod_config_shutdown(); + + /* cleanup eina log domain */ + if (_e_illume_log_dom >= 0) + { + eina_log_domain_unregister(_e_illume_log_dom); + _e_illume_log_dom = -1; + } + + /* report error to user */ + e_error_message_show("There was an error loading Policy\n"); + return NULL; + } + + /* create a new keyboard */ + kbd = e_kbd_new(); + + /* create a new quickpanel */ + qp = e_quickpanel_new(e_util_zone_current_get(e_manager_current_get())); + + return m; +} + +EAPI int +e_modapi_shutdown(E_Module *m) +{ + /* cleanup the quickpanel */ + e_object_del(E_OBJECT(qp)); + qp = NULL; + + /* cleanup the keyboard */ + e_object_del(E_OBJECT(kbd)); + kbd = NULL; + + /* shutdown the layout subsystem */ + e_mod_layout_shutdown(); + + /* shutdown the quickpanel subsystem */ + e_quickpanel_shutdown(); + + /* shutdown the keyboard subsystem */ + e_kbd_shutdown(); + + /* shutdown the config subsystem */ + e_mod_config_shutdown(); + + /* cleanup eina log domain */ + if (_e_illume_log_dom >= 0) + { + eina_log_domain_unregister(_e_illume_log_dom); + _e_illume_log_dom = -1; + } + + return 1; +} + +EAPI int +e_modapi_save(E_Module *m) +{ + return e_mod_config_save(); +} diff --git a/src/modules/illume2/e_mod_main.h b/src/modules/illume2/e_mod_main.h new file mode 100644 index 0000000..fae48ff --- /dev/null +++ b/src/modules/illume2/e_mod_main.h @@ -0,0 +1,36 @@ +#ifndef E_MOD_MAIN_H +# define E_MOD_MAIN_H + +# ifdef E_ILLUME_DEFAULT_LOG_COLOR +# undef E_ILLUME_DEFAULT_LOG_COLOR +# endif +# define E_ILLUME_DEFAULT_LOG_COLOR EINA_COLOR_BLUE + +extern int _e_illume_log_dom; +# ifdef E_ILLUME_ERR +# undef E_ILLUME_ERR +# endif +# define E_ILLUME_ERR(...) EINA_LOG_DOM_ERR(_e_illume_log_dom, __VA_ARGS__) + +# ifdef E_ILLUME_INF +# undef E_ILLUME_INF +# endif +# define E_ILLUME_INF(...) EINA_LOG_DOM_INFO(_e_illume_log_dom, __VA_ARGS__) + +# ifdef E_ILLUME_CRIT +# undef E_ILLUME_CRIT +# endif +# define E_ILLUME_CRIT(...) EINA_LOG_DOM_INFO(_e_illume_log_dom, __VA_ARGS__) + +# ifdef E_ILLUME_WARN +# undef E_ILLUME_WARN +# endif +# define E_ILLUME_WARN(...) EINA_LOG_DOM_WARN(_e_illume_log_dom, __VA_ARGS__) + +EAPI extern E_Module_Api e_modapi; + +EAPI void *e_modapi_init(E_Module *m); +EAPI int e_modapi_shutdown(E_Module *m); +EAPI int e_modapi_save(E_Module *m); + +#endif diff --git a/src/modules/illume2/e_mod_policy.c b/src/modules/illume2/e_mod_policy.c new file mode 100644 index 0000000..3a197df --- /dev/null +++ b/src/modules/illume2/e_mod_policy.c @@ -0,0 +1,113 @@ +#include "E_Illume.h" +#include "e_mod_layout.h" +#include "e_mod_policy.h" +#include "e_mod_config.h" + +/* local function prototypes */ +static void *_il_config_policy_create(E_Config_Dialog *cfd); +static void _il_config_policy_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata); +static Evas_Object *_il_config_policy_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata); +static void _il_config_policy_list_changed(void *data); +static int _il_config_policy_change_timeout(void *data); +static Evas_Object *_il_config_policy_settings_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata); + +/* local variables */ +Ecore_Timer *_policy_change_timer = NULL; +const char *policy_name = NULL; + +void +il_config_policy_show(E_Container *con, const char *params) +{ + E_Config_Dialog *cfd; + E_Config_Dialog_View *v; + + if (e_config_dialog_find("E", "_config_illume_policy")) return; + v = E_NEW(E_Config_Dialog_View, 1); + v->create_cfdata = _il_config_policy_create; + v->free_cfdata = _il_config_policy_free; + v->basic.create_widgets = _il_config_policy_ui; + v->basic_only = 1; + v->normal_win = 1; + v->scroll = 1; + cfd = e_config_dialog_new(con, _("Policy"), "E", + "_config_illume_policy", + "enlightenment/policy", 0, v, NULL); + e_dialog_resizable_set(cfd->dia, 1); +} + +/* local functions */ +static void * +_il_config_policy_create(E_Config_Dialog *cfd) +{ + return NULL; +} + +static void +_il_config_policy_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata) +{ + if (_policy_change_timer) ecore_timer_del(_policy_change_timer); +} + +static Evas_Object * +_il_config_policy_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata) +{ + Evas_Object *list, *ow; + Eina_List *policies; + E_Illume_Layout_Policy *p; + int i = 0, sel = 0; + + list = e_widget_list_add(evas, 0, 0); + ow = e_widget_ilist_add(evas, 24, 24, &(policy_name)); + e_widget_ilist_selector_set(ow, 1); + evas_event_freeze(evas); + edje_freeze(); + e_widget_ilist_freeze(ow); + e_widget_ilist_clear(ow); + e_widget_ilist_go(ow); + + policies = e_illume_layout_policies_get(); + EINA_LIST_FREE(policies, p) + { + e_widget_ilist_append(ow, NULL, strdup(p->api->label), + _il_config_policy_list_changed, NULL, + strdup(p->api->name)); + + if ((p) && (il_cfg->policy.name) && + (!strcmp(il_cfg->policy.name, p->api->name))) + sel = i; + + if (p) + { + e_object_del(E_OBJECT(p)); + p = NULL; + } + i++; + } + + e_widget_size_min_set(ow, 100, 200); + e_widget_ilist_go(ow); + e_widget_ilist_selected_set(ow, sel); + e_widget_ilist_thaw(ow); + edje_thaw(); + evas_event_thaw(evas); + e_widget_list_object_append(list, ow, 1, 0, 0.0); + return list; +} + +static void +_il_config_policy_list_changed(void *data) +{ + if (il_cfg->policy.name) eina_stringshare_del(il_cfg->policy.name); + if (policy_name) il_cfg->policy.name = eina_stringshare_add(policy_name); + if (_policy_change_timer) ecore_timer_del(_policy_change_timer); + _policy_change_timer = + ecore_timer_add(0.5, _il_config_policy_change_timeout, data); +} + +static int +_il_config_policy_change_timeout(void *data) +{ + e_config_save_queue(); + _policy_change_timer = NULL; + return 0; +} diff --git a/src/modules/illume2/e_mod_policy.h b/src/modules/illume2/e_mod_policy.h new file mode 100644 index 0000000..606f3da --- /dev/null +++ b/src/modules/illume2/e_mod_policy.h @@ -0,0 +1,6 @@ +#ifndef E_MOD_POLICY_H +#define E_MOD_POLICY_H + +void il_config_policy_show(E_Container *con, const char *params); + +#endif diff --git a/src/modules/illume2/e_mod_policy_settings.c b/src/modules/illume2/e_mod_policy_settings.c new file mode 100644 index 0000000..1f8b675 --- /dev/null +++ b/src/modules/illume2/e_mod_policy_settings.c @@ -0,0 +1,120 @@ +#include "E_Illume.h" +#include "e_mod_policy_settings.h" + +/* local function prototypes */ +static void *_il_config_policy_settings_create(E_Config_Dialog *cfd); +static void _il_config_policy_settings_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata); +static Evas_Object *_il_config_policy_settings_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata); +static void _il_config_policy_settings_changed(void *data, Evas_Object *obj, void *event); +static int _il_config_policy_settings_change_timeout(void *data); + +/* local variables */ +Ecore_Timer *_ps_change_timer = NULL; +Evas_Object *o_top, *o_left; + +void +il_config_policy_settings_show(E_Container *con, const char *params) +{ + E_Config_Dialog *cfd; + E_Config_Dialog_View *v; + + if (e_config_dialog_find("E", "_config_illume_policy_settings")) return; + v = E_NEW(E_Config_Dialog_View, 1); + v->create_cfdata = _il_config_policy_settings_create; + v->free_cfdata = _il_config_policy_settings_free; + v->basic.create_widgets = _il_config_policy_settings_ui; + v->basic_only = 1; + v->normal_win = 1; + v->scroll = 1; + cfd = e_config_dialog_new(con, _("Policy Settings"), "E", + "_config_illume_policy_settings", + "enlightenment/policy_settings", 0, v, NULL); + e_dialog_resizable_set(cfd->dia, 1); +} + +/* local function prototypes */ +static void * +_il_config_policy_settings_create(E_Config_Dialog *cfd) +{ + return NULL; +} + +static void +_il_config_policy_settings_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata) +{ + if (_ps_change_timer) ecore_timer_del(_ps_change_timer); +} + +static Evas_Object * +_il_config_policy_settings_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata) +{ + Evas_Object *list, *of, *ow; + E_Radio_Group *rg; + + list = e_widget_list_add(evas, 0, 0); + of = e_widget_framelist_add(evas, _("Mode"), 0); + rg = e_widget_radio_group_new(&(il_cfg->policy.mode.dual)); + ow = e_widget_radio_add(evas, _("Single App Mode"), 0, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_policy_settings_changed, NULL); + ow = e_widget_radio_add(evas, _("Dual App Mode"), 1, rg); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_policy_settings_changed, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + of = e_widget_framelist_add(evas, _("Window Layout"), 0); + rg = e_widget_radio_group_new(&(il_cfg->policy.mode.side)); + o_top = e_widget_radio_add(evas, _("Top/Bottom"), 0, rg); + e_widget_framelist_object_append(of, o_top); + evas_object_smart_callback_add(o_top, "changed", + _il_config_policy_settings_changed, NULL); + o_left = e_widget_radio_add(evas, _("Left/Right"), 1, rg); + e_widget_framelist_object_append(of, o_left); + evas_object_smart_callback_add(o_left, "changed", + _il_config_policy_settings_changed, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + e_widget_disabled_set(o_top, !il_cfg->policy.mode.dual); + e_widget_disabled_set(o_left, !il_cfg->policy.mode.dual); + + return list; +} + +static void +_il_config_policy_settings_changed(void *data, Evas_Object *obj, void *event) +{ + e_widget_disabled_set(o_top, !il_cfg->policy.mode.dual); + e_widget_disabled_set(o_left, !il_cfg->policy.mode.dual); + + if (_ps_change_timer) ecore_timer_del(_ps_change_timer); + _ps_change_timer = + ecore_timer_add(0.5, _il_config_policy_settings_change_timeout, data); +} + +static int +_il_config_policy_settings_change_timeout(void *data) +{ + Ecore_X_Window xwin; + Ecore_X_Illume_Mode mode; + + e_config_save_queue(); + _ps_change_timer = NULL; + + if (il_cfg->policy.mode.dual) + { + if (il_cfg->policy.mode.side == 0) + mode = ECORE_X_ILLUME_MODE_DUAL_TOP; + else + mode = ECORE_X_ILLUME_MODE_DUAL_LEFT; + } + else + mode = ECORE_X_ILLUME_MODE_SINGLE; + + xwin = ecore_x_window_root_first_get(); + ecore_x_e_illume_mode_set(xwin, mode); + ecore_x_e_illume_mode_send(xwin, mode); + + return 0; +} diff --git a/src/modules/illume2/e_mod_policy_settings.h b/src/modules/illume2/e_mod_policy_settings.h new file mode 100644 index 0000000..ab7c615 --- /dev/null +++ b/src/modules/illume2/e_mod_policy_settings.h @@ -0,0 +1,6 @@ +#ifndef E_MOD_POLICY_SETTINGS_H +# define E_MOD_POLICY_SETTINGS_H + +void il_config_policy_settings_show(E_Container *con, const char *params); + +#endif diff --git a/src/modules/illume2/e_mod_select_window.c b/src/modules/illume2/e_mod_select_window.c new file mode 100644 index 0000000..5e35741 --- /dev/null +++ b/src/modules/illume2/e_mod_select_window.c @@ -0,0 +1,269 @@ +#include "E_Illume.h" +#include "e_mod_select_window.h" + +/* local function prototypes */ +static void *_il_config_select_window_create_data(E_Config_Dialog *cfd); +static void _il_config_select_window_free_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata); +static Evas_Object *_il_config_select_window_create(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata); +static void _il_config_select_window_list_changed(void *data); +static int _il_config_select_window_change_timeout(void *data); +static int _il_config_select_window_match(E_Border *bd); + +/* local variables */ +Il_Select_Window_Type stype; +Ecore_Timer *_sw_change_timer = NULL; + +/* public functions */ +void +il_config_select_window(Il_Select_Window_Type type) +{ + E_Config_Dialog *cfd; + E_Config_Dialog_View *v; + + if (e_config_dialog_find("E", "_config_illume_select_window")) return; + stype = type; + v = E_NEW(E_Config_Dialog_View, 1); + v->create_cfdata = _il_config_select_window_create_data; + v->free_cfdata = _il_config_select_window_free_data; + v->basic.create_widgets = _il_config_select_window_create; + v->basic_only = 1; + v->normal_win = 1; + v->scroll = 1; + cfd = e_config_dialog_new(e_container_current_get(e_manager_current_get()), + _("Select Home Window"), "E", + "_config_illume_select_window", + "enlightenment/windows", 0, v, NULL); + e_dialog_resizable_set(cfd->dia, 1); +} + +static void * +_il_config_select_window_create_data(E_Config_Dialog *cfd) +{ + return NULL; +} + +static void +_il_config_select_window_free_data(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata) +{ + +} + +static Evas_Object * +_il_config_select_window_create(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata) +{ + Evas_Object *list, *ow; + Eina_List *bds, *l; + int i = 0, sel = -1; + + list = e_widget_list_add(evas, 0, 0); + ow = e_widget_ilist_add(evas, 24, 24, NULL); + e_widget_ilist_selector_set(ow, 1); + evas_event_freeze(evas); + edje_freeze(); + e_widget_ilist_freeze(ow); + e_widget_ilist_clear(ow); + e_widget_ilist_go(ow); + + bds = e_border_client_list(); + for (i = 0, l = bds; l; l = l->next, i++) + { + E_Border *bd; + const char *name; + + if (!(bd = l->data)) continue; + if (e_object_is_del(E_OBJECT(bd))) continue; + if (_il_config_select_window_match(bd)) sel = i; + name = e_border_name_get(bd); + e_widget_ilist_append(ow, NULL, name, + _il_config_select_window_list_changed, + bd, name); + } + e_widget_size_min_set(ow, 100, 200); + e_widget_ilist_go(ow); + if (sel >= 0) e_widget_ilist_selected_set(ow, sel); + e_widget_ilist_thaw(ow); + edje_thaw(); + evas_event_thaw(evas); + e_widget_list_object_append(list, ow, 1, 0, 0.0); + return list; +} + +static void +_il_config_select_window_list_changed(void *data) +{ + E_Border *bd; + Ecore_X_Window_Type wtype; + char *title, *name, *class; + + if (!(bd = data)) return; + title = ecore_x_icccm_title_get(bd->client.win); + ecore_x_icccm_name_class_get(bd->client.win, &name, &class); + ecore_x_netwm_window_type_get(bd->client.win, &wtype); + + switch (stype) + { + case IL_SELECT_WINDOW_TYPE_HOME: + if (il_cfg->policy.home.title) + eina_stringshare_del(il_cfg->policy.home.title); + if (title) il_cfg->policy.home.title = eina_stringshare_add(title); + if (il_cfg->policy.home.class) + eina_stringshare_del(il_cfg->policy.home.class); + if (class) il_cfg->policy.home.class = eina_stringshare_add(class); + if (il_cfg->policy.home.name) + eina_stringshare_del(il_cfg->policy.home.name); + if (name) il_cfg->policy.home.name = eina_stringshare_add(name); + break; + case IL_SELECT_WINDOW_TYPE_VKBD: + if (il_cfg->policy.vkbd.title) + eina_stringshare_del(il_cfg->policy.vkbd.title); + if (title) il_cfg->policy.vkbd.title = eina_stringshare_add(title); + if (il_cfg->policy.vkbd.class) + eina_stringshare_del(il_cfg->policy.vkbd.class); + if (class) il_cfg->policy.vkbd.class = eina_stringshare_add(class); + if (il_cfg->policy.vkbd.name) + eina_stringshare_del(il_cfg->policy.vkbd.name); + if (name) il_cfg->policy.vkbd.name = eina_stringshare_add(name); + break; + case IL_SELECT_WINDOW_TYPE_SOFTKEY: + if (il_cfg->policy.softkey.title) + eina_stringshare_del(il_cfg->policy.softkey.title); + if (title) il_cfg->policy.softkey.title = eina_stringshare_add(title); + if (il_cfg->policy.softkey.class) + eina_stringshare_del(il_cfg->policy.softkey.class); + if (class) il_cfg->policy.softkey.class = eina_stringshare_add(class); + if (il_cfg->policy.softkey.name) + eina_stringshare_del(il_cfg->policy.softkey.name); + if (name) il_cfg->policy.softkey.name = eina_stringshare_add(name); + break; + case IL_SELECT_WINDOW_TYPE_INDICATOR: + if (il_cfg->policy.indicator.title) + eina_stringshare_del(il_cfg->policy.indicator.title); + if (title) il_cfg->policy.indicator.title = eina_stringshare_add(title); + if (il_cfg->policy.indicator.class) + eina_stringshare_del(il_cfg->policy.indicator.class); + if (class) il_cfg->policy.indicator.class = eina_stringshare_add(class); + if (il_cfg->policy.indicator.name) + eina_stringshare_del(il_cfg->policy.indicator.name); + if (name) il_cfg->policy.indicator.name = eina_stringshare_add(name); + break; + } + + if (title) free(title); + if (name) free(name); + if (class) free(class); + + if (_sw_change_timer) ecore_timer_del(_sw_change_timer); + _sw_change_timer = + ecore_timer_add(0.5, _il_config_select_window_change_timeout, data); +} + +static int +_il_config_select_window_change_timeout(void *data) +{ + e_config_save_queue(); + _sw_change_timer = NULL; + return 0; +} + +static int +_il_config_select_window_match(E_Border *bd) +{ + Ecore_X_Window_Type wtype; + char *title, *name, *class; + int match = 0; + + if (!bd) return 0; + title = ecore_x_icccm_title_get(bd->client.win); + ecore_x_icccm_name_class_get(bd->client.win, &name, &class); + ecore_x_netwm_window_type_get(bd->client.win, &wtype); + + switch (stype) + { + case IL_SELECT_WINDOW_TYPE_HOME: + if (il_cfg->policy.home.match.title) + { + if ((title) && (!strcmp(title, il_cfg->policy.home.title))) + match = 1; + break; + } + if (il_cfg->policy.home.match.name) + { + if ((name) && (!strcmp(name, il_cfg->policy.home.name))) + match = 1; + break; + } + if (il_cfg->policy.home.match.class) + { + if ((class) && (!strcmp(class, il_cfg->policy.home.class))) + match = 1; + break; + } + break; + case IL_SELECT_WINDOW_TYPE_VKBD: + if (il_cfg->policy.vkbd.match.title) + { + if ((title) && (!strcmp(title, il_cfg->policy.vkbd.title))) + match = 1; + break; + } + if (il_cfg->policy.vkbd.match.name) + { + if ((name) && (!strcmp(name, il_cfg->policy.vkbd.name))) + match = 1; + break; + } + if (il_cfg->policy.vkbd.match.class) + { + if ((class) && (!strcmp(class, il_cfg->policy.vkbd.class))) + match = 1; + break; + } + break; + case IL_SELECT_WINDOW_TYPE_SOFTKEY: + if (il_cfg->policy.softkey.match.title) + { + if ((title) && (!strcmp(title, il_cfg->policy.softkey.title))) + match = 1; + break; + } + if (il_cfg->policy.softkey.match.name) + { + if ((name) && (!strcmp(name, il_cfg->policy.softkey.name))) + match = 1; + break; + } + if (il_cfg->policy.softkey.match.class) + { + if ((class) && (!strcmp(class, il_cfg->policy.softkey.class))) + match = 1; + break; + } + break; + case IL_SELECT_WINDOW_TYPE_INDICATOR: + if (il_cfg->policy.indicator.match.title) + { + if ((title) && (!strcmp(title, il_cfg->policy.indicator.title))) + match = 1; + break; + } + if (il_cfg->policy.indicator.match.name) + { + if ((name) && (!strcmp(name, il_cfg->policy.indicator.name))) + match = 1; + break; + } + if (il_cfg->policy.indicator.match.class) + { + if ((class) && (!strcmp(class, il_cfg->policy.indicator.class))) + match = 1; + break; + } + break; + } + + if (title) free(title); + if (name) free(name); + if (class) free(class); + + return match; +} diff --git a/src/modules/illume2/e_mod_select_window.h b/src/modules/illume2/e_mod_select_window.h new file mode 100644 index 0000000..25cfc96 --- /dev/null +++ b/src/modules/illume2/e_mod_select_window.h @@ -0,0 +1,15 @@ +#ifndef E_MOD_SELECT_WINDOW_H +#define E_MOD_SELECT_WINDOW_H + +typedef enum _Il_Select_Window_Type Il_Select_Window_Type; +enum _Il_Select_Window_Type +{ + IL_SELECT_WINDOW_TYPE_HOME, + IL_SELECT_WINDOW_TYPE_VKBD, + IL_SELECT_WINDOW_TYPE_SOFTKEY, + IL_SELECT_WINDOW_TYPE_INDICATOR +}; + +void il_config_select_window(Il_Select_Window_Type type); + +#endif diff --git a/src/modules/illume2/e_mod_windows.c b/src/modules/illume2/e_mod_windows.c new file mode 100644 index 0000000..7b22da3 --- /dev/null +++ b/src/modules/illume2/e_mod_windows.c @@ -0,0 +1,217 @@ +#include "E_Illume.h" +#include "e_mod_windows.h" +#include "e_mod_select_window.h" + +/* local function prototypes */ +static void *_il_config_windows_create(E_Config_Dialog *cfd); +static void _il_config_windows_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata); +static Evas_Object *_il_config_windows_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata); +static void _il_config_windows_check_changed(void *data, Evas_Object *obj, void *event); +static void _il_config_windows_change(void *data, Evas_Object *obj, void *event); +static int _il_config_windows_change_timeout(void *data); +static void _il_config_windows_select_home(void *data, void *data2); +static void _il_config_windows_select_vkbd(void *data, void *data2); +static void _il_config_windows_select_softkey(void *data, void *data2); +static void _il_config_windows_select_indicator(void *data, void *data2); + +/* local variables */ +Ecore_Timer *_windows_change_timer = NULL; + +/* public functions */ +void +il_config_windows_show(E_Container *con, const char *params) +{ + E_Config_Dialog *cfd; + E_Config_Dialog_View *v; + + if (e_config_dialog_find("E", "_config_illume_windows_settings")) return; + + v = E_NEW(E_Config_Dialog_View, 1); + v->create_cfdata = _il_config_windows_create; + v->free_cfdata = _il_config_windows_free; + v->basic.create_widgets = _il_config_windows_ui; + v->basic_only = 1; + v->normal_win = 1; + v->scroll = 1; + cfd = e_config_dialog_new(con, _("Window Settings"), "E", + "_config_illume_windows_settings", + "preferences-system-windows", 0, v, NULL); + e_dialog_resizable_set(cfd->dia, 1); +} + +/* local function prototypes */ +static void * +_il_config_windows_create(E_Config_Dialog *cfd) +{ + return NULL; +} + +static void +_il_config_windows_free(E_Config_Dialog *cfd, E_Config_Dialog_Data *cfdata) +{ + if (_windows_change_timer) ecore_timer_del(_windows_change_timer); +} + +static Evas_Object * +_il_config_windows_ui(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata) +{ + Evas_Object *list, *of, *ow; + + list = e_widget_list_add(evas, 0, 0); + + of = e_widget_framelist_add(evas, _("Home"), 0); + ow = e_widget_button_add(evas, _("Select Window"), NULL, + _il_config_windows_select_home, NULL, NULL); + e_widget_framelist_object_append(of, ow); + ow = e_widget_check_add(evas, _("Match Window Class"), + &il_cfg->policy.home.match.class); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Name"), + &il_cfg->policy.home.match.name); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Title"), + &il_cfg->policy.home.match.title); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Type"), + &il_cfg->policy.home.match.win_type); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + of = e_widget_framelist_add(evas, _("Indicator"), 0); + ow = e_widget_button_add(evas, _("Select Window"), NULL, + _il_config_windows_select_indicator, NULL, NULL); + e_widget_framelist_object_append(of, ow); + ow = e_widget_check_add(evas, _("Match Window Class"), + &il_cfg->policy.indicator.match.class); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Name"), + &il_cfg->policy.indicator.match.name); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Title"), + &il_cfg->policy.indicator.match.title); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Type"), + &il_cfg->policy.indicator.match.win_type); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + of = e_widget_framelist_add(evas, _("Keyboard"), 0); + ow = e_widget_button_add(evas, _("Select Window"), NULL, + _il_config_windows_select_vkbd, NULL, NULL); + e_widget_framelist_object_append(of, ow); + ow = e_widget_check_add(evas, _("Match Window Class"), + &il_cfg->policy.vkbd.match.class); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Name"), + &il_cfg->policy.vkbd.match.name); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Title"), + &il_cfg->policy.vkbd.match.title); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Type"), + &il_cfg->policy.vkbd.match.win_type); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + of = e_widget_framelist_add(evas, _("Softkey"), 0); + ow = e_widget_button_add(evas, _("Select Window"), NULL, + _il_config_windows_select_softkey, NULL, NULL); + e_widget_framelist_object_append(of, ow); + ow = e_widget_check_add(evas, _("Match Window Class"), + &il_cfg->policy.softkey.match.class); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Name"), + &il_cfg->policy.softkey.match.name); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Title"), + &il_cfg->policy.softkey.match.title); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + ow = e_widget_check_add(evas, _("Match Window Type"), + &il_cfg->policy.softkey.match.win_type); + e_widget_framelist_object_append(of, ow); + evas_object_smart_callback_add(ow, "changed", + _il_config_windows_check_changed, NULL); + e_widget_list_object_append(list, of, 1, 0, 0.0); + + return list; +} + +static void +_il_config_windows_check_changed(void *data, Evas_Object *obj, void *event) +{ + _il_config_windows_change(data, obj, event); +} + +static void +_il_config_windows_change(void *data, Evas_Object *obj, void *event) +{ + if (_windows_change_timer) ecore_timer_del(_windows_change_timer); + _windows_change_timer = + ecore_timer_add(0.5, _il_config_windows_change_timeout, data); +} + +static int +_il_config_windows_change_timeout(void *data) +{ + e_config_save_queue(); + _windows_change_timer = NULL; + return 0; +} + +static void +_il_config_windows_select_home(void *data, void *data2) +{ + if (e_config_dialog_find("E", "_config_illume_select_window")) return; + il_config_select_window(IL_SELECT_WINDOW_TYPE_HOME); +} + +static void +_il_config_windows_select_vkbd(void *data, void *data2) +{ + if (e_config_dialog_find("E", "_config_illume_select_window")) return; + il_config_select_window(IL_SELECT_WINDOW_TYPE_VKBD); +} + +static void +_il_config_windows_select_softkey(void *data, void *data2) +{ + if (e_config_dialog_find("E", "_config_illume_select_window")) return; + il_config_select_window(IL_SELECT_WINDOW_TYPE_SOFTKEY); +} + +static void +_il_config_windows_select_indicator(void *data, void *data2) +{ + if (e_config_dialog_find("E", "_config_illume_select_window")) return; + il_config_select_window(IL_SELECT_WINDOW_TYPE_INDICATOR); +} diff --git a/src/modules/illume2/e_mod_windows.h b/src/modules/illume2/e_mod_windows.h new file mode 100644 index 0000000..2f4da35 --- /dev/null +++ b/src/modules/illume2/e_mod_windows.h @@ -0,0 +1,6 @@ +#ifndef E_MOD_WINDOWS_H +#define E_MOD_WINDOWS_H + +void il_config_windows_show(E_Container *con, const char *params); + +#endif diff --git a/src/modules/illume2/e_quickpanel.c b/src/modules/illume2/e_quickpanel.c new file mode 100644 index 0000000..6f53491 --- /dev/null +++ b/src/modules/illume2/e_quickpanel.c @@ -0,0 +1,415 @@ +#include "E_Illume.h" +#include "e_quickpanel.h" + +/* local function prototypes */ +static void _e_quickpanel_cb_free(E_Quickpanel *qp); +static int _e_quickpanel_cb_client_message(void *data, int type, void *event); +static void _e_quickpanel_cb_border_pre_post_fetch(void *data, void *data2); +static E_Quickpanel *_e_quickpanel_by_border_get(E_Border *bd); +static int _e_quickpanel_border_is_quickpanel(E_Border *bd); +static void _e_quickpanel_slide(E_Quickpanel *qp, int visible, double len); +static int _e_quickpanel_cb_animate(void *data); +static int _e_quickpanel_cb_delay_hide(void *data); +static void _e_quickpanel_hide(E_Quickpanel *qp); +static int _e_quickpanel_cb_sort(const void *b1, const void *b2); +static int _e_quickpanel_cb_mouse_down(void *data, int type, void *event); +static int _e_quickpanel_cb_mouse_wheel(void *data, int type, void *event); + +/* local variables */ +static Eina_List *qps = NULL, *handlers = NULL, *hooks = NULL; +static Ecore_X_Window input_win = 0; + +/* public functions */ +int +e_quickpanel_init(void) +{ + handlers = + eina_list_append(handlers, + ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, + _e_quickpanel_cb_client_message, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, + _e_quickpanel_cb_mouse_down, NULL)); + handlers = + eina_list_append(handlers, + ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL, + _e_quickpanel_cb_mouse_wheel, NULL)); + + hooks = + eina_list_append(hooks, + e_border_hook_add(E_BORDER_HOOK_EVAL_PRE_POST_FETCH, + _e_quickpanel_cb_border_pre_post_fetch, + NULL)); + return 1; +} + +int +e_quickpanel_shutdown(void) +{ + E_Quickpanel *qp; + Ecore_Event_Handler *handler; + E_Border_Hook *hook; + + EINA_LIST_FREE(handlers, handler) + ecore_event_handler_del(handler); + EINA_LIST_FREE(hooks, hook) + e_border_hook_del(hook); + EINA_LIST_FREE(qps, qp) + e_object_del(E_OBJECT(qp)); + return 1; +} + +E_Quickpanel * +e_quickpanel_new(E_Zone *zone) +{ + E_Quickpanel *qp; + + qp = E_OBJECT_ALLOC(E_Quickpanel, E_QUICKPANEL_TYPE, _e_quickpanel_cb_free); + if (!qp) return NULL; + qp->zone = zone; + qps = eina_list_append(qps, qp); + return qp; +} + +void +e_quickpanel_show(E_Quickpanel *qp) +{ + if (qp->timer) ecore_timer_del(qp->timer); + qp->timer = NULL; + if (qp->visible) return; + if (!qp->borders) return; + if (!input_win) + { + input_win = + ecore_x_window_input_new(qp->zone->container->win, + qp->zone->x, qp->zone->y, + qp->zone->w, qp->zone->h); + ecore_x_window_show(input_win); + if (!e_grabinput_get(input_win, 1, input_win)) + { + ecore_x_window_free(input_win); + input_win = 0; + return; + } + } + if (il_cfg->sliding.quickpanel.duration <= 0) + { + Eina_List *l; + E_Border *bd; + int ny = 0; + + e_illume_border_top_shelf_size_get(qp->zone, NULL, &ny); + EINA_LIST_FOREACH(qp->borders, l, bd) + ny += bd->h; + + EINA_LIST_FOREACH(qp->borders, l, bd) + { + e_border_lower(bd); + e_border_fx_offset(bd, 0, ny); + } + qp->visible = 1; + } + else + _e_quickpanel_slide(qp, 1, + (double)il_cfg->sliding.quickpanel.duration / 1000.0); +} + +void +e_quickpanel_hide(E_Quickpanel *qp) +{ + if (!qp->visible) return; + if (!qp->timer) + qp->timer = ecore_timer_add(0.2, _e_quickpanel_cb_delay_hide, qp); +} + +E_Quickpanel * +e_quickpanel_by_zone_get(E_Zone *zone) +{ + Eina_List *l; + E_Quickpanel *qp; + + if (!zone) return NULL; + EINA_LIST_FOREACH(qps, l, qp) + if (qp->zone == zone) return qp; + return NULL; +} + +void +e_quickpanel_position_update(E_Quickpanel *qp) +{ + Eina_List *l; + E_Border *bd; + int ty; + + if (!qp) return; + e_illume_border_top_shelf_pos_get(qp->zone, NULL, &ty); + EINA_LIST_FOREACH(qp->borders, l, bd) + { + bd->x = qp->zone->x; + bd->y = (ty - qp->h); + bd->changed = 1; + bd->changes.pos = 1; + } +} + +/* local functions */ +static void +_e_quickpanel_cb_free(E_Quickpanel *qp) +{ + E_Border *bd; + + if (qp->animator) ecore_animator_del(qp->animator); + qp->animator = NULL; + if (qp->timer) ecore_timer_del(qp->timer); + qp->timer = NULL; + EINA_LIST_FREE(qp->borders, bd) + bd->stolen = 0; + E_FREE(qp); +} + +static int +_e_quickpanel_cb_client_message(void *data, int type, void *event) +{ + Ecore_X_Event_Client_Message *ev; + E_Zone *zone; + E_Quickpanel *qp; + + ev = event; + if (ev->win != ecore_x_window_root_first_get()) return 1; + if (ev->message_type != ECORE_X_ATOM_E_ILLUME_QUICKPANEL_STATE) return 1; + zone = e_zone_current_get(e_container_current_get(e_manager_current_get())); + if (!(qp = e_quickpanel_by_zone_get(zone))) return 1; + if (ev->data.l[0] == ECORE_X_ATOM_E_ILLUME_QUICKPANEL_OFF) + e_quickpanel_hide(qp); + else if (ev->data.l[0] == ECORE_X_ATOM_E_ILLUME_QUICKPANEL_ON) + e_quickpanel_show(qp); + return 1; +} + +static void +_e_quickpanel_cb_border_pre_post_fetch(void *data, void *data2) +{ + E_Border *bd; + E_Quickpanel *qp; + int ty; + + if (!(bd = data2)) return; + if (!bd->new_client) return; + if (!_e_quickpanel_border_is_quickpanel(bd)) return; + if (_e_quickpanel_by_border_get(bd)) return; + if (!(qp = e_quickpanel_by_zone_get(bd->zone))) return; + e_illume_border_top_shelf_pos_get(qp->zone, NULL, &ty); + bd->stolen = 1; + if (bd->remember) + { + if (bd->bordername) + { + eina_stringshare_del(bd->bordername); + bd->bordername = NULL; + bd->client.border.changed = 1; + } + e_remember_unuse(bd->remember); + bd->remember = NULL; + } + eina_stringshare_replace(&bd->bordername, "borderless"); + bd->client.border.changed = 1; + qp->h += bd->h; + e_border_move(bd, qp->zone->x, (ty - qp->h)); + if (qp->visible) + { + int th; + + e_illume_border_top_shelf_size_get(qp->zone, NULL, &th); + e_border_fx_offset(bd, 0, (bd->h - th)); + } + qp->borders = eina_list_sorted_insert(qp->borders, _e_quickpanel_cb_sort, bd); +} + +static E_Quickpanel * +_e_quickpanel_by_border_get(E_Border *bd) +{ + Eina_List *l, *ll; + E_Border *b; + E_Quickpanel *qp; + + if (!bd->stolen) return NULL; + EINA_LIST_FOREACH(qps, l, qp) + EINA_LIST_FOREACH(qp->borders, ll, b) + if (b == bd) return qp; + return NULL; +} + +static int +_e_quickpanel_border_is_quickpanel(E_Border *bd) +{ + return ecore_x_e_illume_quickpanel_get(bd->client.win); +} + +static void +_e_quickpanel_slide(E_Quickpanel *qp, int visible, double len) +{ + qp->start = ecore_loop_time_get(); + qp->len = len; + qp->adjust_start = qp->adjust; + qp->adjust_end = 0; + if (visible) + { + Eina_List *l; + E_Border *bd; + + EINA_LIST_FOREACH(qp->borders, l, bd) + qp->adjust_end += bd->h; + } + else + { + int th; + + e_illume_border_top_shelf_size_get(qp->zone, NULL, &th); + qp->adjust_end = -th; + } + if (!qp->animator) + qp->animator = ecore_animator_add(_e_quickpanel_cb_animate, qp); +} + +static int +_e_quickpanel_cb_animate(void *data) +{ + E_Quickpanel *qp; + Eina_List *l; + E_Border *bd; + double t, v; + + if (!(qp = data)) return 0; + t = ecore_loop_time_get() - qp->start; + if (t > qp->len) t = qp->len; + if (qp->len > 0.0) + { + v = t / qp->len; + v = 1.0 - v; + v = v * v * v * v; + v = 1.0 - v; + } + else + { + t = qp->len; + v = 1.0; + } + qp->adjust = (qp->adjust_end * v) + (qp->adjust_start * (1.0 - v)); + + EINA_LIST_FOREACH(qp->borders, l, bd) + { + e_border_lower(bd); + e_border_fx_offset(bd, 0, (bd->h + qp->adjust)); + } + + if (t == qp->len) + { + qp->animator = NULL; + if (qp->visible) + qp->visible = 0; + else + qp->visible = 1; + return 0; + } + return 1; +} + +static int +_e_quickpanel_cb_delay_hide(void *data) +{ + E_Quickpanel *qp; + + if (!(qp = data)) return 0; + _e_quickpanel_hide(qp); + qp->timer = NULL; + return 0; +} + +static void +_e_quickpanel_hide(E_Quickpanel *qp) +{ + if (qp->timer) ecore_timer_del(qp->timer); + qp->timer = NULL; + if (!qp->visible) return; + if (input_win) + { + ecore_x_window_free(input_win); + e_grabinput_release(input_win, input_win); + input_win = 0; + } + if (il_cfg->sliding.quickpanel.duration <= 0) + { + Eina_List *l; + E_Border *bd; + + EINA_LIST_FOREACH(qp->borders, l, bd) + { + e_border_lower(bd); + e_border_fx_offset(bd, 0, 0); + } + qp->visible = 0; + } + else + _e_quickpanel_slide(qp, 0, + (double)il_cfg->sliding.quickpanel.duration / 1000.0); +} + +static int +_e_quickpanel_cb_sort(const void *b1, const void *b2) +{ + const E_Border *bd1, *bd2; + int major1, major2; + + if (!(bd1 = b1)) return 0; + if (!(bd2 = b2)) return 1; + printf("Checking: %s against %s\n", bd2->client.icccm.name, bd1->client.icccm.name); + major1 = ecore_x_e_illume_quickpanel_priority_major_get(bd1->client.win); + major2 = ecore_x_e_illume_quickpanel_priority_major_get(bd2->client.win); + if (major2 > major1) return 1; + else if (major2 < major1) return -1; + /* + else if (major2 == major1) + { + int minor1, minor2; + + minor1 = + ecore_x_e_illume_quickpanel_priority_minor_get(bd1->client.win); + minor2 = + ecore_x_e_illume_quickpanel_priority_minor_get(bd2->client.win); + printf("Minors: %d %d\n", minor2, minor1); + if (minor2 > minor1) return 1; + else if (minor2 < minor1) return -1; + } + */ + return 0; +} + +static int +_e_quickpanel_cb_mouse_down(void *data, int type, void *event) +{ + Ecore_Event_Mouse_Button *ev; + Ecore_X_Window xwin; + + ev = event; + if (ev->event_window != input_win) return 1; + xwin = ecore_x_window_root_first_get(); + ecore_x_e_illume_quickpanel_state_set(xwin, ECORE_X_ILLUME_QUICKPANEL_STATE_OFF); + ecore_x_e_illume_quickpanel_state_send(xwin, ECORE_X_ILLUME_QUICKPANEL_STATE_OFF); + return 1; +} + +static int +_e_quickpanel_cb_mouse_wheel(void *data, int type, void *event) +{ + Ecore_Event_Mouse_Wheel *ev; + Ecore_X_Window xwin; + + ev = event; + if (ev->event_window != input_win) return 1; + if (ev->z > 0) return 1; + xwin = ecore_x_window_root_first_get(); + ecore_x_e_illume_quickpanel_state_set(xwin, ECORE_X_ILLUME_QUICKPANEL_STATE_OFF); + ecore_x_e_illume_quickpanel_state_send(xwin, ECORE_X_ILLUME_QUICKPANEL_STATE_OFF); + return 1; +} diff --git a/src/modules/illume2/e_quickpanel.h b/src/modules/illume2/e_quickpanel.h new file mode 100644 index 0000000..a6d9f85 --- /dev/null +++ b/src/modules/illume2/e_quickpanel.h @@ -0,0 +1,29 @@ +#ifndef E_QUICKPANEL_H +#define E_QUICKPANEL_H + +#define E_QUICKPANEL_TYPE 0xE1b0990 + +typedef struct _E_Quickpanel E_Quickpanel; +struct _E_Quickpanel +{ + E_Object e_obj_inherit; + + E_Zone *zone; + Eina_List *borders; + Ecore_Timer *timer; + Ecore_Animator *animator; + double start, len; + int h, adjust, adjust_start, adjust_end; + unsigned char visible : 1; +}; + +int e_quickpanel_init(void); +int e_quickpanel_shutdown(void); + +E_Quickpanel *e_quickpanel_new(E_Zone *zone); +void e_quickpanel_show(E_Quickpanel *qp); +void e_quickpanel_hide(E_Quickpanel *qp); +E_Quickpanel *e_quickpanel_by_zone_get(E_Zone *zone); +void e_quickpanel_position_update(E_Quickpanel *qp); + +#endif diff --git a/src/modules/illume2/keyboards/Makefile.am b/src/modules/illume2/keyboards/Makefile.am new file mode 100644 index 0000000..1b21920 --- /dev/null +++ b/src/modules/illume2/keyboards/Makefile.am @@ -0,0 +1,11 @@ +MAINTAINERCLEANFILES = Makefile.in +MODULE = illume2 + +filesdir = $(libdir)/enlightenment/modules/$(MODULE)/keyboards +files_DATA = ignore_built_in_keyboards + +EXTRA_DIST = $(files_DATA) + +uninstall: + rm -rf $(DESTDIR)$(libdir)/enlightenment/modules/$(MODULE)/keyboards + diff --git a/src/modules/illume2/keyboards/ignore_built_in_keyboards b/src/modules/illume2/keyboards/ignore_built_in_keyboards new file mode 100644 index 0000000..bdb9d6b --- /dev/null +++ b/src/modules/illume2/keyboards/ignore_built_in_keyboards @@ -0,0 +1 @@ +/org/freedesktop/Hal/devices/platform_* diff --git a/src/modules/illume2/module.desktop.in b/src/modules/illume2/module.desktop.in new file mode 100644 index 0000000..8f3845f --- /dev/null +++ b/src/modules/illume2/module.desktop.in @@ -0,0 +1,8 @@ +[Desktop Entry] +Type=Link +Name=Illume2 +Icon=e-module-illume2 +X-Enlightenment-ModuleType=system +Comment=Illume2 for Embedded +Comment[fr]=Illume2 pour l'embarqué +Comment[it]=Illume2 per sistemi embedded diff --git a/src/modules/illume2/policies/Makefile.am b/src/modules/illume2/policies/Makefile.am new file mode 100644 index 0000000..33285bf --- /dev/null +++ b/src/modules/illume2/policies/Makefile.am @@ -0,0 +1,2 @@ +MAINTAINERCLEANFILES = Makefile.in +SUBDIRS = samsung illume diff --git a/src/modules/illume2/policies/illume/Makefile.am b/src/modules/illume2/policies/illume/Makefile.am new file mode 100644 index 0000000..2ba8665 --- /dev/null +++ b/src/modules/illume2/policies/illume/Makefile.am @@ -0,0 +1,20 @@ +MAINTAINERCLEANFILES = Makefile.in +MODULE = illume2 + +# the module .so file +INCLUDES = -I.. \ + -I$(top_srcdir) \ + -I$(top_srcdir)/src/modules/$(MODULE) \ + -I$(top_srcdir)/src/bin \ + -I$(top_srcdir)/src/lib \ + -I$(top_srcdir)/src/modules \ + @e_cflags@ + +plugindir = $(libdir)/enlightenment/modules/$(MODULE)/policies + +illumedir = $(plugindir) +illume_LTLIBRARIES = illume.la +illume_la_SOURCES = illume.c layout.c +illume_la_LIBADD = @e_libs@ +illume_la_LDFLAGS = -no-undefined -module -avoid-version +illume_la_LIBTOOLFLAGS = --tag=disable-static diff --git a/src/modules/illume2/policies/illume/illume.c b/src/modules/illume2/policies/illume/illume.c new file mode 100644 index 0000000..fe0cb7c --- /dev/null +++ b/src/modules/illume2/policies/illume/illume.c @@ -0,0 +1,44 @@ +#include "E_Illume.h" +#include "illume.h" +#include "layout.h" + +EAPI E_Illume_Layout_Api e_layapi = +{ + E_ILLUME_LAYOUT_API_VERSION, "Illume", "illume" +}; + +EAPI void * +e_layapi_init(E_Illume_Layout_Policy *p) +{ + p->funcs.border_add = _layout_border_add; + p->funcs.border_del = _layout_border_del; + p->funcs.border_focus_in = _layout_border_focus_in; + p->funcs.border_focus_out = _layout_border_focus_out; + p->funcs.border_activate = _layout_border_activate; + p->funcs.zone_layout = _layout_zone_layout; + p->funcs.zone_move_resize = _layout_zone_move_resize; + p->funcs.drag_start = _layout_drag_start; + p->funcs.drag_end = _layout_drag_end; + return p; +} + +EAPI int +e_layapi_shutdown(E_Illume_Layout_Policy *p) +{ + p->funcs.border_add = NULL; + p->funcs.border_del = NULL; + p->funcs.border_focus_in = NULL; + p->funcs.border_focus_out = NULL; + p->funcs.border_activate = NULL; + p->funcs.zone_layout = NULL; + p->funcs.zone_move_resize = NULL; + p->funcs.drag_start = NULL; + p->funcs.drag_end = NULL; + return 1; +} + +EAPI void +e_layapi_config(E_Container *con, const char *params) +{ + +} diff --git a/src/modules/illume2/policies/illume/illume.h b/src/modules/illume2/policies/illume/illume.h new file mode 100644 index 0000000..bd58507 --- /dev/null +++ b/src/modules/illume2/policies/illume/illume.h @@ -0,0 +1,10 @@ +#ifndef _ILLUME_H +# define _ILLUME_H + +EAPI extern E_Illume_Layout_Api e_layapi; + +EAPI void *e_layapi_init(E_Illume_Layout_Policy *p); +EAPI int e_layapi_shutdown(E_Illume_Layout_Policy *p); +EAPI void e_layapi_config(E_Container *con, const char *params); + +#endif diff --git a/src/modules/illume2/policies/illume/layout.c b/src/modules/illume2/policies/illume/layout.c new file mode 100644 index 0000000..d4bd084 --- /dev/null +++ b/src/modules/illume2/policies/illume/layout.c @@ -0,0 +1,615 @@ +#include "E_Illume.h" +#include "layout.h" + +/* local function prototypes */ +static void _border_resize_fx(E_Border *bd, int bx, int by, int bw, int bh); +static void _zone_layout_single(E_Border *bd); +static void _zone_layout_dual(E_Border *bd); +static void _zone_layout_dual_top(E_Border *bd); +static void _zone_layout_dual_top_custom(E_Border *bd); +static void _zone_layout_dual_left(E_Border *bd); + +/* local variables */ +static int shelfsize = 0; +static int kbdsize = 0; +static int panelsize = 0; + +void +_layout_border_add(E_Border *bd) +{ + /* HANDLE A BORDER BEING ADDED */ + + int conform; + + /* skip new clients and invisible borders */ + if ((bd->new_client) || (!bd->visible)) return; + + /* check if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* is this a fullscreen border ? */ + if ((bd->need_fullscreen) || (bd->fullscreen)) + { + E_Border *b; + + if (bd->layer != IL_FULLSCREEN_LAYER) + e_border_layer_set(bd, IL_FULLSCREEN_LAYER); + + /* we lock stacking so that the keyboard does not get put + * under the window (if it's needed) */ + bd->lock_user_stacking = 1; + + /* conformant fullscreen borders just hide bottom panel */ + b = e_illume_border_bottom_panel_get(bd->zone); + if (b) e_border_fx_offset(b, 0, -panelsize); + + /* for non-conformant fullscreen borders, + * we hide top shelf and bottom panel in all cases */ + if (!conform) + { + b = e_illume_border_top_shelf_get(bd->zone); + if (b) e_border_fx_offset(b, 0, -shelfsize); + } + } + else if (conform) + { + if (bd->layer != IL_CONFORM_LAYER) + e_border_layer_set(bd, IL_CONFORM_LAYER); + bd->lock_user_stacking = 1; + } + + /* only set focus if border accepts it and it's not locked out */ + if ((bd->client.icccm.accepts_focus) && (bd->client.icccm.take_focus) + && (!bd->lock_focus_out)) + e_border_focus_set(bd, 1, 1); +} + +void +_layout_border_del(E_Border *bd) +{ + /* HANDLE A BORDER BEING DELETED */ + + if ((bd->need_fullscreen) || (bd->fullscreen)) + { + E_Border *b; + + /* conformant fullscreen borders just get bottom panel shown */ + b = e_illume_border_bottom_panel_get(bd->zone); + if (b) e_border_fx_offset(b, 0, 0); + + /* for non-conformant fullscreen borders, + * we show top shelf and bottom panel in all cases */ + if (!e_illume_border_is_conformant(bd)) + { + b = e_illume_border_top_shelf_get(bd->zone); + if (b) e_border_fx_offset(b, 0, 0); + } + } +} + +void +_layout_border_focus_in(E_Border *bd) +{ + /* do something if focus enters a window */ +} + +void +_layout_border_focus_out(E_Border *bd) +{ + /* do something if focus exits a window */ +} + +void +_layout_border_activate(E_Border *bd) +{ + /* HANDLE A BORDER BEING ACTIVATED */ + + if (bd->stolen) return; + + /* only set focus if border accepts it and it's not locked out */ + if (((!bd->client.icccm.accepts_focus) && (!bd->client.icccm.take_focus)) || + (bd->lock_focus_out)) + return; + + /* if the border is not focused, check focus settings */ + if ((bd) && (!bd->focused)) + { + if ((e_config->focus_setting == E_FOCUS_NEW_WINDOW) || + ((bd->parent) && + ((e_config->focus_setting == E_FOCUS_NEW_DIALOG) || + ((bd->parent->focused) && + (e_config->focus_setting == E_FOCUS_NEW_DIALOG_IF_OWNER_FOCUSED))))) + { + if (bd->iconic) + { + /* if it's iconic, then uniconify */ + if (!bd->lock_user_iconify) e_border_uniconify(bd); + } + /* if we can, raise the border */ + if (!bd->lock_user_stacking) e_border_raise(bd); + /* if we can, focus the border */ + if (!bd->lock_focus_out) e_border_focus_set(bd, 1, 1); + } + } +} + +void +_layout_zone_layout(E_Zone *zone) +{ + Eina_List *l, *borders; + E_Border *bd; + + /* ACTUALLY APPLY THE SIZING, POSITIONING AND LAYERING */ + + /* grab list of borders */ + borders = e_border_client_list(); + EINA_LIST_FOREACH(borders, l, bd) + { + int mh; + + /* skip border if: zone not the same, a new client, or invisible */ + if ((bd->zone != zone) || (bd->new_client) || (!bd->visible)) continue; + + /* check for special windows to get their size(s) */ + e_illume_border_min_get(bd, NULL, &mh); + if (e_illume_border_is_top_shelf(bd)) + { + if (shelfsize < mh) shelfsize = mh; + } + else if (e_illume_border_is_bottom_panel(bd)) + { + if (panelsize < mh) panelsize = mh; + } + else if (e_illume_border_is_keyboard(bd)) + { + if (kbdsize < mh) kbdsize = mh; + } + } + + /* grab list of borders */ + borders = e_border_client_list(); + EINA_LIST_FOREACH(borders, l, bd) + { + /* skip border if: zone not the same, a new client, or invisible */ + if ((bd->zone != zone) || (bd->new_client) || (!bd->visible)) continue; + + /* trap 'special' windows as they need special treatment */ + if (e_illume_border_is_top_shelf(bd)) + { + /* make sure we are not dragging the shelf */ + if (!ecore_x_e_illume_drag_get(bd->client.win)) + { + /* if we are not in dual mode, then set shelf to top */ + if (!il_cfg->policy.mode.dual) + _border_resize_fx(bd, zone->x, zone->y, zone->w, shelfsize); + else + { + /* make sure we are in landscape mode */ + if (il_cfg->policy.mode.side == 0) + _border_resize_fx(bd, zone->x, bd->y, zone->w, shelfsize); + else + _border_resize_fx(bd, zone->x, zone->y, zone->w, shelfsize); + } + } + e_border_stick(bd); + if (bd->layer != IL_TOP_SHELF_LAYER) + e_border_layer_set(bd, IL_TOP_SHELF_LAYER); + } + else if (e_illume_border_is_bottom_panel(bd)) + { + /* make sure we are not dragging the bottom panel */ + if (!ecore_x_e_illume_drag_get(bd->client.win)) + _border_resize_fx(bd, zone->x, (zone->y + zone->h - panelsize), + zone->w, panelsize); + e_border_stick(bd); + if (bd->layer != IL_BOTTOM_PANEL_LAYER) + e_border_layer_set(bd, IL_BOTTOM_PANEL_LAYER); + } + else if (e_illume_border_is_keyboard(bd)) + { + if ((bd->h != kbdsize) || (bd->w != zone->w)) + e_border_resize(bd, zone->w, kbdsize); + if ((bd->x != zone->x) || (bd->y != (zone->y + zone->h - kbdsize)) || + (bd->fx.y != (zone->y + zone->h - kbdsize))) + e_border_move(bd, zone->x, (zone->y + zone->h - kbdsize)); + e_border_stick(bd); + if (bd->layer != IL_KEYBOARD_LAYER) + e_border_layer_set(bd, IL_KEYBOARD_LAYER); + } + else if (e_illume_border_is_dialog(bd)) + { + int mw, mh; + + e_illume_border_min_get(bd, &mw, &mh); + if (mw > zone->w) mw = zone->w; + if (mh > zone->h) mh = zone->h; + _border_resize_fx(bd, (zone->x + ((zone->w - mw) / 2)), + (zone->y + ((zone->h - mh) / 2)), mw, mh); + if (bd->layer != IL_DIALOG_LAYER) + e_border_layer_set(bd, IL_DIALOG_LAYER); + } + else if (e_illume_border_is_quickpanel(bd)) + { + int mh; + + e_illume_border_min_get(bd, NULL, &mh); + if ((bd->w != bd->zone->w) || (bd->h != mh)) + e_border_resize(bd, bd->zone->w, mh); + if (bd->layer != IL_QUICKPANEL_LAYER) + e_border_layer_set(bd, IL_QUICKPANEL_LAYER); + bd->lock_user_stacking = 1; + } + else + { + if (bd->layer != IL_APP_LAYER) + e_border_layer_set(bd, IL_APP_LAYER); + + /* normal border, handle layout based on policy mode */ + if (il_cfg->policy.mode.dual) _zone_layout_dual(bd); + else _zone_layout_single(bd); + } + } +} + +void +_layout_zone_move_resize(E_Zone *zone) +{ + /* the zone was moved or resized - re-configure all windows in this zone */ + _layout_zone_layout(zone); +} + +void +_layout_drag_start(E_Border *bd) +{ + /* HANDLE A BORDER DRAG BEING STARTED */ + ecore_x_e_illume_drag_set(bd->client.win, 1); +} + +void +_layout_drag_end(E_Border *bd) +{ + /* HANDLE A BORDER DRAG BEING ENDED */ + ecore_x_e_illume_drag_set(bd->client.win, 0); +} + +/* local functions */ +static void +_border_resize_fx(E_Border *bd, int bx, int by, int bw, int bh) +{ + /* CONVENIENCE FUNCTION TO REMOVE DUPLICATED CODE */ + + if ((bd->need_fullscreen) || (bd->fullscreen)) + { + if ((bd->w != bw) || (bd->h != bh)) + { + bd->w = bw; + bd->h = bh; + bd->client.w = bw; + bd->client.h = bh; + bd->changes.size = 1; + bd->changed = 1; + } + if ((bd->x != bx) || (bd->y != by)) + { + bd->x = bx; + bd->y = by; + bd->changes.pos = 1; + bd->changed = 1; + } + } + else + { + if ((bd->w != bw) || (bd->h != bh)) + e_border_resize(bd, bw, bh); + if ((bd->x != bx) || (bd->y != by)) + e_border_fx_offset(bd, bx, by); + } +} + +static void +_zone_layout_single(E_Border *bd) +{ + int kx, ky, kw, kh, ss, ps; + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, &ky, &kw, &kh); + if (!e_illume_border_is_conformant(bd)) + { + if (!((bd->need_fullscreen) || (bd->fullscreen))) + { + if (kh >= bd->zone->h) ps = panelsize; + ss = shelfsize; + } + } + else + kh = bd->zone->h; + _border_resize_fx(bd, kx, (ky + ss), kw, (kh - ss - ps)); +} + +static void +_zone_layout_dual(E_Border *bd) +{ + if (il_cfg->policy.mode.side == 0) + { + int ty; + + e_illume_border_top_shelf_pos_get(bd->zone, NULL, &ty); + if (ty <= bd->zone->y) + _zone_layout_dual_top(bd); + else + _zone_layout_dual_top_custom(bd); + } + else if (il_cfg->policy.mode.side == 1) + _zone_layout_dual_left(bd); +} + +static void +_zone_layout_dual_top(E_Border *bd) +{ + int kx, ky, kw, kh, ss, ps; + int conform; + + /* fetch if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, &ky, &kw, &kh); + if (!conform) + { + /* if the border is not conformant and doesn't need fullscreen, then + * we account for shelf & panel sizes */ + if (!((bd->need_fullscreen) || (bd->fullscreen))) + { + if (kh >= bd->zone->h) ps = panelsize; + ss = shelfsize; + } + } + + /* if there are no other borders, than give this one all available space */ + if (e_illume_border_valid_count_get(bd->zone) < 2) + _border_resize_fx(bd, kx, (ky + ss), kw, (kh - ss - ps)); + else + { + E_Border *b; + int bx, by, bw, bh; + + /* more than one valid border */ + bx = kx; + by = (ky + ss); + bw = kw; + bh = (kh - ss - ps); + + /* grab the border at this location */ + b = e_illume_border_at_xy_get(bd->zone, kx, shelfsize); + + if ((b) && (bd != b)) + { + /* we have a border there, and it's not the current one */ + if (!e_illume_border_is_conformant(b)) + { + /* border in this location is not conformant */ + bh = ((kh - ss - ps) / 2); + by = (b->fx.y + b->h); + } + else + { + /* border there is conformant */ + if (conform) + { + /* if current border is conformant, divide zone in half */ + bh = ((bd->zone->h - ss) / 2); + by = by + bh; + } + else + { + /* current border is not conformant */ + by = (b->fx.y + b->h); + bh = (kh - by - ps); + } + } + } + else if (b) + { + /* border at this location and it's the current border */ + by = bd->fx.y; + bh = ((kh - ss - ps) / 2); + } + else + { + /* no border at this location */ + b = e_illume_border_valid_border_get(bd->zone); + by = ky + ss; + bh = (ky - b->h); + } + _border_resize_fx(bd, bx, by, bw, bh); + } +} + +static void +_zone_layout_dual_top_custom(E_Border *bd) +{ + int kx, kw; + int count, conform; + int ax, ay, aw, ah; + int zx, zy, zw, zh; + + /* get count of valid borders */ + count = e_illume_border_valid_count_get(bd->zone); + + /* fetch if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, NULL, &kw, NULL); + + e_illume_border_app1_safe_region_get(bd->zone, &ax, &ay, &aw, &ah); + e_illume_border_app2_safe_region_get(bd->zone, &zx, &zy, &zw, &zh); + + /* if there are no other borders, than give this one all available space */ + if (count < 2) + { + if (ah >= zh) + { + zx = ax; + zy = ax; + zw = aw; + zh = ah; + } + if ((bd->w != zw) || (bd->h != zh)) + e_border_resize(bd, zw, zh); + if ((bd->x != zx) || (bd->y != zy) || (bd->fx.y != zy)) + e_border_fx_offset(bd, zx, zy); + } + else + { + E_Border *bt, *bb; + int bh, by; + + /* more than one valid border */ + + if (ecore_x_e_virtual_keyboard_state_get(bd->client.win) > + ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + bh = ah; + by = ay; + } + else + { + /* grab the border at this location */ + bt = e_illume_border_at_xy_get(bd->zone, kx, ay); + + if ((bt) && (bd != bt)) + { + /* is there a border in the bottom section */ + bb = e_illume_border_at_xy_get(bd->zone, kx, zy); + if (!bb) + { + bh = zh; + by = zy; + } + else if ((bb) && (bd != bb)) + { + if (bt == e_border_focused_get()) + { + if (ecore_x_e_virtual_keyboard_state_get(bd->client.win) <= + ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + bh = zh; + by = zy; + } + else + { + bh = ah; + by = ay; + } + } + else if (bb = e_border_focused_get()) + { + if (ecore_x_e_virtual_keyboard_state_get(bd->client.win) <= + ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + bh = ah; + by = ay; + } + } + } + else if (bb) + { + bh = zh; + by = zy; + } + } + else + { + bh = ah; + by = ay; + } + } + if ((bd->w != kw) || (bd->h != bh)) + e_border_resize(bd, kw, bh); + if ((bd->x != kx) || (bd->y != by) || (bd->fx.y != by)) + e_border_fx_offset(bd, kx, by); + } +} + +static void +_zone_layout_dual_left(E_Border *bd) +{ + int kx, ky, kw, kh, ss, ps; + int conform; + + /* fetch if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, &ky, &kw, &kh); + if (!conform) + { + /* if the border is not conformant and doesn't need fullscreen, then + * we account for shelf & panel sizes */ + if (!((bd->need_fullscreen) || (bd->fullscreen))) + { + if (kh >= bd->zone->h) ps = panelsize; + ss = shelfsize; + } + } + + /* if there are no other borders, than give this one all available space */ + if (e_illume_border_valid_count_get(bd->zone) < 2) + _border_resize_fx(bd, kx, (ky + ss), kw, (kh - ss - ps)); + else + { + E_Border *b; + int bx, by, bw, bh; + + /* more than one valid border */ + bx = kx; + by = (ky + ss); + bw = kw; + bh = (kh - ss - ps); + + /* grab the border at this location */ + b = e_illume_border_at_xy_get(bd->zone, kx, shelfsize); + + if ((b) && (bd != b)) + { + /* we have a border there, and it's not the current one */ + if (!e_illume_border_is_conformant(b)) + { + /* border in this location is not conformant */ + bw = (kw / 2); + bx = (b->fx.x + b->w); + } + else + { + /* border there is conformant */ + if (conform) + { + /* if current border is conformant, divide zone in half */ + bw = (bd->zone->w / 2); + bx = bx + bw; + } + else + { + /* current border is not conformant */ + bx = (b->fx.x + b->w); + bw = (kw - bx); + } + } + } + else if (b) + { + /* border at this location and it's the current border */ + bx = bd->fx.x; + bw = (kw / 2); + } + else + { + /* no border at this location */ + b = e_illume_border_valid_border_get(bd->zone); + bx = kx; + bw = (kw - b->w); + } + _border_resize_fx(bd, bx, by, bw, bh); + } +} diff --git a/src/modules/illume2/policies/illume/layout.h b/src/modules/illume2/policies/illume/layout.h new file mode 100644 index 0000000..0617246 --- /dev/null +++ b/src/modules/illume2/policies/illume/layout.h @@ -0,0 +1,25 @@ +#ifndef _LAYOUT_H +# define _LAYOUT_H + +/* define some values here for easily changing layers so we don't have to + * grep through code to change layers */ +#define IL_TOP_SHELF_LAYER 200 +#define IL_BOTTOM_PANEL_LAYER 100 +#define IL_KEYBOARD_LAYER 150 +#define IL_DIALOG_LAYER 120 +#define IL_CONFORM_LAYER 140 +#define IL_FULLSCREEN_LAYER 140 +#define IL_QUICKPANEL_LAYER 160 +#define IL_APP_LAYER 100 + +void _layout_border_add(E_Border *bd); +void _layout_border_del(E_Border *bd); +void _layout_border_focus_in(E_Border *bd); +void _layout_border_focus_out(E_Border *bd); +void _layout_border_activate(E_Border *bd); +void _layout_zone_layout(E_Zone *zone); +void _layout_zone_move_resize(E_Zone *zone); +void _layout_drag_start(E_Border *bd); +void _layout_drag_end(E_Border *bd); + +#endif diff --git a/src/modules/illume2/policies/samsung/Makefile.am b/src/modules/illume2/policies/samsung/Makefile.am new file mode 100644 index 0000000..1ed804f --- /dev/null +++ b/src/modules/illume2/policies/samsung/Makefile.am @@ -0,0 +1,20 @@ +MAINTAINERCLEANFILES = Makefile.in +MODULE = illume2 + +# the module .so file +INCLUDES = -I.. \ + -I$(top_srcdir) \ + -I$(top_srcdir)/src/modules/$(MODULE) \ + -I$(top_srcdir)/src/bin \ + -I$(top_srcdir)/src/lib \ + -I$(top_srcdir)/src/modules \ + @e_cflags@ + +plugindir = $(libdir)/enlightenment/modules/$(MODULE)/policies + +samsungdir = $(plugindir) +samsung_LTLIBRARIES = samsung.la +samsung_la_SOURCES = samsung.c layout.c +samsung_la_LIBADD = @e_libs@ +samsung_la_LDFLAGS = -no-undefined -module -avoid-version +samsung_la_LIBTOOLFLAGS = --tag=disable-static diff --git a/src/modules/illume2/policies/samsung/layout.c b/src/modules/illume2/policies/samsung/layout.c new file mode 100644 index 0000000..d4bd084 --- /dev/null +++ b/src/modules/illume2/policies/samsung/layout.c @@ -0,0 +1,615 @@ +#include "E_Illume.h" +#include "layout.h" + +/* local function prototypes */ +static void _border_resize_fx(E_Border *bd, int bx, int by, int bw, int bh); +static void _zone_layout_single(E_Border *bd); +static void _zone_layout_dual(E_Border *bd); +static void _zone_layout_dual_top(E_Border *bd); +static void _zone_layout_dual_top_custom(E_Border *bd); +static void _zone_layout_dual_left(E_Border *bd); + +/* local variables */ +static int shelfsize = 0; +static int kbdsize = 0; +static int panelsize = 0; + +void +_layout_border_add(E_Border *bd) +{ + /* HANDLE A BORDER BEING ADDED */ + + int conform; + + /* skip new clients and invisible borders */ + if ((bd->new_client) || (!bd->visible)) return; + + /* check if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* is this a fullscreen border ? */ + if ((bd->need_fullscreen) || (bd->fullscreen)) + { + E_Border *b; + + if (bd->layer != IL_FULLSCREEN_LAYER) + e_border_layer_set(bd, IL_FULLSCREEN_LAYER); + + /* we lock stacking so that the keyboard does not get put + * under the window (if it's needed) */ + bd->lock_user_stacking = 1; + + /* conformant fullscreen borders just hide bottom panel */ + b = e_illume_border_bottom_panel_get(bd->zone); + if (b) e_border_fx_offset(b, 0, -panelsize); + + /* for non-conformant fullscreen borders, + * we hide top shelf and bottom panel in all cases */ + if (!conform) + { + b = e_illume_border_top_shelf_get(bd->zone); + if (b) e_border_fx_offset(b, 0, -shelfsize); + } + } + else if (conform) + { + if (bd->layer != IL_CONFORM_LAYER) + e_border_layer_set(bd, IL_CONFORM_LAYER); + bd->lock_user_stacking = 1; + } + + /* only set focus if border accepts it and it's not locked out */ + if ((bd->client.icccm.accepts_focus) && (bd->client.icccm.take_focus) + && (!bd->lock_focus_out)) + e_border_focus_set(bd, 1, 1); +} + +void +_layout_border_del(E_Border *bd) +{ + /* HANDLE A BORDER BEING DELETED */ + + if ((bd->need_fullscreen) || (bd->fullscreen)) + { + E_Border *b; + + /* conformant fullscreen borders just get bottom panel shown */ + b = e_illume_border_bottom_panel_get(bd->zone); + if (b) e_border_fx_offset(b, 0, 0); + + /* for non-conformant fullscreen borders, + * we show top shelf and bottom panel in all cases */ + if (!e_illume_border_is_conformant(bd)) + { + b = e_illume_border_top_shelf_get(bd->zone); + if (b) e_border_fx_offset(b, 0, 0); + } + } +} + +void +_layout_border_focus_in(E_Border *bd) +{ + /* do something if focus enters a window */ +} + +void +_layout_border_focus_out(E_Border *bd) +{ + /* do something if focus exits a window */ +} + +void +_layout_border_activate(E_Border *bd) +{ + /* HANDLE A BORDER BEING ACTIVATED */ + + if (bd->stolen) return; + + /* only set focus if border accepts it and it's not locked out */ + if (((!bd->client.icccm.accepts_focus) && (!bd->client.icccm.take_focus)) || + (bd->lock_focus_out)) + return; + + /* if the border is not focused, check focus settings */ + if ((bd) && (!bd->focused)) + { + if ((e_config->focus_setting == E_FOCUS_NEW_WINDOW) || + ((bd->parent) && + ((e_config->focus_setting == E_FOCUS_NEW_DIALOG) || + ((bd->parent->focused) && + (e_config->focus_setting == E_FOCUS_NEW_DIALOG_IF_OWNER_FOCUSED))))) + { + if (bd->iconic) + { + /* if it's iconic, then uniconify */ + if (!bd->lock_user_iconify) e_border_uniconify(bd); + } + /* if we can, raise the border */ + if (!bd->lock_user_stacking) e_border_raise(bd); + /* if we can, focus the border */ + if (!bd->lock_focus_out) e_border_focus_set(bd, 1, 1); + } + } +} + +void +_layout_zone_layout(E_Zone *zone) +{ + Eina_List *l, *borders; + E_Border *bd; + + /* ACTUALLY APPLY THE SIZING, POSITIONING AND LAYERING */ + + /* grab list of borders */ + borders = e_border_client_list(); + EINA_LIST_FOREACH(borders, l, bd) + { + int mh; + + /* skip border if: zone not the same, a new client, or invisible */ + if ((bd->zone != zone) || (bd->new_client) || (!bd->visible)) continue; + + /* check for special windows to get their size(s) */ + e_illume_border_min_get(bd, NULL, &mh); + if (e_illume_border_is_top_shelf(bd)) + { + if (shelfsize < mh) shelfsize = mh; + } + else if (e_illume_border_is_bottom_panel(bd)) + { + if (panelsize < mh) panelsize = mh; + } + else if (e_illume_border_is_keyboard(bd)) + { + if (kbdsize < mh) kbdsize = mh; + } + } + + /* grab list of borders */ + borders = e_border_client_list(); + EINA_LIST_FOREACH(borders, l, bd) + { + /* skip border if: zone not the same, a new client, or invisible */ + if ((bd->zone != zone) || (bd->new_client) || (!bd->visible)) continue; + + /* trap 'special' windows as they need special treatment */ + if (e_illume_border_is_top_shelf(bd)) + { + /* make sure we are not dragging the shelf */ + if (!ecore_x_e_illume_drag_get(bd->client.win)) + { + /* if we are not in dual mode, then set shelf to top */ + if (!il_cfg->policy.mode.dual) + _border_resize_fx(bd, zone->x, zone->y, zone->w, shelfsize); + else + { + /* make sure we are in landscape mode */ + if (il_cfg->policy.mode.side == 0) + _border_resize_fx(bd, zone->x, bd->y, zone->w, shelfsize); + else + _border_resize_fx(bd, zone->x, zone->y, zone->w, shelfsize); + } + } + e_border_stick(bd); + if (bd->layer != IL_TOP_SHELF_LAYER) + e_border_layer_set(bd, IL_TOP_SHELF_LAYER); + } + else if (e_illume_border_is_bottom_panel(bd)) + { + /* make sure we are not dragging the bottom panel */ + if (!ecore_x_e_illume_drag_get(bd->client.win)) + _border_resize_fx(bd, zone->x, (zone->y + zone->h - panelsize), + zone->w, panelsize); + e_border_stick(bd); + if (bd->layer != IL_BOTTOM_PANEL_LAYER) + e_border_layer_set(bd, IL_BOTTOM_PANEL_LAYER); + } + else if (e_illume_border_is_keyboard(bd)) + { + if ((bd->h != kbdsize) || (bd->w != zone->w)) + e_border_resize(bd, zone->w, kbdsize); + if ((bd->x != zone->x) || (bd->y != (zone->y + zone->h - kbdsize)) || + (bd->fx.y != (zone->y + zone->h - kbdsize))) + e_border_move(bd, zone->x, (zone->y + zone->h - kbdsize)); + e_border_stick(bd); + if (bd->layer != IL_KEYBOARD_LAYER) + e_border_layer_set(bd, IL_KEYBOARD_LAYER); + } + else if (e_illume_border_is_dialog(bd)) + { + int mw, mh; + + e_illume_border_min_get(bd, &mw, &mh); + if (mw > zone->w) mw = zone->w; + if (mh > zone->h) mh = zone->h; + _border_resize_fx(bd, (zone->x + ((zone->w - mw) / 2)), + (zone->y + ((zone->h - mh) / 2)), mw, mh); + if (bd->layer != IL_DIALOG_LAYER) + e_border_layer_set(bd, IL_DIALOG_LAYER); + } + else if (e_illume_border_is_quickpanel(bd)) + { + int mh; + + e_illume_border_min_get(bd, NULL, &mh); + if ((bd->w != bd->zone->w) || (bd->h != mh)) + e_border_resize(bd, bd->zone->w, mh); + if (bd->layer != IL_QUICKPANEL_LAYER) + e_border_layer_set(bd, IL_QUICKPANEL_LAYER); + bd->lock_user_stacking = 1; + } + else + { + if (bd->layer != IL_APP_LAYER) + e_border_layer_set(bd, IL_APP_LAYER); + + /* normal border, handle layout based on policy mode */ + if (il_cfg->policy.mode.dual) _zone_layout_dual(bd); + else _zone_layout_single(bd); + } + } +} + +void +_layout_zone_move_resize(E_Zone *zone) +{ + /* the zone was moved or resized - re-configure all windows in this zone */ + _layout_zone_layout(zone); +} + +void +_layout_drag_start(E_Border *bd) +{ + /* HANDLE A BORDER DRAG BEING STARTED */ + ecore_x_e_illume_drag_set(bd->client.win, 1); +} + +void +_layout_drag_end(E_Border *bd) +{ + /* HANDLE A BORDER DRAG BEING ENDED */ + ecore_x_e_illume_drag_set(bd->client.win, 0); +} + +/* local functions */ +static void +_border_resize_fx(E_Border *bd, int bx, int by, int bw, int bh) +{ + /* CONVENIENCE FUNCTION TO REMOVE DUPLICATED CODE */ + + if ((bd->need_fullscreen) || (bd->fullscreen)) + { + if ((bd->w != bw) || (bd->h != bh)) + { + bd->w = bw; + bd->h = bh; + bd->client.w = bw; + bd->client.h = bh; + bd->changes.size = 1; + bd->changed = 1; + } + if ((bd->x != bx) || (bd->y != by)) + { + bd->x = bx; + bd->y = by; + bd->changes.pos = 1; + bd->changed = 1; + } + } + else + { + if ((bd->w != bw) || (bd->h != bh)) + e_border_resize(bd, bw, bh); + if ((bd->x != bx) || (bd->y != by)) + e_border_fx_offset(bd, bx, by); + } +} + +static void +_zone_layout_single(E_Border *bd) +{ + int kx, ky, kw, kh, ss, ps; + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, &ky, &kw, &kh); + if (!e_illume_border_is_conformant(bd)) + { + if (!((bd->need_fullscreen) || (bd->fullscreen))) + { + if (kh >= bd->zone->h) ps = panelsize; + ss = shelfsize; + } + } + else + kh = bd->zone->h; + _border_resize_fx(bd, kx, (ky + ss), kw, (kh - ss - ps)); +} + +static void +_zone_layout_dual(E_Border *bd) +{ + if (il_cfg->policy.mode.side == 0) + { + int ty; + + e_illume_border_top_shelf_pos_get(bd->zone, NULL, &ty); + if (ty <= bd->zone->y) + _zone_layout_dual_top(bd); + else + _zone_layout_dual_top_custom(bd); + } + else if (il_cfg->policy.mode.side == 1) + _zone_layout_dual_left(bd); +} + +static void +_zone_layout_dual_top(E_Border *bd) +{ + int kx, ky, kw, kh, ss, ps; + int conform; + + /* fetch if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, &ky, &kw, &kh); + if (!conform) + { + /* if the border is not conformant and doesn't need fullscreen, then + * we account for shelf & panel sizes */ + if (!((bd->need_fullscreen) || (bd->fullscreen))) + { + if (kh >= bd->zone->h) ps = panelsize; + ss = shelfsize; + } + } + + /* if there are no other borders, than give this one all available space */ + if (e_illume_border_valid_count_get(bd->zone) < 2) + _border_resize_fx(bd, kx, (ky + ss), kw, (kh - ss - ps)); + else + { + E_Border *b; + int bx, by, bw, bh; + + /* more than one valid border */ + bx = kx; + by = (ky + ss); + bw = kw; + bh = (kh - ss - ps); + + /* grab the border at this location */ + b = e_illume_border_at_xy_get(bd->zone, kx, shelfsize); + + if ((b) && (bd != b)) + { + /* we have a border there, and it's not the current one */ + if (!e_illume_border_is_conformant(b)) + { + /* border in this location is not conformant */ + bh = ((kh - ss - ps) / 2); + by = (b->fx.y + b->h); + } + else + { + /* border there is conformant */ + if (conform) + { + /* if current border is conformant, divide zone in half */ + bh = ((bd->zone->h - ss) / 2); + by = by + bh; + } + else + { + /* current border is not conformant */ + by = (b->fx.y + b->h); + bh = (kh - by - ps); + } + } + } + else if (b) + { + /* border at this location and it's the current border */ + by = bd->fx.y; + bh = ((kh - ss - ps) / 2); + } + else + { + /* no border at this location */ + b = e_illume_border_valid_border_get(bd->zone); + by = ky + ss; + bh = (ky - b->h); + } + _border_resize_fx(bd, bx, by, bw, bh); + } +} + +static void +_zone_layout_dual_top_custom(E_Border *bd) +{ + int kx, kw; + int count, conform; + int ax, ay, aw, ah; + int zx, zy, zw, zh; + + /* get count of valid borders */ + count = e_illume_border_valid_count_get(bd->zone); + + /* fetch if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, NULL, &kw, NULL); + + e_illume_border_app1_safe_region_get(bd->zone, &ax, &ay, &aw, &ah); + e_illume_border_app2_safe_region_get(bd->zone, &zx, &zy, &zw, &zh); + + /* if there are no other borders, than give this one all available space */ + if (count < 2) + { + if (ah >= zh) + { + zx = ax; + zy = ax; + zw = aw; + zh = ah; + } + if ((bd->w != zw) || (bd->h != zh)) + e_border_resize(bd, zw, zh); + if ((bd->x != zx) || (bd->y != zy) || (bd->fx.y != zy)) + e_border_fx_offset(bd, zx, zy); + } + else + { + E_Border *bt, *bb; + int bh, by; + + /* more than one valid border */ + + if (ecore_x_e_virtual_keyboard_state_get(bd->client.win) > + ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + bh = ah; + by = ay; + } + else + { + /* grab the border at this location */ + bt = e_illume_border_at_xy_get(bd->zone, kx, ay); + + if ((bt) && (bd != bt)) + { + /* is there a border in the bottom section */ + bb = e_illume_border_at_xy_get(bd->zone, kx, zy); + if (!bb) + { + bh = zh; + by = zy; + } + else if ((bb) && (bd != bb)) + { + if (bt == e_border_focused_get()) + { + if (ecore_x_e_virtual_keyboard_state_get(bd->client.win) <= + ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + bh = zh; + by = zy; + } + else + { + bh = ah; + by = ay; + } + } + else if (bb = e_border_focused_get()) + { + if (ecore_x_e_virtual_keyboard_state_get(bd->client.win) <= + ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) + { + bh = ah; + by = ay; + } + } + } + else if (bb) + { + bh = zh; + by = zy; + } + } + else + { + bh = ah; + by = ay; + } + } + if ((bd->w != kw) || (bd->h != bh)) + e_border_resize(bd, kw, bh); + if ((bd->x != kx) || (bd->y != by) || (bd->fx.y != by)) + e_border_fx_offset(bd, kx, by); + } +} + +static void +_zone_layout_dual_left(E_Border *bd) +{ + int kx, ky, kw, kh, ss, ps; + int conform; + + /* fetch if this border is conformant */ + conform = e_illume_border_is_conformant(bd); + + /* grab the 'safe' region. Safe region is space not occupied by keyboard */ + e_illume_kbd_safe_app_region_get(bd->zone, &kx, &ky, &kw, &kh); + if (!conform) + { + /* if the border is not conformant and doesn't need fullscreen, then + * we account for shelf & panel sizes */ + if (!((bd->need_fullscreen) || (bd->fullscreen))) + { + if (kh >= bd->zone->h) ps = panelsize; + ss = shelfsize; + } + } + + /* if there are no other borders, than give this one all available space */ + if (e_illume_border_valid_count_get(bd->zone) < 2) + _border_resize_fx(bd, kx, (ky + ss), kw, (kh - ss - ps)); + else + { + E_Border *b; + int bx, by, bw, bh; + + /* more than one valid border */ + bx = kx; + by = (ky + ss); + bw = kw; + bh = (kh - ss - ps); + + /* grab the border at this location */ + b = e_illume_border_at_xy_get(bd->zone, kx, shelfsize); + + if ((b) && (bd != b)) + { + /* we have a border there, and it's not the current one */ + if (!e_illume_border_is_conformant(b)) + { + /* border in this location is not conformant */ + bw = (kw / 2); + bx = (b->fx.x + b->w); + } + else + { + /* border there is conformant */ + if (conform) + { + /* if current border is conformant, divide zone in half */ + bw = (bd->zone->w / 2); + bx = bx + bw; + } + else + { + /* current border is not conformant */ + bx = (b->fx.x + b->w); + bw = (kw - bx); + } + } + } + else if (b) + { + /* border at this location and it's the current border */ + bx = bd->fx.x; + bw = (kw / 2); + } + else + { + /* no border at this location */ + b = e_illume_border_valid_border_get(bd->zone); + bx = kx; + bw = (kw - b->w); + } + _border_resize_fx(bd, bx, by, bw, bh); + } +} diff --git a/src/modules/illume2/policies/samsung/layout.h b/src/modules/illume2/policies/samsung/layout.h new file mode 100644 index 0000000..0617246 --- /dev/null +++ b/src/modules/illume2/policies/samsung/layout.h @@ -0,0 +1,25 @@ +#ifndef _LAYOUT_H +# define _LAYOUT_H + +/* define some values here for easily changing layers so we don't have to + * grep through code to change layers */ +#define IL_TOP_SHELF_LAYER 200 +#define IL_BOTTOM_PANEL_LAYER 100 +#define IL_KEYBOARD_LAYER 150 +#define IL_DIALOG_LAYER 120 +#define IL_CONFORM_LAYER 140 +#define IL_FULLSCREEN_LAYER 140 +#define IL_QUICKPANEL_LAYER 160 +#define IL_APP_LAYER 100 + +void _layout_border_add(E_Border *bd); +void _layout_border_del(E_Border *bd); +void _layout_border_focus_in(E_Border *bd); +void _layout_border_focus_out(E_Border *bd); +void _layout_border_activate(E_Border *bd); +void _layout_zone_layout(E_Zone *zone); +void _layout_zone_move_resize(E_Zone *zone); +void _layout_drag_start(E_Border *bd); +void _layout_drag_end(E_Border *bd); + +#endif diff --git a/src/modules/illume2/policies/samsung/samsung.c b/src/modules/illume2/policies/samsung/samsung.c new file mode 100644 index 0000000..b65e6b6 --- /dev/null +++ b/src/modules/illume2/policies/samsung/samsung.c @@ -0,0 +1,44 @@ +#include "E_Illume.h" +#include "samsung.h" +#include "layout.h" + +EAPI E_Illume_Layout_Api e_layapi = +{ + E_ILLUME_LAYOUT_API_VERSION, "Samsung", "samsung" +}; + +EAPI void * +e_layapi_init(E_Illume_Layout_Policy *p) +{ + p->funcs.border_add = _layout_border_add; + p->funcs.border_del = _layout_border_del; + p->funcs.border_focus_in = _layout_border_focus_in; + p->funcs.border_focus_out = _layout_border_focus_out; + p->funcs.border_activate = _layout_border_activate; + p->funcs.zone_layout = _layout_zone_layout; + p->funcs.zone_move_resize = _layout_zone_move_resize; + p->funcs.drag_start = _layout_drag_start; + p->funcs.drag_end = _layout_drag_end; + return p; +} + +EAPI int +e_layapi_shutdown(E_Illume_Layout_Policy *p) +{ + p->funcs.border_add = NULL; + p->funcs.border_del = NULL; + p->funcs.border_focus_in = NULL; + p->funcs.border_focus_out = NULL; + p->funcs.border_activate = NULL; + p->funcs.zone_layout = NULL; + p->funcs.zone_move_resize = NULL; + p->funcs.drag_start = NULL; + p->funcs.drag_end = NULL; + return 1; +} + +EAPI void +e_layapi_config(E_Container *con, const char *params) +{ + +} diff --git a/src/modules/illume2/policies/samsung/samsung.h b/src/modules/illume2/policies/samsung/samsung.h new file mode 100644 index 0000000..c8ac34e --- /dev/null +++ b/src/modules/illume2/policies/samsung/samsung.h @@ -0,0 +1,10 @@ +#ifndef _SAMSUNG_H +# define _SAMSUNG_H + +EAPI extern E_Illume_Layout_Api e_layapi; + +EAPI void *e_layapi_init(E_Illume_Layout_Policy *p); +EAPI int e_layapi_shutdown(E_Illume_Layout_Policy *p); +EAPI void e_layapi_config(E_Container *con, const char *params); + +#endif -- 2.7.4