Discussion :

[robux]

Hello chersss codersss!!

J'ai une application et j'ai besoin de savoir sous quel bureau l'utilisateur travaille KDE? Gnome? etc...?

Comment detecter le bueau utilisé?

Merci

Robux

[Davidbrcz]

Tu récupre la liste des processus en cours et tu teste si dedans tu trouve des processus t'indiquant un bureau particulier.

[robux]

hello,

peux tu detailler stp...?
Comment recuperer cette fameuse liste des processus en cours?

Et surtout quel processus ce refaire au bureau? il a un nom?

Est ce que il y a d'autre moyen en plus de celui là?

Merci

robux

[gorgonite]

un truc ressemblant à cela... (pas vérifié )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
for wm in {"gnome","kde","icewm",...}
do
   TMP=`ps -aux | grep $wm | wc -l`
   if [ $TMP -gt 0 ]
   then
      echo interface graphique : $wm
   fi
done

[robux]

ça va un ptit peu trop vite...Enfin même si je comprend l'algo je ne vois pas comment l'utiliser...

Où je mets ça? : J'ai un projet cpp qui definit une GUI et donnera un version release pour un logiciel alors ou je mets ça?
J'ai besoin un moment dans mon code cpp de connaitre le bureau mais ça m'a l'air d'être du shell ou du code de makefile si je me trompe pas?

Merci
robux

[Davidbrcz]

Il est vrai que c'est du bash.
Mais ca doit être transposable en C++ sans trop de problème.

Edit : toujours pas testé mais je changerai un peu le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
for wm in {"[g]nome*","[k]de*","[i]cewm*",...}
do
   TMP=`ps -aux | grep $wm | wc -l`
   if [ $TMP -gt 0 ]
   then
      echo interface graphique : $wm
   fi
done

[robux]

Il est vrai que c'est du bash.
Mais ca doit être transposable en C++ sans trop de problème.

Edit : toujours pas testé mais je changerai un peu le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
for wm in {"[g]nome*","[k]de*","[i]cewm*",...}
do
   TMP=`ps -aux | grep $wm | wc -l`
   if [ $TMP -gt 0 ]
   then
      echo interface graphique : $wm
   fi
done

Bon Salut et Merci à vous deux mais c'est encore moi

Peut tu me dire :

1/ Comment transposer "wm" ?
2/ Est ce que TMP correspond à std::system( "...");?
3/ A quoi me servirait de faire un print dans mon code si il est destiné à une version release?
-> Par contre comment recuperer la variable bureau?

Thanks!
Robux

[gorgonite]

ben tu peux lister tous les fichiers dont le nom est purement numerique contenus dans le répertoire dans /proc

[robux]

j'y connais rien en architecture et system linux. j'ai juste fait mon code cpp et mon appli.
j'ai besoin de connaitre le bureau. je suis ok pour transposer le code shell j'étais en train de le faire. Gorgonite tu peux répondre au post juste au dessus au lieu de me proposer un autre truc STP.

Merci les gars

robux!

[Davidbrcz]

Ou alors , tu va dans /proc et tu liste tous le fichier stat des sous dossier.
Tu en extrait la 2eme colone|1er ligne qui correspond a la commande lancé.
Et tu compare avec ta liste de "processus type" pour chaque WM.

[robux]

J' Y COMPRENDS RIEN!!!

Je l'écris ou le code bash dans mon makefile? ou ça??
si je le fais en cpp je l'écris ou dans mon main???
Bref c'est pas clair je suis débutant sur linux (à peine un mois...) Je comprends pas ce que vous dites alors faites un effort s'il vous plait.
Merci qd même!

Robux

[gorgonite]

