← Back to branch summary

~foxtrotgps-team/foxtrotgps/trunk

« back to all changes in this revision

Viewing changes to src/friends.c

  • Committer: Joshua Judson Rosen
  • Author(s): Marcus Bauer
  • Date: 2010-08-08 22:28:45 UTC
  • Revision ID: rozzin@geekspace.com-20100808222845-86w25l3qq5nlf5ib
Perl scripts to convert track-logs from tangoGPS format to GPX and OSM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/friends.c
1
1
 
2
 
#include "callbacks.h"
 
2
 
3
3
#include "friends.h"
4
4
#include "globals.h"
5
5
#include "converter.h"
17
17
#include <gtk/gtk.h>
18
18
 
19
19
#include <curl/curl.h>
 
20
#include <curl/types.h>
20
21
#include <curl/easy.h>
21
22
 
22
23
 
61
62
static size_t
62
63
cb_write_to_mem(void *ptr, size_t size, size_t nmemb, void *data)
63
64
{
64
 
        size_t realsize         = size * nmemb;
65
 
        struct mem_struct *mem  = (struct mem_struct *)data;
66
 
 
 
65
        size_t realsize = size * nmemb;
 
66
        struct mem_struct *mem = (struct mem_struct *)data;
 
67
        
67
68
        mem->memory = (char *)g_realloc(mem->memory, mem->size + realsize + 1);
68
 
 
 
69
        
69
70
        if (mem->memory)
70
71
        {
71
72
                memcpy(&(mem->memory[mem->size]), ptr, realsize);
98
99
 
99
100
gboolean
100
101
update_position()
101
 
{
 
102
{               
102
103
        GtkLabel *label_msg;
103
104
        label_msg = (GtkLabel *)lookup_widget(window1, "label51");
104
 
        gtk_label_set_label (label_msg, _("Connecting..."));
 
105
        gtk_label_set_label(label_msg, "Connecting...");
105
106
 
106
 
#if GLIB_CHECK_VERSION(2,34,0)
107
 
        if (!g_thread_new("friends thread", &update_position_thread, (gpointer) NULL) != 0)
108
 
#else
109
107
        if (!g_thread_create(&update_position_thread, NULL, FALSE, NULL) != 0)
110
 
#endif
111
108
                g_warning("### can't create friend thread\n");
112
109
 
113
 
        return TRUE;
 
110
        return TRUE;    
114
111
}
115
 
 
 
112
        
116
113
void *
117
114
update_position_thread(void *ptr)
118
115
{
119
116
        int i=1;
120
 
 
 
117
        
121
118
        GtkEntry *nick, *pass, *email, *msg;
122
119
        GtkLabel *label_msg;
123
 
        const gchar *n, *p, *e, *m;
 
120
        const gchar *n, *p, *e, *m;     
124
121
        gchar *ff_mode;
125
122
        static gchar lat[64], lon[64], mode[64];
126
123
        static gchar alt[16] = "0", speed[16] = "0", head[16]="0";
127
 
 
128
 
 
 
124
        
 
125
        
129
126
        gchar **user_data_sets;
130
127
        long int response_code;
131
 
 
 
128
        
132
129
        CURL *curl_handle;
133
 
 
 
130
        
134
131
        struct curl_httppost *formdata=NULL;
135
132
        struct curl_httppost *lastptr=NULL;
136
 
 
 
133
                
137
134
        struct mem_struct chunk;
138
 
 
 
135
        
139
136
        chunk.memory=NULL;
140
137
        chunk.size = 0;
141
 
 
 
138
        
142
139
 
143
140
gdk_threads_enter();
144
 
 
 
141
        
145
142
        label_msg = (GtkLabel *)lookup_widget(window1, "label51");
146
143
 
147
 
 
 
144
        
148
145
        nick  = (GtkEntry *)lookup_widget(window1, "entry7");
149
146
        pass  = (GtkEntry *)lookup_widget(window1, "entry8");
150
147
        email = (GtkEntry *)lookup_widget(window1, "entry9");
151
148
        msg   = (GtkEntry *)lookup_widget(window1, "entry29");
152
149
 
153
150
        switch (global_ff_mode) {
154
 
        case PRIVATE_MODE:
 
151
        case PRIVATE_MODE: 
155
152
                ff_mode = g_strdup("private");
156
153
                break;
157
154
        case FRIEND_MODE:
163
160
        default:
164
161
                ff_mode = g_strdup("");
165
162
        }
166
 
 
 
163
        
167
164
        n = gtk_entry_get_text(nick);
168
165
        p = gtk_entry_get_text(pass);
169
166
        e = gtk_entry_get_text(email);
170
167
        m = gtk_entry_get_text(msg);
171
168
 
172
169
gdk_threads_leave();
173
 
 
174
 
 
 
170
        
 
171
        
175
172
        if (global_myposition.lat && global_myposition.lon)
176
173
        {
177
174
                g_sprintf(lat, "%f", global_myposition.lat);
178
175
                g_sprintf(lon, "%f", global_myposition.lon);
179
 
                g_sprintf(mode, "%s|%dx%d", "man", global_drawingarea_width, global_drawingarea_height);
 
176
                g_sprintf(mode, "%s|%dx%d", "man", global_drawingarea_width, global_drawingarea_height);                
180
177
        }
181
178
        else if (gpsdata && gpsdata->fix.latitude !=0)
182
179
        {
183
180
                g_sprintf(lat, "%f", gpsdata->fix.latitude);
184
181
                g_sprintf(lon, "%f", gpsdata->fix.longitude);
185
 
                g_sprintf(mode, "%s|%dx%d", "gps", global_drawingarea_width, global_drawingarea_height);
 
182
                g_sprintf(mode, "%s|%dx%d", "gps", global_drawingarea_width, global_drawingarea_height);                
186
183
        }
187
184
        else
188
185
        {
189
186
                float tmplat, tmplon;
190
 
 
 
187
                
191
188
                tmplat = rad2deg( pixel2lat(global_zoom, global_y+global_drawingarea_height/2) );
192
189
                tmplon = rad2deg( pixel2lon(global_zoom, global_x+global_drawingarea_width/2) );
193
190
                g_sprintf(lat, "%f", tmplat);
194
191
                g_sprintf(lon, "%f", tmplon);
195
 
                g_sprintf(mode, "%s|%dx%d", "atm", global_drawingarea_width, global_drawingarea_height);
 
192
                g_sprintf(mode, "%s|%dx%d", "atm", global_drawingarea_width, global_drawingarea_height);                
196
193
        }
197
 
 
198
 
 
 
194
        
 
195
        
199
196
        if(gpsdata)
200
197
        {
201
198
                g_snprintf(alt, 16, "%.1f", gpsdata->fix.altitude);
202
199
                g_snprintf(head, 16, "%.1f", gpsdata->fix.heading);
203
200
                g_snprintf(speed, 16, "%.1f", gpsdata->fix.speed);
204
201
        }
205
 
 
 
202
        
206
203
        curl_global_init(CURL_GLOBAL_ALL);
207
204
 
208
205
        curl_formadd(&formdata,
209
 
                     &lastptr,
210
 
                     CURLFORM_COPYNAME, "lat",
211
 
                     CURLFORM_COPYCONTENTS, lat,
212
 
                     CURLFORM_END);
213
 
 
214
 
        curl_formadd(&formdata,
215
 
                     &lastptr,
216
 
                     CURLFORM_COPYNAME, "lon",
217
 
                     CURLFORM_COPYCONTENTS, lon,
218
 
                     CURLFORM_END);
219
 
 
220
 
        curl_formadd(&formdata,
221
 
                     &lastptr,
222
 
                     CURLFORM_COPYNAME, "alt",
223
 
                     CURLFORM_COPYCONTENTS, alt,
224
 
                     CURLFORM_END);
225
 
 
226
 
        curl_formadd(&formdata,
227
 
                     &lastptr,
228
 
                     CURLFORM_COPYNAME, "head",
229
 
                     CURLFORM_COPYCONTENTS, head,
230
 
                     CURLFORM_END);
231
 
 
232
 
        curl_formadd(&formdata,
233
 
                     &lastptr,
234
 
                     CURLFORM_COPYNAME, "speed",
235
 
                     CURLFORM_COPYCONTENTS, speed,
236
 
                     CURLFORM_END);
237
 
 
238
 
        curl_formadd(&formdata,
239
 
                     &lastptr,
240
 
                     CURLFORM_COPYNAME, "mode",
241
 
                     CURLFORM_COPYCONTENTS, mode,
242
 
                     CURLFORM_END);
243
 
 
244
 
        curl_formadd(&formdata,
245
 
                     &lastptr,
246
 
                     CURLFORM_COPYNAME, "ff_mode",
247
 
                     CURLFORM_COPYCONTENTS, ff_mode,
248
 
                     CURLFORM_END);
249
 
 
250
 
        curl_formadd(&formdata,
251
 
                     &lastptr,
252
 
                     CURLFORM_COPYNAME, "nick",
253
 
                     CURLFORM_COPYCONTENTS, n,
254
 
                     CURLFORM_END);
255
 
 
256
 
        curl_formadd(&formdata,
257
 
                     &lastptr,
258
 
                     CURLFORM_COPYNAME, "pass",
259
 
                     CURLFORM_COPYCONTENTS, p,
260
 
                     CURLFORM_END);
261
 
 
262
 
        curl_formadd(&formdata,
263
 
                     &lastptr,
264
 
                     CURLFORM_COPYNAME, "msg",
265
 
                     CURLFORM_COPYCONTENTS, m,
266
 
                     CURLFORM_END);
267
 
 
268
 
 
 
206
               &lastptr,
 
207
               CURLFORM_COPYNAME, "lat",
 
208
               CURLFORM_COPYCONTENTS, lat,
 
209
               CURLFORM_END);
 
210
 
 
211
        curl_formadd(&formdata,
 
212
               &lastptr,
 
213
               CURLFORM_COPYNAME, "lon",
 
214
               CURLFORM_COPYCONTENTS, lon,
 
215
               CURLFORM_END);
 
216
        
 
217
        curl_formadd(&formdata,
 
218
               &lastptr,
 
219
               CURLFORM_COPYNAME, "alt",
 
220
               CURLFORM_COPYCONTENTS, alt,
 
221
               CURLFORM_END);
 
222
 
 
223
        curl_formadd(&formdata,
 
224
               &lastptr,
 
225
               CURLFORM_COPYNAME, "head",
 
226
               CURLFORM_COPYCONTENTS, head,
 
227
               CURLFORM_END);
 
228
 
 
229
        curl_formadd(&formdata,
 
230
               &lastptr,
 
231
               CURLFORM_COPYNAME, "speed",
 
232
               CURLFORM_COPYCONTENTS, speed,
 
233
               CURLFORM_END);
 
234
 
 
235
        curl_formadd(&formdata,
 
236
               &lastptr,
 
237
               CURLFORM_COPYNAME, "mode",
 
238
               CURLFORM_COPYCONTENTS, mode,
 
239
               CURLFORM_END);
 
240
               
 
241
        curl_formadd(&formdata,
 
242
               &lastptr,
 
243
               CURLFORM_COPYNAME, "ff_mode",
 
244
               CURLFORM_COPYCONTENTS, ff_mode,
 
245
               CURLFORM_END);
 
246
 
 
247
        curl_formadd(&formdata,
 
248
               &lastptr,
 
249
               CURLFORM_COPYNAME, "nick",
 
250
               CURLFORM_COPYCONTENTS, n,
 
251
               CURLFORM_END);
 
252
 
 
253
        curl_formadd(&formdata,
 
254
               &lastptr,
 
255
               CURLFORM_COPYNAME, "pass",
 
256
               CURLFORM_COPYCONTENTS, p,
 
257
               CURLFORM_END);
 
258
 
 
259
        curl_formadd(&formdata,
 
260
               &lastptr,
 
261
               CURLFORM_COPYNAME, "msg",
 
262
               CURLFORM_COPYCONTENTS, m,
 
263
               CURLFORM_END);
 
264
               
 
265
               
269
266
        curl_handle = curl_easy_init();
270
 
 
 
267
        
271
268
        curl_easy_setopt(curl_handle, CURLOPT_URL, "http://www.tangogps.org/friends/update_pos.php");
272
269
        curl_easy_setopt(curl_handle, CURLOPT_HTTPPOST, formdata);
273
270
        curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, cb_write_to_mem);
274
271
        curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
275
 
        curl_easy_setopt(curl_handle, CURLOPT_USERAGENT,  VERSION );
 
272
        curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0 |" VERSION " | " __VERSION__);
 
273
 
 
274
 
276
275
 
277
276
        curl_easy_perform(curl_handle);
278
277
        curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &response_code);
279
 
 
280
 
 
 
278
        
 
279
        
281
280
        curl_easy_cleanup(curl_handle);
282
 
 
283
 
 
284
 
 
285
 
 
286
 
 
287
 
 
288
 
 
289
 
 
290
 
        if (response_code == 200)
291
 
        {
292
 
 
293
 
 
294
 
 
295
 
 
 
281
        
 
282
        
 
283
        
 
284
        
 
285
        
 
286
        
 
287
 
 
288
 
 
289
        if (response_code == 200) 
 
290
        { 
 
291
                
 
292
                
 
293
                
 
294
                
296
295
 
297
296
                user_data_sets = g_strsplit_set (chunk.memory, "|", -1);
298
 
 
299
 
 
 
297
        
 
298
                        
300
299
                gdk_threads_enter();
301
300
                g_slist_free(friends_list);
302
301
                friends_list = NULL;
303
 
                gtk_label_set_label(label_msg, user_data_sets[0]);
 
302
                gtk_label_set_label(label_msg, user_data_sets[0]); 
304
303
                gdk_threads_leave();
305
 
 
 
304
                
306
305
                while (user_data_sets[i] && !g_str_equal(user_data_sets[i],"EOD") )
307
306
                {
308
307
                        gchar **array;
309
308
                        int len=0;
310
309
                        friend_t *friend = g_new0(friend_t,1);
311
 
 
 
310
                        
312
311
                        array = g_strsplit(user_data_sets[i],"#",-1);
313
312
                        while (array[len]) len++;
314
 
 
315
 
 
316
 
 
317
 
 
318
 
 
 
313
                        
 
314
                        
 
315
                        
 
316
                        
 
317
                        
319
318
                        if(len>=7)
320
319
                        {
321
320
                                friend->type = atoi(g_strdup(array[0]));
325
324
                                friend->head = atoi(g_strdup(array[4]));
326
325
                                friend->lastseen = g_strdup(array[5]);
327
326
                                friend->away_msg = g_strdup(array[6]);
328
 
 
 
327
                                
329
328
                                friends_list = g_slist_append(friends_list, friend);
330
329
                        }
331
 
 
332
 
 
 
330
                        
 
331
                        
333
332
                        i++;
334
333
                }
335
334
        }
336
335
        else
337
336
        {
338
337
                gdk_threads_enter();
339
 
                gtk_label_set_text (label_msg, _("No response (200)"));
 
338
                gtk_label_set_text(label_msg, "No response (200)"); 
340
339
                gdk_threads_leave();
341
 
 
 
340
                
342
341
        }
343
 
 
344
 
 
345
 
 
346
 
 
 
342
        
 
343
        
 
344
        
 
345
        
347
346
        gdk_threads_enter();
348
 
        repaint_all();
 
347
        paint_friends();
 
348
        
349
349
        gdk_threads_leave();
350
 
 
351
 
 
 
350
        
 
351
        
352
352
        if(chunk.memory)
353
353
                g_free(chunk.memory);
354
 
 
 
354
        
355
355
        curl_global_cleanup();
356
 
 
 
356
        
357
357
        g_free(ff_mode);
358
358
 
359
359
        return NULL;
361
361
 
362
362
void
363
363
paint_friends()
364
 
{
 
364
{       
365
365
        GSList *list;
366
366
        int pixel_x, pixel_y, x,y;
367
367
        float lat, lon;
368
368
        GdkColor color;
369
369
        GdkGC *gc;
370
370
        GError  *error = NULL;
371
 
 
 
371
        
372
372
        gc = gdk_gc_new(pixmap);
373
373
        color.green = 60000;
374
374
        color.blue = 0;
375
375
        color.red = 10000;
376
376
        gdk_gc_set_rgb_fg_color(gc, &color);
377
 
 
 
377
        
378
378
 
379
379
        if(!friend_icon)
380
380
        {
382
382
                        PACKAGE_PIXMAPS_DIR "/" PACKAGE "-friend.png", 24,24,
383
383
                        &error);
384
384
        }
385
 
        if (pixmap && !gc_map)
 
385
        if (pixmap && !gc_map)  
386
386
                gc_map = gdk_gc_new(pixmap);
387
 
 
388
 
 
 
387
                
 
388
        
389
389
        if (global_show_friends)
390
390
                {
391
391
                for(list = friends_list; list != NULL; list = list->next)
392
392
                {
393
393
                        friend_t *f = list->data;
394
 
 
 
394
                
395
395
                        lat = deg2rad(f->lat);
396
396
                        lon = deg2rad(f->lon);
397
 
 
398
 
 
399
 
 
400
 
 
 
397
                        
 
398
                        
 
399
                        
 
400
                        
401
401
                        pixel_x = lon2pixel(global_zoom, lon);
402
402
                        pixel_y = lat2pixel(global_zoom, lat);
403
 
 
 
403
                        
404
404
                        x = pixel_x - global_x;
405
405
                        y = pixel_y - global_y;
406
 
 
 
406
                        
407
407
                        f->screen_x = x;
408
408
                        f->screen_y = y;
409
 
 
410
 
 
411
 
 
 
409
                        
 
410
                        
 
411
                        
412
412
                        if(!friend_icon)
413
413
                        {
414
414
                                gdk_draw_arc (
415
415
                                        pixmap,
416
 
 
 
416
                                        
417
417
                                        gc,
418
 
                                        TRUE,
419
 
                                        x-4, y-4,
420
 
                                        8,8,
421
 
                                        0,23040);
 
418
                                        TRUE,                   
 
419
                                        x-4, y-4,               
 
420
                                        8,8,                    
 
421
                                        0,23040);               
422
422
                        }
423
423
                        else
424
424
                        {
430
430
                                        x-12,y-12,
431
431
                                        24,24,
432
432
                                        GDK_RGB_DITHER_NONE, 0, 0);
433
 
 
 
433
                                
434
434
                                gtk_widget_queue_draw_area (
435
 
                                        map_drawable,
 
435
                                        map_drawable, 
436
436
                                        x-12, y-12,
437
437
                                        24,24);
438
438
                        }
439
 
 
 
439
                        
440
440
                }
441
441
        }
442
442
}
447
447
        CURL *curl;
