Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1841 connectés 

  FORUM HardWare.fr
  Programmation
  C++

  Modification/amélioration menu contextuel gtk (C++?)

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Modification/amélioration menu contextuel gtk (C++?)

n°2069261
argolance
Posté le 11-04-2011 à 14:10:56  profilanswer
 

Bonjour,
Je connais un peu le code gtkdialog3, qui me permet modestement de créer/modifier des scripts simples pour le développement d'une distribution LINUX à laquelle je collabore: Toutou LINUX FAT version RELOADED. Parmi les utilitaires, il en est un, nommé "fbxkb", qui permet d'afficher et changer la disposition du clavier, d'un simple clic gauche sur une icône-drapeau située dans la barre des tâches. Un clic droit sur cette icône affiche un menu contextuel donnant accès à une fenêtre d'information (genre A propos) ainsi qu'à un bouton pour quitter l'application.
 
http://www.murga-linux.com/puppy/viewtopic.php?mode=attach&id=39739
 
Je trouverais bien pratique qu'une entrée supplémentaire de ce menu donne directement accès à une application, (en l'occurrence, au Gestionnaire de configuration avancée du clavier Xkb Config Manager, dont fbxkb est une sorte d'extension), sans avoir donc à passer par un raccourci dans le menu ou sur le bureau.
 
Ce que j'aimerais obtenir:
 
http://www.murga-linux.com/puppy/viewtopic.php?mode=attach&id=39756
 
Le problème c'est que je ne sais pas du tout comment y parvenir. Pour un habitué de ce langage (gtk C, C++?), je suppose que ce n'est pas bien sorcier, voire basique et évident (?) de modifier le code ci-dessous pour ajouter l'entrée voulue au menu contextuel de l'icône de la barre des taches:

