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