448
448
        CURLcode res;
449
449
 
 
450
        printf("*** %s(): \n",__PRETTY_FUNCTION__);
 
451
        
450
452
        curl = curl_easy_init();
451
 
 
 
453
        
452
454
        if(curl)
453
455
        {
454
 
                curl_easy_setopt(curl, CURLOPT_URL,
 
456
                curl_easy_setopt(curl, CURLOPT_URL, 
455
457
                                "127.0.0.1/friends/update_position.php?lat=1&lon=1");
456
458
                res = curl_easy_perform(curl);
457
 
 
 
459
                
458
460
                curl_easy_cleanup(curl);
459
461
        }
460
 
 
 
462
        
461
463
}
462
464
 
463
465
 
465
467
 
466
468
 
467
469
 
 
470
 
 
471
 
468
472
int
469
473
register_nick()
470
 
{
 
474
{               
471
475
        GtkLabel *label_msg;
472
476
        label_msg = (GtkLabel *)lookup_widget(window1, "label62");
473
 
        gtk_label_set_text (label_msg, _("Connecting..."));
474
 
 
475
 
#if GLIB_CHECK_VERSION(2,34,0)
476
 
        if (!g_thread_new("register nick thread", &register_nick_thread, (gpointer) NULL) != 0)
477
 
#else
 
477
        gtk_label_set_text(label_msg, "Connecting...");
 
478
 
 
479
        printf("*** %s(): \n",__PRETTY_FUNCTION__);
 
480
 
478
481
        if (!g_thread_create(&register_nick_thread, NULL, FALSE, NULL) != 0)
479
 
#endif
480
482
                g_warning("### can't create register_nick() thread\n");
481
 
 
 
483
        
482
484
        return 0;
483
485
}
484
 
 
 
486
        
485
487
void *
486
488
register_nick_thread(void *ptr)
487
489
{
488
 
 
 
490
        
489
491
        GtkEntry *nick, *pass, *email;
490
492
        GtkLabel *label_msg;
491
493
        const gchar *n, *p, *e;
492
494
        gchar *buffer;
493
 
 
494
 
 
495
 
 
 
495
        
 
496
        
 
497
        
496
498
        CURL *curl_handle;
497
 
 
 
499
        
498
500
        struct curl_httppost *formdata=NULL;
499
501
        struct curl_httppost *lastptr=NULL;
500
 
 
 
502
                
501
503
        struct mem_struct chunk;
502
 
 
 
504
        
503
505
        chunk.memory=NULL;
504
506
        chunk.size = 0;
505
 
 
 
507
        
 
508
        printf("*** %s(): \n",__PRETTY_FUNCTION__);
 
509
 
 
510
 
 
511
 
 
512
        
506
513
        nick  = (GtkEntry *)lookup_widget(window1, "entry7");
507
514
        pass  = (GtkEntry *)lookup_widget(window1, "entry8");
508
515
        email = (GtkEntry *)lookup_widget(window1, "entry9");
511
518
        p = gtk_entry_get_text(pass);
512
519
        e = gtk_entry_get_text(email);
513
520
 
514
 
 
 
521
        
515
522
        curl_global_init(CURL_GLOBAL_ALL);
516
523
 
517
 
 
518
 
        curl_formadd(&formdata,
519
 
                     &lastptr,
520
 
                     CURLFORM_COPYNAME, "nick",
521
 
                     CURLFORM_COPYCONTENTS, n,
522
 
                     CURLFORM_END);
523
 
 
524
 
        curl_formadd(&formdata,
525
 
                     &lastptr,
526
 
                     CURLFORM_COPYNAME, "pass",
527
 
                     CURLFORM_COPYCONTENTS, p,
528
 
                     CURLFORM_END);
529
 
 
530
 
        curl_formadd(&formdata,
531
 
                     &lastptr,
532
 
                     CURLFORM_COPYNAME, "email",
533
 
                     CURLFORM_COPYCONTENTS, e,
534
 
                     CURLFORM_END);
535
 
 
536
 
 
537
 
 
 
524
               
 
525
        curl_formadd(&formdata,
 
526
               &lastptr,
 
527
               CURLFORM_COPYNAME, "nick",
 
528
               CURLFORM_COPYCONTENTS, n,
 
529
               CURLFORM_END);
 
530
 
 
531
        curl_formadd(&formdata,
 
532
               &lastptr,
 
533
               CURLFORM_COPYNAME, "pass",
 
534
               CURLFORM_COPYCONTENTS, p,
 
535
               CURLFORM_END);
 
536
 
 
537
        curl_formadd(&formdata,
 
538
               &lastptr,
 
539
               CURLFORM_COPYNAME, "email",
 
540
               CURLFORM_COPYCONTENTS, e,
 
541
               CURLFORM_END);
 
542
 
 
543
               
 
544
               
538
545
        curl_handle = curl_easy_init();
539
 
 
 
546
        
540
547
        curl_easy_setopt(curl_handle, CURLOPT_URL, "http://www.tangogps.org/friends/register_nick.php");
541
548
        curl_easy_setopt(curl_handle, CURLOPT_HTTPPOST, formdata);
542
549
        curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, cb_write_to_mem);
547
554
        curl_easy_perform(curl_handle);
548
555
        curl_easy_cleanup(curl_handle);
549
556
 
 
557
        printf("REPLY: %s %d \n",chunk.memory, (int)chunk.size);
 
558
 
550
559
        if((int)chunk.size > 0){
551
560
                buffer = g_strdup(chunk.memory);
552
561
        }
553
562
        else
554
 
                buffer = g_strdup (_("Oh. Some error occurred..."));
 
563
                buffer = g_strdup("Oh. Some error occurred...");
555
564
 
556
565
        gdk_threads_enter();
557
566
        label_msg = (GtkLabel *)lookup_widget(window1, "label62");
558
 
        gtk_label_set_text(label_msg, buffer);
 
567
        gtk_label_set_text(label_msg, buffer); 
559
568
        gdk_threads_leave();
560
 
 
561
 
 
562
 
 
563
 
 
564
 
 
 
569
        
 
570
 
 
571
        
 
572
        
 
573
        
565
574
        curl_global_cleanup();
566
 
 
 
575
        
567
576
        return NULL;
568
577
}
569
578
 
573
582
{
574
583
        GtkWidget *hbox, *label, *vbox, *button;
575
584
        char *label_txt;
576
 
 
577
 
        label_txt = g_strdup_printf (_("<b>%s</b>\n"
578
 
                                       "Last seen:\n"
579
 
                                       "%s\n"
580
 
                                       "<i>%s</i>"),
581
 
                                     f->nick, f->lastseen, f->away_msg);
582
 
 
 
585
        
 
586
        label_txt = g_strdup_printf("<b>%s</b>\nLast seen:\n%s\n<i>%s</i>",f->nick, f->lastseen, f->away_msg);
 
587
        
583
588
        hbox = gtk_hbox_new (FALSE, 2);
584
589
        gtk_widget_show (hbox);
585
 
 
 
590
        
586
591
        label = gtk_label_new ("");
587
592
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
588
593
 
589
594
        gtk_label_set_label(GTK_LABEL(label), label_txt);
590
 
 
 
595
        
591
596
        gtk_widget_show (label);
592
597
        gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
593
 
 
 
598
        
594
599
        vbox = gtk_vbox_new (FALSE, 0);
595
600
        gtk_widget_show (vbox);
596
601
        gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
597
 
 
 
602
        
598
603
        button = gtk_button_new_with_mnemonic (_("Msg"));
599
604
        gtk_widget_show (button);
600
605
        gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 2);