Code :
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <unistd.h>
  7. #include <errno.h>
  8. #include <locale.h>
  9. #include <string.h>
  10. #include <signal.h>
  12. #include <X11/Xlib.h>
  13. #include <gtk/gtk.h>
  14. #include <gdk/gdk.h>
  16. #include <X11/XKBlib.h>
  18. #include "config.h"
  19. #include "eggtrayicon.h"
  20. #include "version.h"
  22. static gchar version[] = VERSION;
  25. //#define DEBUG
  26. #include "dbg.h"
  28. /******************************************************************
  29. * TYPEDEFS                                                        *
  30. ******************************************************************/
  31. typedef struct _kbd_info {
  32.     gchar *sym;
  33.     gchar *name;
  34.     GdkPixbuf *flag;
  35. } kbd_info;
  37. #define IMGPREFIX PREFIX "/share/fbxkb/images/"
  38. /******************************************************************
  39. * GLOBAL VARSIABLES                                              *
  40. ******************************************************************/
  42. /* X11 common stuff */
  43. static Atom a_XKB_RULES_NAMES;
  44. static Display *dpy;
  45. static int xkb_event_type;
  47. /* internal state mashine */
  48. static int cur_group;
  49. static int ngroups;
  50. static GHashTable *sym2pix;
  51. static kbd_info group2info[XkbNumKbdGroups];
  52. static GdkPixbuf *zzflag;
  53. static int active;
  54. /* gtk gui */
  55. static GtkWidget *flag_menu;
  56. static GtkWidget *app_menu;
  57. static GtkWidget *docklet;
  58. static GtkWidget *image;
  59. static GtkWidget *about_dialog = NULL;
  60. /******************************************************************
  61. * DECLARATION                                                    *
  62. ******************************************************************/
  64. static int init();
  65. static void read_kbd_description();
  66. static void update_flag(int no);
  67. static GdkFilterReturn filter( XEvent *xev, GdkEvent *event, gpointer data);
  68. static void Xerror_handler(Display * d, XErrorEvent * ev);
  69. static GdkPixbuf *sym2flag(char *sym);
  70. static void flag_menu_create();
  71. static void flag_menu_destroy();
  72. static void flag_menu_activated(GtkWidget *widget, gpointer data);
  73. static void app_menu_create();
  74. static void app_menu_about(GtkWidget *widget, gpointer data);
  75. static void app_menu_exit(GtkWidget *widget, gpointer data);
  77. static int docklet_create();
  79. static int create_all();
  81. /******************************************************************
  82. * CODE                                                           *
  83. ******************************************************************/
  85. /******************************************************************
  86. * gtk gui                                                        *
  87. ******************************************************************/
  88. static void
  89. flag_menu_create()
  90. {
  91.     int i;
  92.     GdkPixbuf *flag;
  93.     GtkWidget *mi, *img;
  94.     //static GString *s = NULL;;
  95.    
  96.     ENTER;
  97.     flag_menu =  gtk_menu_new();
  98.     for (i = 0; i < ngroups; i++) {
  99.         mi = gtk_image_menu_item_new_with_label(
  100.             group2info.name ? group2info[i].name : group2info[i].sym);
  101.         g_signal_connect(G_OBJECT(mi), "activate", (GCallback)flag_menu_activated, GINT_TO_POINTER(i));
  102.         gtk_menu_shell_append (GTK_MENU_SHELL (flag_menu), mi);
  103.         gtk_widget_show (mi);
  104.         flag = sym2flag(group2info[i].sym);
  105.         img = gtk_image_new_from_pixbuf(flag);
  106.         gtk_widget_show(img);
  107.         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
  108.     }
  109.     RET();
  110. }
  112. static void
  113. flag_menu_destroy()
  114. {
  115.     if (flag_menu) {
  116.         gtk_widget_destroy(flag_menu);
  117.         flag_menu = NULL;
  118.     }
  119. }
  121. static void
  122. flag_menu_activated(GtkWidget *widget, gpointer data)
  123. {
  124.     int i;
  126.     ENTER;   
  127.     i = GPOINTER_TO_INT(data);
  128.     DBG("asking %d group\n", i);
  129.     XkbLockGroup(dpy, XkbUseCoreKbd, i);
  130.     RET();
  131. }
  133. static void
  134. app_menu_create()
  135. {
  136.     GtkWidget *mi;
  137.    
  138.     ENTER;
  139.     app_menu =  gtk_menu_new();
  141.     mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_DIALOG_INFO, NULL);
  142.     g_signal_connect(G_OBJECT(mi), "activate", (GCallback)app_menu_about, NULL);
  143.     gtk_menu_shell_append (GTK_MENU_SHELL (app_menu), mi);
  144.     gtk_widget_show (mi);
  146.    
  147.     mi = gtk_menu_item_new ();
  148.     gtk_widget_show (mi);
  149.     gtk_menu_shell_append (GTK_MENU_SHELL (app_menu), mi);
  150.     gtk_widget_set_sensitive (mi, FALSE);
  152.     mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
  153.     g_signal_connect(G_OBJECT(mi), "activate", (GCallback)app_menu_exit, NULL);
  154.     gtk_menu_shell_append (GTK_MENU_SHELL (app_menu), mi);
  155.     gtk_widget_show (mi);
  156.     RET();
  158. }
  160. static void
  161. app_menu_about(GtkWidget *widget, gpointer data)
  162. {
  163.     ENTER;
  164.     if (!about_dialog) {
  165.         about_dialog = gtk_message_dialog_new (NULL,
  166.               GTK_DIALOG_DESTROY_WITH_PARENT,
  167.               GTK_MESSAGE_INFO,
  168.               GTK_BUTTONS_CLOSE,
  169.               "fbxkb %s\nX11 Keyboard switcher\nAuthor: Anatoly Asviyan <aanatoly@users.sf.net>", version);
  170.         /* Destroy the dialog when the user responds to it (e.g. clicks a button) */
  171.         g_signal_connect_swapped (about_dialog, "response",
  172.               G_CALLBACK (gtk_widget_hide),
  173.               about_dialog);
  174.     }
  175.     gtk_widget_show (about_dialog);
  176.     RET();
  177. }
  180. static void
  181. app_menu_exit(GtkWidget *widget, gpointer data)
  182. {
  183.     ENTER;   
  184.     exit(0);
  185.     RET();
  186. }
  189. static void docklet_embedded(GtkWidget *widget, void *data)
  190. {
  191.     ENTER;
  192.     RET();
  193. }
  195. static void docklet_destroyed(GtkWidget *widget, void *data)
  196. {
  197.     ENTER;
  198.     //g_object_unref(G_OBJECT(docklet));
  199.     docklet = NULL;
  200.     g_idle_add(create_all, NULL);
  201.     RET();
  202. }
  205. void docklet_clicked(GtkWidget *button, GdkEventButton *event, void *data)
  206. {
  207.     //GtkWidget *menu;
  208.     ENTER;
  209.     if (event->type != GDK_BUTTON_PRESS)
  210.         RET();
  212.     if (event->button == 1) {
  213.         int no;
  215.         no =  (cur_group + 1) % ngroups;
  216.         DBG("no=%d\n", no);
  217.         XkbLockGroup(dpy, XkbUseCoreKbd, no);
  218.     } else if (event->button == 2) {
  219.         gtk_menu_popup(GTK_MENU(flag_menu), NULL, NULL, NULL, NULL, event->button, event->time);
  220.     } else if (event->button == 3) {
  221.         gtk_menu_popup(GTK_MENU(app_menu), NULL, NULL, NULL, NULL, event->button, event->time);
  222.     }
  223.     RET();
  224. }
  226. static int
  227. docklet_create()
  228. {
  229.     GtkWidget *box;
  230.    
  231.     ENTER;
  232.     docklet = (GtkWidget*)egg_tray_icon_new("fbxkb" );
  233.     box     = gtk_event_box_new();
  234.     image   = gtk_image_new();
  235.     //image   = gtk_image_new();
  236.     g_signal_connect(G_OBJECT(docklet), "embedded", G_CALLBACK(docklet_embedded), NULL);
  237.     g_signal_connect(G_OBJECT(docklet), "destroy", G_CALLBACK(docklet_destroyed), NULL);
  238.     g_signal_connect(G_OBJECT(box), "button-press-event", G_CALLBACK(docklet_clicked), NULL);
  240.     gtk_container_set_border_width(GTK_CONTAINER(box), 0);
  241.    
  242.     gtk_container_add(GTK_CONTAINER(box), image);
  243.     gtk_container_add(GTK_CONTAINER(docklet), box);
  244.     gtk_widget_show_all(GTK_WIDGET(docklet));
  245.    
  246.     RET(1);
  247. }
  250. /******************************************************************
  251. * internal state machine                                         *
  252. ******************************************************************/
  253. static gboolean
  254. my_str_equal (gchar *a, gchar *b)
  255. {
  256.     return  (a[0] == b[0] && a[1] == b[1]);
  257. }
  259.    
  260. static GdkPixbuf *
  261. sym2flag(char *sym)
  262. {
  263.     GdkPixbuf *flag;
  264.     static GString *s = NULL;
  265.     char tmp[3];
  266.    
  267.     ENTER;
  268.     g_assert(sym != NULL && strlen(sym) > 1);
  269.     flag = g_hash_table_lookup(sym2pix, sym);
  270.     if (flag)
  271.         RET(flag);
  273.     if (!s)
  274.         s = g_string_new(IMGPREFIX "tt.png" );
  275.     s->str[s->len-6] = sym[0];
  276.     s->str[s->len-5] = sym[1];
  277.     flag = gdk_pixbuf_new_from_file_at_size(s->str, 24, 24, NULL);
  278.     if (!flag)
  279.         RET(zzflag);
  280.     tmp[0] = sym[0];
  281.     tmp[1] = sym[1];
  282.     tmp[2] = 0;
  283.     g_hash_table_insert(sym2pix, tmp, flag);
  284.     RET(flag);
  285. }
  288. static void
  289. read_kbd_description()
  290. {
  291.     unsigned int mask;
  292.     XkbDescRec *kbd_desc_ptr;
  293.     XkbStateRec xkb_state;
  294.     Atom sym_name_atom;
  295.     int i;
  297.     ENTER;
  298.     // clean up
  299.     cur_group = ngroups = 0;
  300.     for (i = 0; i < XkbNumKbdGroups; i++) {
  301.         g_free(group2info[i].sym);
  302.         g_free(group2info[i].name);
  303.         /*
  304.           if (group2info[i].flag)
  305.             g_object_unref(G_OBJECT(group2info[i].flag));
  306.         */
  307.     }
  308.     bzero(group2info, sizeof(group2info));
  310.     // get kbd info
  311.     mask = XkbControlsMask | XkbServerMapMask;
  312.     kbd_desc_ptr = XkbAllocKeyboard();
  313.     if (!kbd_desc_ptr) {
  314.         ERR("can't alloc kbd info\n" );
  315.         goto out_us;
  316.     }
  317.     kbd_desc_ptr->dpy = dpy;
  318.     if (XkbGetControls(dpy, XkbAllControlsMask, kbd_desc_ptr) != Success) {
  319.         ERR("can't get Xkb controls\n" );
  320.         goto out;
  321.     }
  322.     ngroups = kbd_desc_ptr->ctrls->num_groups;
  323.     if (ngroups < 1)
  324.         goto out;
  325.     if (XkbGetState(dpy, XkbUseCoreKbd, &xkb_state) != Success) {
  326.         ERR("can't get Xkb state\n" );
  327.         goto out;
  328.     }
  329.     cur_group = xkb_state.group;
  330.     DBG("cur_group = %d ngroups = %d\n", cur_group, ngroups);
  331.     g_assert(cur_group < ngroups);
  332.    
  333.     if (XkbGetNames(dpy, XkbSymbolsNameMask, kbd_desc_ptr) != Success) {
  334.         ERR("can't get Xkb symbol description\n" );
  335.         goto out;
  336.     }
  337.     if (XkbGetNames(dpy, XkbGroupNamesMask, kbd_desc_ptr) != Success)
  338.         ERR("Failed to get keyboard description\n" );
  339.     g_assert(kbd_desc_ptr->names);
  340.     sym_name_atom = kbd_desc_ptr->names->symbols;
  342.     // parse kbd info
  343.     if (sym_name_atom != None) {
  344.         char *sym_name, *tmp, *tok;
  345.         int no;
  346.        
  347.         sym_name = XGetAtomName(dpy, sym_name_atom);
  348.         if (!sym_name)
  349.             goto out;
  350.         /* to know how sym_name might look like do this:
  351.          *    % xlsatoms | grep pc
  352.          *    150 pc/pc(pc101)+pc/us+pc/ru(phonetic):2+group(shift_toggle)
  353.          *    470 pc(pc105)+us+ru(phonetic):2+il(phonetic):3+group(shifts_toggle)+group(switch)
  354.          */
  355.         DBG("sym_name=%s\n", sym_name);
  356.         for (tok = strtok(sym_name, "+" ); tok; tok = strtok(NULL, "+" )) {
  357.             DBG("tok=%s\n", tok);
  358.             tmp = strchr(tok, ':');
  359.             if (tmp) {
  360.                 if (sscanf(tmp+1, "%d", &no) != 1)
  361.                     ERR("can't read kbd number\n" );
  362.                 no--;
  363.                 *tmp = 0;
  364.             } else {
  365.                 no = 0;
  366.             }
  367.             for (tmp = tok; isalpha(*tmp); tmp++);
  368.             *tmp = 0;
  370.             DBG("map=%s no=%d\n", tok, no);
  371.             if (!strcmp(tok, "pc" ) || !strcmp(tok, "group" ))
  372.                 continue;
  373.          
  374.             g_assert((no >= 0) && (no < ngroups));
  375.             if (group2info[no].sym != NULL) {
  376.                 ERR("xkb group #%d is already defined\n", no);
  377.             }
  378.             group2info[no].sym = g_strdup(tok);
  379.             group2info[no].flag = sym2flag(tok);
  380.             group2info[no].name = XGetAtomName(dpy, kbd_desc_ptr->names->groups[no]);         
  381.         }
  382.         XFree(sym_name);
  383.     }
  384. out:
  385.     XkbFreeKeyboard(kbd_desc_ptr, 0, True);
  386.     // sanity check: group numbering must be continous
  387.     for (i = 0; (i < XkbNumKbdGroups) && (group2info[i].sym != NULL); i++);
  388.     if (i != ngroups) {
  389.         ERR("kbd group numbering is not continous\n" );
  390.         ERR("run 'xlsatoms | grep pc' to know what hapends\n" );
  391.         exit(1);
  392.     }
  393. out_us:
  394.     //if no groups were defined just add default 'us' kbd group
  395.     if (!ngroups) {
  396.         ngroups = 1;
  397.         cur_group = 0;
  398.         group2info[0].sym = g_strdup("us" );
  399.         group2info[0].flag = sym2flag("us" );
  400.         group2info[0].name = NULL;
  401.         ERR("no kbd groups defined. adding default 'us' group\n" );
  402.     }
  403.     RET();
  404. }
  408. static void update_flag(int no)
  409. {
  410.     kbd_info *k = &group2info[no];
  411.     ENTER;
  412.     g_assert(k != NULL);
  413.     DBG("k->sym=%s\n", k->sym);
  414.     gtk_image_set_from_pixbuf(GTK_IMAGE(image), k->flag);
  415.     RET();
  416. }
  420. static GdkFilterReturn
  421. filter( XEvent *xev, GdkEvent *event, gpointer data)
  422. {
  423.     ENTER;
  424.     if (!active)
  425.         RET(GDK_FILTER_CONTINUE);
  426.  
  427.     if (xev->type ==  xkb_event_type) {
  428.         XkbEvent *xkbev = (XkbEvent *) xev;
  429.         DBG("XkbTypeEvent %d \n", xkbev->any.xkb_type);
  430.         if (xkbev->any.xkb_type == XkbStateNotify) {
  431.             DBG("XkbStateNotify: %d\n", xkbev->state.group);
  432.             cur_group = xkbev->state.group;
  433.             if (cur_group < ngroups)
  434.                 update_flag(cur_group);
  435.         } else if (xkbev->any.xkb_type == XkbNewKeyboardNotify) {       
  436.             DBG("XkbNewKeyboardNotify\n" );
  437.             read_kbd_description();
  438.             //cur_group = 0;
  439.             update_flag(cur_group);
  440.             flag_menu_destroy();
  441.             flag_menu_create(); 
  442.         }
  443.         RET(GDK_FILTER_REMOVE);
  444.     }
  445.     RET(GDK_FILTER_CONTINUE);
  446. }
  448. static int
  449. init()
  450. {
  451.     int dummy;
  453.     ENTER;
  454.     sym2pix  = g_hash_table_new(g_str_hash, (GEqualFunc) my_str_equal);
  455.     dpy = GDK_DISPLAY();
  456.     a_XKB_RULES_NAMES = XInternAtom(dpy, "_XKB_RULES_NAMES", False);
  457.     if (a_XKB_RULES_NAMES == None)
  458.         ERR("_XKB_RULES_NAMES - can't get this atom\n" );
  460.     if (!XkbQueryExtension(dpy, &dummy, &xkb_event_type, &dummy, &dummy, &dummy))
  461.         RET(0);
  462.     DBG("xkb_event_type=%d\n", xkb_event_type);
  463.     XkbSelectEventDetails(dpy, XkbUseCoreKbd, XkbStateNotify,
  464.           XkbAllStateComponentsMask, XkbGroupStateMask);
  465.     gdk_window_add_filter(NULL, (GdkFilterFunc)filter, NULL);
  466.     zzflag = gdk_pixbuf_new_from_file_at_size(IMGPREFIX "zz.png", 24, 24, NULL);
  467.     RET(1);
  468. }
  470. #if 0
  473. static void
  474. app_menu_destroy()
  475. {
  476.     ENTER;
  477.     if (app_menu) {
  478.         gtk_widget_destroy(app_menu);
  479.         app_menu = NULL;
  480.     }
  481.     RET();
  482. }
  484. static void
  485. destroy_all()
  486. {
  487.     active = 0;
  488.     gdk_window_remove_filter(NULL, (GdkFilterFunc)filter, NULL);
  489.     XkbSelectEventDetails(dpy, XkbUseCoreKbd, XkbStateNotify,
  490.           XkbAllStateComponentsMask, 0UL);
  491.     flag_menu_destroy();
  492.     app_menu_destroy();
  493. }
  494. #endif
  496. static int
  497. create_all()
  498. {
  499.     ENTER;
  500.     read_kbd_description();
  501.     docklet_create();
  502.     flag_menu_create();
  503.     app_menu_create();
  504.     update_flag(cur_group);
  505.     active = 1;
  506.     RET(FALSE);// FALSE will remove us from idle func
  507. }
  509. int
  510. main(int argc, char *argv[], char *env[])
  511. {
  512.     ENTER;
  513.     setlocale(LC_CTYPE, "" );
  514.     gtk_set_locale();
  515.     gtk_init(&argc, &argv);
  516.     XSetLocaleModifiers("" );
  517.     XSetErrorHandler((XErrorHandler) Xerror_handler);
  519.     if (!init())
  520.         ERR("can't init. exiting\n" );
  521.     create_all();
  522.     gtk_main ();
  523.     RET(0);
  524. }
  527. /********************************************************************/
  529. void
  530. Xerror_handler(Display * d, XErrorEvent * ev)
  531. {
  532.     char buf[256];
  534.     ENTER;
  535.     XGetErrorText(GDK_DISPLAY(), ev->error_code, buf, 256);
  536.     ERR( "fbxkb : X error: %s\n", buf);
  537.     RET();
  538. }


L'application a lancer est:
 

Code :
  1. XkbConfigMngr


Pas ce chemin à préciser, vu qu'il peut varier d'un système à l'autre et qu'un raccourci vers cette application se trouve dans  le dossier  /usr/bin.
J'en demande beaucoup et sous estime peut-être le travail de codage que ça demande?
... Mais qui ne risque rien n'a rien!
 
Note: Le nom de l'auteur de la modification apparaitrait évidemment, de droit, dans la fenêtre d'information où figure déjà celui de l'auteur du script original[i] (Anatoly Asviyan)
 
Merci de votre aide éventuelle!
 
Cordialement.

mood
Publicité
Posté le 11-04-2011 à 14:10:56  profilanswer
 


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C++

  Modification/amélioration menu contextuel gtk (C++?)

 

Sujets relatifs
Menu Wampouvrir une communication série (usb) en C
Lua et C[C++] Vector class et pointer
[SimpleXML] Modification du contenu[C#] Enregistrer contenu textbox dans un fichier
[JAVA] Menu lié à une animation[RESOLU] Problème compilation Visual C++
[C++] (2) Une histoire de vectorDirectshow et C++
Plus de sujets relatifs à : Modification/amélioration menu contextuel gtk (C++?)

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.149 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR