« back to all changes in this revision
Viewing changes to src/tasks.cc
- browse files at revision 63
- compare with another revision
- download diff
- download tarball
- view history from revision 63
- Committer: onli
- Date: 2014-09-09 20:21:36 UTC
- Revision ID: git-v1:4b04d7e2ae4986f186007ad6eca492ee64217a62
minor format cleanup
- files modified:
- src/tasks.cc
added
removed
src/tasks.cc
18
18
19
19
#include "tasks.h"
20
20
21
bool taskInfo::Init(WnckWindow* window)
22
{
23
if (!window)
24
{
25
printf("taskInfo::Init NULL argument!\n");
26
return false;
27
}
21
bool taskInfo::Init (WnckWindow* window) {
22
if (!window) {
23
printf("taskInfo::Init NULL argument!\n");
24
return false;
25
}
28
26
29
27
/*First set the icon. This will work always, as wnck_window_get_icon
30
28
returns a fallbackicon if necessary, the rest may fail*/
31
29
GdkPixbuf* pb = gdk_pixbuf_copy(wnck_window_get_icon (window));
32
if (!pb) {
33
return false;
34
}
30
if (!pb) {
31
return false;
32
}
35
33
36
wxBitmap bmp;
37
bmp.SetPixbuf(pb);
38
if (!bmp.IsOk ()) {
39
return false;
34
wxBitmap bmp;
35
bmp.SetPixbuf(pb);
36
if (!bmp.IsOk ()) {
37
return false;
40
38
}
41
39
this->icon = bmp;
42
40
43
enum { BUFFERSIZE = 1024 };
44
char processName[BUFFERSIZE];
45
/* Since X doesn't rely on pids there's not a clear way to get the
41
enum { BUFFERSIZE = 1024 };
42
char processName[BUFFERSIZE];
43
/* Since X doesn't rely on pids there's not a clear way to get the
46
44
* pid associated with a window. We use 2 different ways to get the
47
45
* pid. None of them is 100% accurate. (aMSN!!!) */
48
46
49
pid = wnck_window_get_pid (window);
47
pid = wnck_window_get_pid (window);
50
48
if (!pid) {
51
WnckApplication *app = wnck_window_get_application (window);
52
pid = wnck_application_get_pid (app);
49
pid = wnck_application_get_pid( wnck_window_get_application(window) );
53
50
}
54
55
if (!pid)
56
{
57
printf("Could not get pid for 0x%x\n",(unsigned int) wnck_window_get_xid (window));
58
return false;
59
}
51
52
if (!pid){
53
printf("Could not get pid for 0x%x\n",(unsigned int) wnck_window_get_xid (window));
54
return false;
55
}
60
56
61
57
if (!tasks_getProcessName(pid, &processName[0], sizeof (processName) -1))
62
{
63
printf("Could not get process name for %d\n", pid);
64
return false;
65
}
66
67
setPath(&processName[0]);
68
setName(&processName[0]);
69
70
return true;
71
58
{
59
printf("Could not get process name for %d\n", pid);
60
return false;
61
}
62
63
setPath(&processName[0]);
64
setName(&processName[0]);
65
66
return true;
72
67
}
73
68
74
bool taskInfo::compareWith (simImage * img)
75
{
76
if (name.IsEmpty() || img->link.IsEmpty())
77
{
78
return false;
79
}
80
81
if (pid == img->pid)
82
{
83
return true;
84
}
85
86
69
bool taskInfo::compareWith (simImage * img) {
70
if (name.IsEmpty() || img->link.IsEmpty()) {
71
return false;
72
}
73
74
if (pid == img->pid) {
75
return true;
76
}
77
78
87
79
wxFileName launcherFN (img->link);
88
80
wxString currLauncher = launcherFN.GetName ();
89
if (launcherFN.HasExt ())
90
{
91
currLauncher = currLauncher + _T (".") + launcherFN.GetExt ();
92
}
93
94
95
if (currLauncher.Len () > name.Len ()
96
&& currLauncher.StartsWith (name))
97
return true;
98
99
if (name.StartsWith (currLauncher))
100
return true;
101
102
if (currLauncher.CmpNoCase (name) == 0)
103
return true;
104
81
if (launcherFN.HasExt ()) {
82
currLauncher = currLauncher + _T (".") + launcherFN.GetExt ();
83
}
84
85
86
if ( (currLauncher.Len() > name.Len() && currLauncher.StartsWith(name))
87
|| name.StartsWith(currLauncher)
88
|| currLauncher.CmpNoCase(name) == 0) {
89
return true;
90
}
91
105
92
return false;
106
107
93
}
108
94
109
void taskInfo::setName (char *processName)
110
{
95
void taskInfo::setName (char *processName) {
111
96
wxString s = wxString ((const char *) processName, wxConvUTF8);
112
97
wxFileName programFN (s);
113
98
name = programFN.GetName ();
114
if (programFN.HasExt ())
115
{
99
if (programFN.HasExt ()) {
116
100
name = name + _T (".") + programFN.GetExt ();
117
101
}
118
102
}
119
103
120
void taskInfo::setPath (char *processName)
121
{
104
void taskInfo::setPath (char *processName) {
122
105
path = wxString ((const char *) processName, wxConvUTF8);
123
106
}
124
107
125
108
126
int
127
tasks_getProcessName (unsigned int pid, char *target_name, int size_targetname)
128
{
109
int tasks_getProcessName (unsigned int pid, char *target_name, int size_targetname) {
129
110
int target_link;
130
111
char dir_name[PATH_MAX];
131
112
132
sprintf (dir_name, "/proc/%d/exe", pid);
113
sprintf(dir_name, "/proc/%d/exe", pid);
133
114
134
115
/* Getting the target of the exe ie to which binary it points to */
135
target_link = readlink (dir_name, target_name, size_targetname);
116
target_link = readlink(dir_name, target_name, size_targetname);
136
117
137
118
if (target_link <= 0) {
138
119
return false;
143
124
return true;
144
125
}
145
126
146
static void tasks_window_closed (WnckScreen *screen, WnckWindow *window,callbackArgs* ca ) {
127
static void tasks_window_closed (WnckScreen *screen, WnckWindow *window,callbackArgs* ca) {
147
128
148
if (!WNCK_IS_WINDOW (window) || wnck_window_is_skip_tasklist (window)) {
149
return;
129
if (!WNCK_IS_WINDOW (window) || wnck_window_is_skip_tasklist (window)) {
130
return;
150
131
}
151
132
152
ImagesArray * ImagesList = ca->ImagesList;
133
ImagesArray * ImagesList = ca->ImagesList;
153
134
if (!ImagesList) {
154
135
return;
155
136
}
156
157
for (unsigned int i = 0; i < ImagesList->GetCount (); i++)
158
{
159
simImage *img = (*ImagesList)[i];
137
138
for (unsigned int i = 0; i < ImagesList->GetCount (); i++) {
139
simImage *img = (*ImagesList)[i];
160
140
161
if (img->hasWindow(window))
162
{
163
img->removeWindow(window);
164
if (img->task && img->windowCount() == 0)
165
{
166
delete img;
167
ImagesList->RemoveAt (i);
168
//wxGetApp ().reposition ();
169
wxGetApp ().updateSize ();
170
} else if (img->windowCount() == 0) {
141
if (img->hasWindow(window)) {
142
img->removeWindow(window);
143
if (img->task && img->windowCount() == 0) {
144
delete img;
145
ImagesList->RemoveAt (i);
146
wxGetApp().updateSize();
147
} else if (img->windowCount() == 0) {
171
148
// we need to fall back to the default image, if a starter
172
149
img->loadImage(img->img_link);
173
150
}
176
153
taskInfo ti;
177
154
ti.Init(img->getWindow());
178
155
img->img = ti.icon.ConvertToImage();
179
180
156
}
181
wxGetApp().frame->appSize = FirstPosition(ca->settings, ImagesList);
182
wxGetApp().updateSize();
183
return;
184
}
185
}
186
157
158
wxGetApp().frame->appSize = FirstPosition(ca->settings, ImagesList);
159
wxGetApp().updateSize();
160
return;
161
}
162
}
187
163
}
188
164
189
static void tasks_window_opened (WnckScreen *screen, WnckWindow *window, callbackArgs* ca )
190
{
191
if (!ca || !ca->ImagesList)
192
{
193
printf("tasks_window_opened NULL ARGUMENT!\n");
194
return;
195
}
196
197
ImagesArray * ImagesList = ca->ImagesList;
198
simSettings settings = ca->settings;
199
200
if (wnck_window_is_skip_tasklist (window))
201
return;
202
203
taskInfo ti;
204
ti.Init(window);
205
206
unsigned int i;
207
for (i = 0; i < ImagesList->GetCount (); i++)
208
{
209
simImage *img = (*ImagesList)[i];
210
211
if (ti.compareWith (img))
212
{
213
img->addWindow(window);
214
img->pid = ti.pid;
165
static void tasks_window_opened (WnckScreen *screen, WnckWindow *window, callbackArgs* ca) {
166
if (!ca || !ca->ImagesList) {
167
printf("tasks_window_opened NULL ARGUMENT!\n");
168
return;
169
}
170
171
if (wnck_window_is_skip_tasklist (window)) {
172
return;
173
}
174
175
ImagesArray * ImagesList = ca->ImagesList;
176
simSettings settings = ca->settings;
177
taskInfo ti;
178
ti.Init(window);
179
180
unsigned int i;
181
for (i = 0; i < ImagesList->GetCount (); i++) {
182
simImage *img = (*ImagesList)[i];
183
184
if (ti.compareWith (img)) {
185
img->addWindow(window);
186
img->pid = ti.pid;
215
187
// refresh the icon, cause sometimes the splash-screen has not
216
188
// a valid icon, but the program does
217
189
img->img = ti.icon.ConvertToImage();
218
return;
219
}
220
}
221
222
if (i == ImagesList->GetCount())
223
{
224
tasks_addNewImage(window, ImagesList, settings, ti);
225
}
190
return;
191
}
192
}
193
194
if (i == ImagesList->GetCount()) {
195
tasks_addNewImage(window, ImagesList, settings, ti);
196
}
226
197
}
227
198
228
void tasks_window_background_change (WnckScreen *screen, WnckWindow *window, callbackArgs* ca )
229
{
199
void tasks_window_background_change (WnckScreen *screen, WnckWindow *window, callbackArgs* ca) {
230
200
wxBitmap* backImage = getRootWallpaper();
231
201
wxGetApp().SetWallpaper(backImage);
232
202
}
233
203
234
void tasks_track_active_window (WnckScreen *screen, WnckWindow *window, callbackArgs* ca ) {
235
if (!WNCK_IS_WINDOW (window))
236
return;
237
238
239
ImagesArray * ImagesList = ca->ImagesList;
240
if (!ImagesList)
241
{
242
return;
243
}
244
if (wnck_window_is_skip_tasklist (window)) {
204
void tasks_track_active_window (WnckScreen *screen, WnckWindow *window, callbackArgs* ca) {
205
if (!WNCK_IS_WINDOW (window)) {
206
return;
207
}
208
209
ImagesArray * ImagesList = ca->ImagesList;
210
if (!ImagesList) {
211
return;
212
}
213
214
if (wnck_window_is_skip_tasklist (window)) {
245
215
// note that this also catches simdock itself
246
return;
247
}
248
249
unsigned int i;
250
for (i = 0; i < ImagesList->GetCount (); i++)
251
{
252
simImage *img = (*ImagesList)[i];
253
254
if (img->hasWindow(window))
255
{
256
img->active = true;
257
} else {
258
img->active = false;
259
}
260
}
261
262
}
263
264
265
void tasks_register_signals(ImagesArray * ImagesList,simSettings settings)
266
{
267
callbackArgs* ca = new callbackArgs();
268
ca->ImagesList = ImagesList;
269
ca->settings = settings;
270
271
WnckScreen *defaultScreen = wnck_screen_get_default ();
272
g_signal_connect (G_OBJECT(defaultScreen), "window_opened",
273
G_CALLBACK (tasks_window_opened),
274
ca);
275
276
g_signal_connect (G_OBJECT(defaultScreen), "background-changed",
277
G_CALLBACK (tasks_window_background_change),
278
ca);
279
280
g_signal_connect (G_OBJECT(defaultScreen), "window_closed",
281
G_CALLBACK(tasks_window_closed),
282
ca);
283
284
g_signal_connect (G_OBJECT(defaultScreen), "active-window-changed",
285
G_CALLBACK(tasks_track_active_window),
286
ca);
287
}
288
289
290
void tasks_addNewImage(WnckWindow *window, ImagesArray* ImagesList, simSettings settings,const taskInfo& ti)
291
{
292
if (!window || !ImagesList)
293
{
294
printf("addNewImage::Null argument\n");
295
return;
296
}
297
298
299
simImage *si = new simImage (ti.icon.ConvertToImage (), _T (" "), ti.name ,
300
ti.name, _T (" "), 1);
301
302
si->addWindow(window);
303
si->pid = ti.pid;
304
si->w = settings.ICONW;
305
si->h = settings.ICONH;
306
si->y = (settings.MAXSIZE + settings.BOTTOM_BORDER) - settings.ICONH - settings.BOTTOM_BORDER;
307
si->task = true;
308
si->blurStatus = STATUS_NONE;
309
si->blur = 0;
310
ImagesList->Add (si);
311
wxGetApp().frame->appSize = FirstPosition(settings, ImagesList);
312
wxGetApp().updateSize();
313
}
314
315
void
316
tasks_fillList (ImagesArray * ImagesList, simSettings settings)
317
{
318
WnckScreen *defaultScreen = wnck_screen_get_default ();
319
wnck_screen_force_update (defaultScreen);
320
GList *windowz = wnck_screen_get_windows (defaultScreen);
321
322
WnckWindow *curr_Win=NULL;
323
int l = g_list_length (windowz);
324
325
//printf ("%d windows found\n", l);
326
327
for (int i = 0; i < l; i++)
328
{
329
curr_Win = (WnckWindow *) g_list_nth_data (windowz, i);
330
if (!curr_Win || wnck_window_is_skip_tasklist (curr_Win))
331
continue;
332
333
334
taskInfo ti;
335
bool init_ok = ti.Init(curr_Win);
336
337
if (init_ok)
338
{
339
unsigned int i;
340
for (i = 0; i < ImagesList->GetCount (); i++)
341
{
342
simImage *img = (*ImagesList)[i];
343
if (ti.compareWith (img))
344
{
345
img->addWindow(curr_Win);
346
img->pid = ti.pid;
347
break;
348
}
349
}
350
if (i == ImagesList->GetCount())
351
{
352
tasks_addNewImage(curr_Win, ImagesList, settings, ti);
353
}
354
}
355
else
356
{
357
tasks_addNewImage(curr_Win, ImagesList, settings, ti);
358
}
359
360
}
361
}
362
363
364
Window
365
tasks_getFromName (const char *name, int nameLength)
366
{
367
368
if (!name)
369
return 0;
370
371
WnckScreen *defaultScreen = wnck_screen_get_default ();
372
wnck_screen_force_update (defaultScreen);
373
GList *windowz = wnck_screen_get_windows (defaultScreen);
374
375
WnckWindow *curr_Win;
376
int l = g_list_length (windowz);
377
378
for (int i = 0; i < l; i++)
379
{
380
curr_Win = (WnckWindow *) g_list_nth_data (windowz, i);
381
WnckApplication *app = wnck_window_get_application (curr_Win);
382
if (strncmp (name, wnck_application_get_name (app), nameLength) == 0)
383
return wnck_window_get_xid (curr_Win);
384
385
}
386
387
return 0;
388
}
389
390
Window
391
tasks_getFromWindowName (const char *name, int nameLength)
392
{
393
394
if (!name)
395
return 0;
396
397
WnckScreen *defaultScreen = wnck_screen_get_default ();
398
wnck_screen_force_update (defaultScreen);
399
GList *windowz = wnck_screen_get_windows (defaultScreen);
400
401
WnckWindow *curr_Win;
402
int l = g_list_length (windowz);
403
404
for (int i = 0; i < l; i++)
405
{
406
curr_Win = (WnckWindow *) g_list_nth_data (windowz, i);
407
printf("%s \n", wnck_window_get_name (curr_Win));
408
if (strncmp (name, wnck_window_get_name (curr_Win), nameLength) == 0)
409
return wnck_window_get_xid (curr_Win);
410
411
}
412
413
return 0;
414
}
415
416
void tasks_raise (WnckWindow* win)
417
{
418
if(!win)
419
return;
420
421
if (wnck_window_is_minimized(win))
422
{
423
wnck_window_unminimize(win, gtk_get_current_event_time());
424
}
425
wnck_window_activate(win, gtk_get_current_event_time());
426
}
427
428
void tasks_minimize (WnckWindow* win)
429
{
430
if(!win)
431
return;
432
216
return;
217
}
218
219
for (unsigned int i = 0; i < ImagesList->GetCount (); i++) {
220
simImage *img = (*ImagesList)[i];
221
img->active = img->hasWindow(window);
222
}
223
}
224
225
226
void tasks_register_signals(ImagesArray * ImagesList,simSettings settings) {
227
callbackArgs* ca = new callbackArgs();
228
ca->ImagesList = ImagesList;
229
ca->settings = settings;
230
231
WnckScreen *defaultScreen = wnck_screen_get_default ();
232
g_signal_connect (G_OBJECT(defaultScreen), "window_opened",
233
G_CALLBACK (tasks_window_opened),
234
ca);
235
236
g_signal_connect (G_OBJECT(defaultScreen), "background-changed",
237
G_CALLBACK (tasks_window_background_change),
238
ca);
239
240
g_signal_connect (G_OBJECT(defaultScreen), "window_closed",
241
G_CALLBACK(tasks_window_closed),
242
ca);
243
244
g_signal_connect (G_OBJECT(defaultScreen), "active-window-changed",
245
G_CALLBACK(tasks_track_active_window),
246
ca);
247
}
248
249
250
void tasks_addNewImage(WnckWindow *window, ImagesArray* ImagesList, simSettings settings,const taskInfo& ti) {
251
if (!window || !ImagesList) {
252
printf("addNewImage::Null argument\n");
253
return;
254
}
255
256
257
simImage *si = new simImage (ti.icon.ConvertToImage (), _T (" "), ti.name, ti.name, _T (" "), 1);
258
259
si->addWindow(window);
260
si->pid = ti.pid;
261
si->w = settings.ICONW;
262
si->h = settings.ICONH;
263
si->y = (settings.MAXSIZE + settings.BOTTOM_BORDER) - settings.ICONH - settings.BOTTOM_BORDER;
264
si->task = true;
265
si->blurStatus = STATUS_NONE;
266
si->blur = 0;
267
ImagesList->Add(si);
268
wxGetApp().frame->appSize = FirstPosition(settings, ImagesList);
269
wxGetApp().updateSize();
270
}
271
272
void tasks_fillList (ImagesArray * ImagesList, simSettings settings) {
273
WnckScreen *defaultScreen = wnck_screen_get_default ();
274
wnck_screen_force_update (defaultScreen);
275
GList *windowz = wnck_screen_get_windows (defaultScreen);
276
277
WnckWindow *curr_Win=NULL;
278
int l = g_list_length (windowz);
279
280
//printf ("%d windows found\n", l);
281
282
for (int i = 0; i < l; i++) {
283
curr_Win = (WnckWindow *) g_list_nth_data (windowz, i);
284
if (!curr_Win || wnck_window_is_skip_tasklist (curr_Win)) {
285
continue;
286
}
287
288
taskInfo ti;
289
bool init_ok = ti.Init(curr_Win);
290
291
if (init_ok) {
292
unsigned int i;
293
for (i = 0; i < ImagesList->GetCount (); i++) {
294
simImage *img = (*ImagesList)[i];
295
if (ti.compareWith (img)) {
296
img->addWindow(curr_Win);
297
img->pid = ti.pid;
298
break;
299
}
300
}
301
if (i == ImagesList->GetCount()) {
302
tasks_addNewImage(curr_Win, ImagesList, settings, ti);
303
}
304
} else {
305
tasks_addNewImage(curr_Win, ImagesList, settings, ti);
306
}
307
}
308
}
309
310
311
Window tasks_getFromName (const char *name, int nameLength) {
312
313
if (!name) {
314
return 0;
315
}
316
317
WnckScreen *defaultScreen = wnck_screen_get_default ();
318
wnck_screen_force_update (defaultScreen);
319
GList *windowz = wnck_screen_get_windows (defaultScreen);
320
321
WnckWindow *curr_Win;
322
int l = g_list_length (windowz);
323
324
for (int i = 0; i < l; i++) {
325
curr_Win = (WnckWindow *) g_list_nth_data (windowz, i);
326
WnckApplication *app = wnck_window_get_application (curr_Win);
327
if (strncmp (name, wnck_application_get_name (app), nameLength) == 0) {
328
return wnck_window_get_xid (curr_Win);
329
}
330
}
331
return 0;
332
}
333
334
Window tasks_getFromWindowName (const char *name, int nameLength) {
335
336
if (!name) {
337
return 0;
338
}
339
340
WnckScreen *defaultScreen = wnck_screen_get_default ();
341
wnck_screen_force_update (defaultScreen);
342
GList *windowz = wnck_screen_get_windows (defaultScreen);
343
344
WnckWindow *curr_Win;
345
int l = g_list_length (windowz);
346
347
for (int i = 0; i < l; i++) {
348
curr_Win = (WnckWindow *) g_list_nth_data (windowz, i);
349
printf("%s \n", wnck_window_get_name (curr_Win));
350
if (strncmp (name, wnck_window_get_name (curr_Win), nameLength) == 0) {
351
return wnck_window_get_xid (curr_Win);
352
}
353
}
354
return 0;
355
}
356
357
void tasks_raise (WnckWindow* win) {
358
if (!win) {
359
return;
360
}
361
362
wnck_window_unminimize(win, gtk_get_current_event_time());
363
wnck_window_activate(win, gtk_get_current_event_time());
364
}
365
366
void tasks_minimize (WnckWindow* win) {
367
if (!win) {
368
return;
369
}
433
370
wnck_window_minimize(win);
434
371
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1