601
 
 
 
606
        
602
607
        g_signal_connect ((gpointer) button, "clicked",
603
608
                                G_CALLBACK (on_msg_friend_clicked),
604
609
                                (gpointer) f->nick);
605
 
 
 
610
                                
606
611
        button = gtk_button_new_with_mnemonic (_("Go To"));
607
612
        gtk_widget_show (button);
608
613
        gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 2);
609
 
 
 
614
        
610
615
        g_signal_connect ((gpointer) button, "clicked",
611
616
                                G_CALLBACK (on_goto_friend_clicked),
612
617
                                (gpointer) f);
621
626
        GtkWidget *widget, *window;
622
627
        char *label_txt;
623
628
        char *to;
624
 
 
 
629
        
625
630
        to = user_data;
626
 
        label_txt = g_strdup_printf (_("Send Message To: <b>%s</b>"), to);
627
 
 
 
631
        label_txt = g_strdup_printf("Send Message To: <b>%s</b>", to);
 
632
        
 
633
        printf("* %s() %s\n", __PRETTY_FUNCTION__, label_txt);
 
634
        
628
635
        widget = lookup_widget(GTK_WIDGET(button), "window8");
629
636
        gtk_widget_destroy(widget);
630
 
 
 
637
        
631
638
        gladexml = glade_xml_new (gladefile, "dialog9", GETTEXT_PACKAGE);