étudies ce code...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <dirent.h>
 #include <errno.h>
 
 //Prototypes
 DIR *opendir (const char *filename);
 struct dirent *readdir (DIR * dirp);
 int closedir (DIR * dirp);
 
 //ACTION SUR FICHIER ET REPERTOIRE
 
 //Action sur un repertoire
 void action_dir (const char *dir)
     {printf("%s/\n", dir);}
 
 //action sur un rep avt parcour de son contenu
 void action_dir_pre (const char *root, const char *dir)
     {printf("\n-> %s/%s/\n", root, dir);}
 
 //action sur un re apres parcour de son contenu
 void action_dir_post (const char *root, const char *dir)
     {}
 
 //action sur un fichier
 void action_file (const char *file)
     {printf("%s\n", file);}
 
 //DEFINITION D'UNE LISTE CHAINEE SIMPLE
 typedef struct slist_t
    {
      char *name;
      int is_dir;
      struct slist_t *next;
    }slist_t;
 
 //PARCOURS RECURSIF DES REPERTOIRES
 int recursive_dir (char *root, char *MP3)
    {
      slist_t *names = NULL;
      slist_t *sl;
 
      DIR *FD;
      struct dirent *f;
      int cwdlen = 32;
      char *cwd;
      char *new_root;
 
      if (NULL ==(cwd=malloc(cwdlen* sizeof *cwd)))
        {
          fprintf(stderr, "probleme avec malloc\n" );
          exit(EXIT_FAILURE);
        }
 
      //Concatenation new_root="root/MP3"
      if (root)
        {
          int rootlen = strlen (root);
          int dirnamelen = strlen ("MP3" );
          if (NULL == (new_root = malloc((rootlen + dirnamelen +2) * sizeof *new_root)))
            {
              fprintf (stderr, "probleme avec malloc\n" );
              exit (EXIT_FAILURE);
            }
          memcpy (new_root, root, rootlen);
          new_root[rootlen] = '/';
          memcpy (new_root + rootlen + 1, MP3, dirnamelen);
          new_root[rootlen + dirnamelen + 1] = '\0';
        }
      else
          new_root = strdup ("MP3" );
 
      //obtention du repertoire courant
      while (NULL == (cwd = getcwd (cwd, cwdlen)))
         {
           if (ERANGE != errno)
             {
               fprintf (stderr, "probleme avec getcwd (errno= '%s')\n",strerror (errno));
               exit (EXIT_FAILURE);
             }
           cwdlen += 32;
           cwd = realloc (cwd, cwdlen * sizeof *cwd);
         }
      chdir ("MP3" );
 
      //Remplissage de la liste avec les noms des fichiers du rep courant
      if (NULL == (FD = opendir ("." )))
        {
          fprintf (stderr, "opendir() impossible\n" );
          return (-1);
        }
      sl = names;
      while ((f = readdir (FD)))
        {
          struct stat st;
          slist_t *n;
          if (!strcmp (f->d_name, "." ))
              continue;
          if (!strcmp (f->d_name, ".." ))
              continue;
          if (stat (f->d_name, &st))
              continue;
          if (NULL == (n = malloc (sizeof *n)))
             {
               fprintf (stderr, "Plus assez de memoire\n" );
               exit (EXIT_FAILURE);
             }
          n->name = strdup (f->d_name);
          if (S_ISDIR (st.st_mode))
             n->is_dir = 1;
          else
             n->is_dir = 0;
          n->next = NULL;
          if (sl)
            {
              sl->next = n;
              sl = n;
            }
          else
            {
              names = n;
              sl = n;
            }
         }
       closedir (FD);
 
       //parcourt les fichiers et repertoire pour action
       for (sl= names; sl; sl = sl->next)
          {
            if (sl->is_dir)
              action_dir (sl->name);
            else
              action_file (sl->name);
          }
 
       //parcourt les fichiers et rep pr actoin avt traitement recursif et apres traitement recursif
 /*      for (sl = names; sl; sl = sl->next)
          {
            if (sl->is_dir)
               {
                 action_dir_pre (new_root, sl->name);
                 recursive_dir (new_root, sl->name);
                 action_dir_post (new_root, sl->name);
               }
          }
 */
       //Nettoyage
       free (new_root);
       while (names)
         {
           slist_t *prev;
           free (names->name);
           prev = names;
           names = names->next;
           free (prev);
         }
       chdir (cwd);
       free (cwd);
       return(0);
    }
 
 int main (int argc, char **argv)
     {
      if (argc >= 1)
           recursive_dir (NULL, argv[1]);
       exit (0);
     }