632
639
        glade_xml_signal_autoconnect (gladexml);
633
640
        window = glade_xml_get_widget (gladexml, "dialog9");
636
643
 
637
644
        gtk_widget_show(window);
638
645
 
639
 
        widget = lookup_widget(window, "label188");
 
646
        widget = lookup_widget(window, "label188");     
640
647
        gtk_label_set_label(GTK_LABEL(widget), label_txt);
641
648
 
642
649
        widget = lookup_widget(window, "okbutton10");
650
657
on_goto_friend_clicked(GtkButton *button, gpointer user_data)
651
658
{
652
659
        GtkWidget *widget;
653
 
 
 
660
        
654
661
        friend_t *f;
655
662
        f = user_data;
656
 
 
 
663
        
 
664
        printf("btn42 clicked: %s\n", f->nick);
 
665
        
657
666
        widget = lookup_widget(GTK_WIDGET(button), "window8");
658
667
        set_current_wp(deg2rad(f->lat), deg2rad(f->lon));
659
668
        gtk_widget_destroy(widget);
665
674
        GtkWidget *widget;
666
675
        char *to;
667
676
        msg_t *m;
668
 
 
 
677
        
669
678
        to = user_data;
670
679
        m = g_new0(msg_t,1);
671
 
 
 
680
        
672
681
        widget = lookup_widget(GTK_WIDGET(button), "entry30");
673
682
        m->txt = g_strdup( gtk_entry_get_text(GTK_ENTRY(widget)) );
674
683
        m->to = g_strdup(to);
687
696
                m->lat = 0;
688
697
                m->lon = 0;
689
698
        }
690
 
 
 
699
                
 
700
        printf("* %s() %s %s %f %f\n", __PRETTY_FUNCTION__, to, m->txt, m->lat,m->lon);
 
701
        
691
702
        add_message(m);
692
703
        send_message((gpointer) m);
693
704
        widget = lookup_widget(GTK_WIDGET(button), "dialog9");
699
710
{
700
711
        GSList *postdata = NULL;
701
712
        msg_t *m;
702
 
 
 
713
        
703
714
        m = user_data;
704
715
 
705
716
        postdata = create_msg_postdata(m);
706
717
 
707
 
#if GLIB_CHECK_VERSION(2,34,0)
708
 
        if (!g_thread_new("Mission thread", &thread_send_message, postdata) != 0)
709
 
#else
710
718
        if (!g_thread_create(&thread_send_message, postdata, FALSE, NULL) != 0)
711
 
#endif
712
719
                g_warning("### can't create mission thread\n");
713
 
 
 
720
        
714
721
        return TRUE;
715
722
}
716
723
 
717
724
void *
718
725
thread_send_message(void *ptr)
719
726
{
720
 
 
 
727
        
721
728
        GSList          *postdata = NULL;
722
729
        postreply_t     *postreply;
723
 
 
724
 
 
 
730
        
 
731
                
725
732
 
726
733
        postdata = ptr;
727
734
 
728
 
 
 
735
        
729
736
        postreply = mycurl__do_http_post(MSG_SEND_URL, postdata, VERSION);
730
 
 
731
 
 
732
 
 
733
 
 
 
737
        
 
738
 
 
739
        
 
740
        
734
741
        gdk_threads_enter();
735
742
        process_msg_replydata(postreply);
736
743
        gdk_threads_leave();
737
744
 
738
 
 
739
 
 
740
 
 
 
745
        
 
746
        
741
747
        g_slist_free(postdata);
742
748
        g_free(postreply);
743
 
 
 
749
        
744
750
        return NULL;
745
751
}
746
752
 
751
757
        const char *n, *p;
752
758
        postdata_item_t *item;
753
759
 
754
 
 
755
 
 
756
 
 
 
760
                
 
761
        
 
762
        
757
763
        n = gtk_entry_get_text((GtkEntry *)lookup_widget(window1, "entry7"));
758
764
        p = gtk_entry_get_text((GtkEntry *)lookup_widget(window1, "entry8"));
759
 
 
 
765
        
760
766
        item = g_new0(postdata_item_t, 1);
761
767
        item->name=g_strdup("user");
762
768
        item->value=g_strdup(n);
766
772
        item->name=g_strdup("pass");
767
773
        item->value=g_strdup(p);
768
774
        postdata = g_slist_append(postdata, item);
769
 
 
770
 
 
 
775
        
 
776
        
771
777
 
772
778
        if(m)
773
779
        {
774
 
 
 
780
                
775
781
                item = g_new0(postdata_item_t, 1);
776
782
                item->name=g_strdup("lat");
777
783
                item->value=g_strdup_printf("%f", m->lat);
778
784
                postdata = g_slist_append(postdata, item);
779
 
 
 
785
                
780
786
                item = g_new0(postdata_item_t, 1);
781
787
                item->name=g_strdup("lon");
782
788
                item->value=g_strdup_printf("%f", m->lon);
783
 
                postdata = g_slist_append(postdata, item);
784
 
 
 
789
                postdata = g_slist_append(postdata, item);      
 
790
                
785
791
                item = g_new0(postdata_item_t, 1);
786
792
                item->name=g_strdup("txt");
787
793
                item->value=g_strdup_printf("%s", m->txt);
788
 
                postdata = g_slist_append(postdata, item);
789
 
 
 
794
                postdata = g_slist_append(postdata, item);      
 
795
                
790
796
                item = g_new0(postdata_item_t, 1);
791
797
                item->name=g_strdup("to");
792
798
                item->value=g_strdup_printf("%s", m->to);
793
 
                postdata = g_slist_append(postdata, item);
 
799
                postdata = g_slist_append(postdata, item);      
794
800
        }
795
801
 
796
 
 
797
 
 
 
802
        
 
803
        
798
804
        if(db_ts_last_request_friends)
799
805
        {
800
806
                item = g_new0(postdata_item_t, 1);
802
808
                item->value=g_strdup(db_ts_last_request_friends);
803
809
                postdata = g_slist_append(postdata, item);
804
810
        }
805
 
 
 
811
        
806
812
        return postdata;
807
813
}
808
814
 
815
821
        msg_t *msg = NULL;
816
822
        int i = 1;
817
823
        static gboolean first_call = TRUE;
818
 
 
819
 
 
820
 
 
 
824
        
 
825
        
 
826
        
821
827
        widget = lookup_widget(window1, "label132");
822
 
 
823
 
 
824
 
 
825
 
 
 
828
        
 
829
        
 
830
        
 
831
        
826
832
        if(postreply->status_code == 200 && postreply->size > 0)
827
833
        {
828
834
                arr0 = g_strsplit (postreply->data, "###", -1);
829
 
 
830
 
 
831
 
 
 
835
                
 
836
                
 
837
                
832
838
                if (arr0[0] && strlen(arr0[0]))
833
839
                {
834
840
                        char *err_msg;
835
 
 
 
841
                        
836
842
                        arr = g_strsplit (arr0[0], "|", -1);
837
 
 
 
843
                        
838
844
                        err_msg = g_strdup(arr[4]);
839
845
                        gtk_label_set_label(GTK_LABEL(widget), err_msg );
840
846
 
841
 
 
 
847
                        
842
848
                        if(atoi(arr[6]) > 0)
843
849
                        {
844
 
 
 
850
                                
845
851
                                db_ts_last_request_friends = g_strdup(arr[2]);
846
 
 
 
852
                                
847
853
                                if(first_call)
848
854
                                {
849
855
                                        GtkWidget *widget = NULL;
850
 
 
 
856
                                        
851
857
                                        widget = lookup_widget(window1, "button35");
852
858
                                        gtk_widget_show(widget);
853
 
 
 
859
                                        
854
860
                                        first_call = FALSE;
855
861
                                }
856
862
                                else
857
863
                                        global_new_msg = TRUE;
858
864
                        }
859
 
 
860
 
 
861
 
 
 
865
                        
 
866
                        
 
867
                        
862
868
                        g_strfreev(arr);
863
869
                }
864
 
 
865
 
 
 
870
                
 
871
                
866
872
                while (arr0[i] && strlen(arr0[i]) )
867
873
                {
868
874
 
869
 
 
 
875
                        
870
876
                        msg = g_new0(msg_t, 1);
871
 
 
872
 
 
 
877
                        
 
878
                        
873
879
                        arr = g_strsplit (arr0[i], "|||", -1);
874
 
 
875
 
 
876
 
 
877
 
 
 
880
                        
 
881
                        
 
882
                        
 
883
                        
878
884
                        msg->id         = atoi(arr[1]);
879
885
                        msg->time       = g_strdup(arr[2]);
880
886
                        msg->txt        = g_strdup(arr[3]);
886
892
 
887
893
 
888
894
                        add_message(msg);
889
 
 
 
895
                        
890
896
                        i++;
891
 
 
 
897
                        
892
898
                        g_strfreev(arr);
893
899
                }
894
900
        }
895
901
        else
896
902
        {
897
 
                gtk_label_set_label (GTK_LABEL(widget),
898
 
                                     g_strdup_printf (_("msg-code: %d"),
899
 
                                                      (int)postreply->status_code));
 
903
                gtk_label_set_label(GTK_LABEL(widget), g_strdup_printf("msg-code: %d",(int)postreply->status_code) );
900
904
        }
901
 
 
902
 
 
903
 
 
904
 
 
905
 
 
906
 
 
907
 
 
908
 
 
 
905
        
 
906
        
 
907
        
 
908
        
 
909
        
 
910
        
 
911
 
 
912
        
909
913
 
910
914
}
911
915
 
914
918
{
915
919
        GtkWidget *msg_box, *widget, *hseparator;
916
920
        msg_list = g_slist_append(msg_list, m);
917
 
 
 
921
        
918
922
        msg_box = create_msg_box(m);
919
 
 
 
923
        
920
924
        widget = lookup_widget(window1, "vbox48");
921
925
        gtk_box_pack_start (GTK_BOX (widget), msg_box, FALSE, FALSE, 0);
922
 
 
 
926
        
923
927
        hseparator = gtk_hseparator_new ();
924
928
        gtk_widget_show (hseparator);
925
929
        gtk_box_pack_start (GTK_BOX (widget), hseparator, FALSE, FALSE, 0);
926
 
 
 
930
        
927
931
 
928
932
}
929
933
 
932
936
{
933
937
        GtkWidget *hbox, *label, *vbox, *button;
934
938
        char *label_txt;
935
 
 
936
 
 
 
939
        
 
940
        
937
941
        hbox = gtk_hbox_new (FALSE, 2);
938
942
        gtk_widget_set_size_request(hbox, 340, -1);
939
943
        gtk_widget_show (hbox);
940
 
 
 
944
        
941
945
        label = gtk_label_new ("");
942
946
        gtk_widget_set_size_request(label, 260, -1);
943
947
 
945
949
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
946
950
        gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
947
951
        gtk_misc_set_padding (GTK_MISC (label), 5, 2);
948
 
 
 
952
        
949
953
        if(m->incoming)
950
954
                label_txt = g_strdup_printf("<i><b>%s</b>, %s</i>\n\n%s",m->from, m->time, m->txt);
951
955
        else
952
 
                label_txt = g_strdup_printf(_("<i><small>To: </small><b>%s</b></i>\n\n%s"),
953
 
                                            m->to, m->txt);
954
 
 
 
956
                label_txt = g_strdup_printf("<i><small>To: </small><b>%s</b></i>\n\n%s",m->to, m->txt);
 
957
        
955
958
        gtk_label_set_label(GTK_LABEL(label), label_txt);
956
 
 
 
959
        
957
960
        gtk_widget_show (label);
958
961
        gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
959
 
 
 
962
        
960
963
        vbox = gtk_vbox_new (FALSE, 0);
961
964
        gtk_widget_show (vbox);
962
965
        gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
963
 
 
 
966
        
964
967
        if(m->incoming)
965
968
        {
966
969
                button = gtk_button_new_with_mnemonic (_("Reply"));
967
970
                gtk_widget_show (button);
968
971
                gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2);
969
 
 
 
972
                
970
973
                g_signal_connect ((gpointer) button, "clicked",
971
974
                                        G_CALLBACK (on_msg_friend_clicked),
972
975
                                        (gpointer) m->from);
973
 
 
 
976
                                        
974
977
                button = gtk_button_new_with_mnemonic (_("Go To"));
975
978
                gtk_widget_show (button);
976
979
                gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2);
977
 
 
 
980
                
978
981
                g_signal_connect ((gpointer) button, "clicked",
979
982
                                        G_CALLBACK (on_goto_friend2_clicked),
980
983
                                        (gpointer) m);
981
984
        }
982
 
 
 
985
        
983
986
        return hbox;
984
987
}
985
988
 
986
989
void
987
990
on_goto_friend2_clicked(GtkButton *button, gpointer user_data)
988
 
{
 
991
{       
989
992
        msg_t *m;
990
993
        m = user_data;
991
 
 
 
994
        
 
995
        printf("btn42 clicked: %s\n", m->from);
 
996
        
992
997
        set_current_wp(deg2rad(m->lat), deg2rad(m->lon));
993
 
 
 
998
        
994
999
        set_mapcenter(m->lat,m->lon, global_zoom);
995
1000
 
996
1001
}