void
popup(struct navit *nav, int button, struct point *p)
{
void *popup,*men;
char buffer[1024];
struct coord_geo g;
struct coord co;
popup=gui_popup_new(navit_get_gui(nav));
transform_reverse(navit_get_trans(nav), p, &co);
men=popup_printf(popup, menu_type_submenu, _("Point 0x%x 0x%x"), co.x, co.y);
popup_printf(men, menu_type_menu, _("Screen %d %d"), p->x, p->y);
transform_to_geo(transform_get_projection(navit_get_trans(nav)), &co, &g);
transform_geo_text(&g, buffer);
popup_printf(men, menu_type_menu, "%s", buffer);
popup_printf(men, menu_type_menu, "%f %f", g.lat, g.lng);
dbg(0,"%p %p\n", nav, &c);
c.pro = transform_get_projection(navit_get_trans(nav));
c.x = co.x;
c.y = co.y;
popup_printf_cb(men, menu_type_menu, callback_new_2(callback_cast(popup_set_position), nav, &c), _("Set as position"));
popup_printf_cb(men, menu_type_menu, callback_new_2(callback_cast(popup_set_destination), nav, &c), _("Set as destination"));
popup_printf_cb(men, menu_type_menu, callback_new_2(callback_cast(popup_set_bookmark), nav, &c), _("Add as bookmark"));
popup_display(nav, popup, p);
#ifdef _WIN32
// menu needs first to be constructed before doing the menu popup
// therefore this work around for win32
// needs to be fixed
popup=gui_popup_new(navit_get_gui(nav));
#endif
}
static int
vehicle_add_log(struct vehicle *this_, struct log *log,
struct attr **attrs)
{
struct attr *type;
struct callback *cb;
type = attr_search(attrs, NULL, attr_type);
if (!type)
return 1;
if (!strcmp(type->u.str, "nmea")) {
cb=callback_new_2(callback_cast(vehicle_log_nmea), this_, log);
} else if (!strcmp(type->u.str, "gpx")) {
char *header =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<gpx version=\"1.0\" creator=\"Navit http://navit.sourceforge.net\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://www.topografix.com/GPX/1/0\" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd\">\n<trk>\n<trkseg>\n";
char *trailer = "</trkseg>\n</trk>\n</gpx>\n";
log_set_header(log, header, strlen(header));
log_set_trailer(log, trailer, strlen(trailer));
cb=callback_new_2(callback_cast(vehicle_log_gpx), this_, log);
} else if (!strcmp(type->u.str, "textfile")) {
char *header = "type=track\n";
log_set_header(log, header, strlen(header));
cb=callback_new_2(callback_cast(vehicle_log_textfile), this_, log);
} else
return 1;
callback_list_add(this_->cbl, cb);
return 0;
}
static void
popup_show_item(struct navit *nav, void *popup, struct displayitem *di)
{
struct map_rect *mr;
void *menu, *menu_map, *menu_item, *menu_dist;
char *label;
struct item *item,*diitem;
int count;
label=graphics_displayitem_get_label(di);
diitem=graphics_displayitem_get_item(di);
count=graphics_displayitem_get_coord_count(di);
dbg_assert(diitem);
if (label)
menu=popup_printf(popup, menu_type_submenu, "%s '%s' (%d coords)", item_to_name(diitem->type), label, count);
else
menu=popup_printf(popup, menu_type_submenu, "%s (%d coords)", item_to_name(diitem->type), count);
menu_item=popup_printf(menu, menu_type_submenu, "Item");
popup_printf(menu_item, menu_type_menu, "type: 0x%x", diitem->type);
popup_printf(menu_item, menu_type_menu, "id: 0x%x 0x%x", diitem->id_hi, diitem->id_lo);
if (diitem->map) {
struct attr type,data;
if (!map_get_attr(diitem->map, attr_type, &type, NULL))
type.u.str="";
if (!map_get_attr(diitem->map, attr_data, &data, NULL))
data.u.str="";
popup_printf(menu_item, menu_type_menu, "map: %s:%s", type.u.str, data.u.str);
}
if (diitem->map) {
mr=map_rect_new(diitem->map,NULL);
item=map_rect_get_item_byid(mr, diitem->id_hi, diitem->id_lo);
dbg(1,"item=%p\n", item);
if (item) {
popup_show_attrs(item->map, menu_item, item);
popup_printf_cb(menu_item, menu_type_menu, callback_new_1(callback_cast(popup_item_dump), diitem), "Dump");
if (item->type < type_line) {
struct coord co;
struct pcoord *c;
if (item_coord_get(item, &co, 1)) {
c=g_new(struct pcoord, 1);
c->pro = transform_get_projection(navit_get_trans(nav));
c->x = co.x;
c->y = co.y;
popup_printf_cb(menu_item, menu_type_menu, callback_new_2(callback_cast(popup_set_position), nav, c), _("Set as position"));
popup_printf_cb(menu_item, menu_type_menu, callback_new_2(callback_cast(popup_set_destination), nav, c), _("Set as destination"));
popup_printf_cb(menu_item, menu_type_menu, callback_new_2(callback_cast(popup_set_bookmark), nav, c), _("Add as bookmark"));
}
}
}
static struct vehicle_priv *
vehicle_demo_new(struct vehicle_methods
*meth, struct callback_list
*cbl, struct attr **attrs)
{
struct vehicle_priv *ret;
struct attr *interval,*speed,*position_coord_geo;
dbg(1, "enter\n");
ret = g_new0(struct vehicle_priv, 1);
ret->cbl = cbl;
ret->interval=1000;
ret->config_speed=40;
if ((speed=attr_search(attrs, NULL, attr_speed))) {
ret->config_speed=speed->u.num;
}
if ((interval=attr_search(attrs, NULL, attr_interval)))
ret->interval=interval->u.num;
if ((position_coord_geo=attr_search(attrs, NULL, attr_position_coord_geo))) {
ret->geo=*(position_coord_geo->u.coord_geo);
ret->position_set=1;
dbg(0,"position_set %f %f\n", ret->geo.lat, ret->geo.lng);
}
*meth = vehicle_demo_methods;
ret->timer_callback=callback_new_1(callback_cast(vehicle_demo_timer), ret);
ret->timer=event_add_timeout(ret->interval, 1, ret->timer_callback);
return ret;
}
/** @fn static int vehicle_file_open(struct vehicle_priv *priv)
*****************************************************************************
* @b Description: open dialogue with the GPS
*****************************************************************************
* @param priv : pointer on the private data of the plugin
*****************************************************************************
* @return 1 if ok
* 0 if error
*****************************************************************************
**/
static int
vehicle_file_open(struct vehicle_priv *priv)
{
#ifdef _WIN32
dbg(1, "enter, priv->source='%s'\n", priv->source);
if ( priv->source )
{
char* raw_setting_str = g_strdup( priv->source );
char* strport = strchr(raw_setting_str, ':' );
char* strsettings = strchr(raw_setting_str, ' ' );
if ( strport && strsettings )
{
strport++;
*strsettings = '\0';
strsettings++;
priv->fd=serial_io_init( strport, strsettings );
}
g_free( raw_setting_str );
// Add the callback
dbg(2, "Add the callback ...\n", priv->source);
priv->timeout_callback=callback_new_1(callback_cast(vehicle_win32_serial_track), priv);
}
#else
char *name;
struct stat st;
struct termios tio;
name = priv->source + 5;
if (!strncmp(priv->source, "file:", 5)) {
priv->fd = open(name, O_RDONLY | O_NDELAY);
if (priv->fd < 0)
return 0;
stat(name, &st);
if (S_ISREG(st.st_mode)) {
priv->file_type = file_type_file;
} else {
tcgetattr(priv->fd, &tio);
cfmakeraw(&tio);
cfsetispeed(&tio, priv->baudrate);
cfsetospeed(&tio, priv->baudrate);
tio.c_cc[VMIN] = 0;
tio.c_cc[VTIME] = 200;
tcsetattr(priv->fd, TCSANOW, &tio);
priv->file_type = file_type_device;
}
} else {
priv->file = popen(name, "r");
if (!priv->file)
return 0;
priv->fd = fileno(priv->file);
priv->file_type = file_type_pipe;
}
#endif
return(priv->fd != -1);
}
void
navit_window_roadbook_new(struct navit *this_)
{
this_->roadbook_callback=callback_new_1(callback_cast(navit_window_roadbook_update), this_);
navigation_register_callback(this_->navigation, navigation_mode_long, this_->roadbook_callback);
this_->roadbook_window=gui_datawindow_new(this_->gui, "Roadbook", NULL, callback_new_1(callback_cast(navit_window_roadbook_destroy), this_));
}
/**
* @brief Create android_vehicle
*
* @param meth
* @param cbl
* @param attrs
* @returns vehicle_priv
*/
static struct vehicle_priv *
vehicle_android_new_android(struct vehicle_methods *meth,
struct callback_list *cbl,
struct attr **attrs)
{
struct vehicle_priv *ret;
dbg(lvl_debug, "enter\n");
ret = g_new0(struct vehicle_priv, 1);
ret->cbl = cbl;
ret->pcb = callback_new_1(callback_cast(vehicle_android_position_callback), ret);
ret->scb = callback_new_1(callback_cast(vehicle_android_status_callback), ret);
ret->fcb = callback_new_1(callback_cast(vehicle_android_fix_callback), ret);
ret->valid = attr_position_valid_invalid;
ret->sats = 0;
ret->sats_used = 0;
*meth = vehicle_android_methods;
vehicle_android_init(ret);
dbg(lvl_debug, "return\n");
return ret;
}
struct log *
log_new(struct attr * parent,struct attr **attrs)
{
struct log *ret=g_new0(struct log, 1);
struct attr *data,*overwrite,*lazy,*mkdir,*flush_size,*flush_time;
struct file_wordexp *wexp;
char *filename, **wexp_data;
dbg(1,"enter\n");
ret->func=&log_func;
navit_object_ref((struct navit_object *)ret);
data=attr_search(attrs, NULL, attr_data);
if (! data)
return NULL;
filename=data->u.str;
wexp=file_wordexp_new(filename);
if (wexp && file_wordexp_get_count(wexp) > 0) {
wexp_data=file_wordexp_get_array(wexp);
filename=wexp_data[0];
}
if (filename)
ret->filename=g_strdup(filename);
if (wexp)
file_wordexp_destroy(wexp);
overwrite=attr_search(attrs, NULL, attr_overwrite);
if (overwrite)
ret->overwrite=overwrite->u.num;
lazy=attr_search(attrs, NULL, attr_lazy);
if (lazy)
ret->lazy=lazy->u.num;
mkdir=attr_search(attrs, NULL, attr_mkdir);
if (mkdir)
ret->mkdir=mkdir->u.num;
flush_size=attr_search(attrs, NULL, attr_flush_size);
if (flush_size)
ret->flush_size=flush_size->u.num;
flush_time=attr_search(attrs, NULL, attr_flush_time);
if (flush_time)
ret->flush_time=flush_time->u.num;
if (ret->flush_time) {
dbg(1,"interval %d\n", ret->flush_time*1000);
ret->timer_callback=callback_new_1(callback_cast(log_timer), ret);
ret->timer=event_add_timeout(ret->flush_time*1000, 1, ret->timer_callback);
}
expand_filenames(ret);
if (ret->lazy)
log_set_last_flush(ret);
else
log_open(ret);
ret->attrs=attr_list_dup(attrs);
return ret;
}
static void
popup_show_item(struct navit *nav, void *popup, struct displayitem *di)
{
struct map_rect *mr;
void *menu, *menu_map, *menu_item;
char *label;
struct item *item;
label=graphics_displayitem_get_label(di);
item=graphics_displayitem_get_item(di);
if (label)
menu=popup_printf(popup, menu_type_submenu, "%s '%s'", item_to_name(item->type), label);
else
menu=popup_printf(popup, menu_type_submenu, "%s", item_to_name(item->type));
menu_item=popup_printf(menu, menu_type_submenu, "Item");
popup_printf(menu_item, menu_type_menu, "type: 0x%x", item->type);
popup_printf(menu_item, menu_type_menu, "id: 0x%x 0x%x", item->id_hi, item->id_lo);
if (item->map) {
mr=map_rect_new(item->map,NULL);
item=map_rect_get_item_byid(mr, item->id_hi, item->id_lo);
dbg(1,"item=%p\n", item);
if (item) {
popup_show_attrs(item->map, menu_item, item);
if (item->type < type_line) {
struct coord co;
struct pcoord *c;
if (item_coord_get(item, &co, 1)) {
c=g_new(struct pcoord, 1);
c->pro = transform_get_projection(navit_get_trans(nav));
c->x = co.x;
c->y = co.y;
popup_printf_cb(menu_item, menu_type_menu, callback_new_2(callback_cast(popup_set_position), nav, c), _("Set as position"));
popup_printf_cb(menu_item, menu_type_menu, callback_new_2(callback_cast(popup_set_destination), nav, c), _("Set as destination"));
popup_printf_cb(menu_item, menu_type_menu, callback_new_2(callback_cast(popup_set_bookmark), nav, c), _("Add as bookmark"));
}
}
}
static void
osd_rocket_init(struct navit *nav)
{
struct rocket *rocket=g_new0(struct rocket, 1);
struct attr attr;
rocket->navit=nav;
rocket->callback=callback_new_1(callback_cast(pedestrian_rocket_idle), rocket);
if (navit_get_attr(nav, attr_layout, &attr, NULL))
rocket->layout=attr.u.layout;
if (navit_get_attr(nav, attr_callback_list, &attr, NULL)) {
dbg(0,"ok\n");
command_add_table(attr.u.callback_list, commands, sizeof(commands)/sizeof(struct command_table), rocket);
}
}
void
navit_init(struct navit *this_)
{
struct menu *men;
struct mapset *ms;
if (this_->mapsets) {
ms=this_->mapsets->data;
if (this_->route)
route_set_mapset(this_->route, ms);
if (this_->tracking)
tracking_set_mapset(this_->tracking, ms);
if (this_->navigation)
navigation_set_mapset(this_->navigation, ms);
if (this_->menubar) {
men=menu_add(this_->menubar, "Map", menu_type_submenu, NULL, NULL, NULL);
if (men) {
navit_add_menu_layout(this_, men);
navit_add_menu_projection(this_, men);
navit_add_menu_vehicle(this_, men);
navit_add_menu_maps(this_, ms, men);
}
men=menu_add(this_->menubar, "Route", menu_type_submenu, NULL, NULL, NULL);
if (men) {
navit_add_menu_former_destinations(this_, men, this_->route);
navit_add_menu_bookmarks(this_, men);
}
} else
navit_add_menu_former_destinations(this_, NULL, this_->route);
}
if (this_->navigation && this_->speech) {
this_->nav_speech_cb=callback_new_1(callback_cast(navit_speak), this_);
navigation_register_callback(this_->navigation, navigation_mode_speech, this_->nav_speech_cb);
#if 0
#endif
}
if (this_->menubar) {
men=menu_add(this_->menubar, "Data", menu_type_submenu, NULL, NULL, NULL);
if (men) {
navit_add_menu_windows_items(this_, men);
}
}
global_navit=this_;
#if 0
navit_window_roadbook_new(this_);
navit_window_items_new(this_);
#endif
navit_debug(this_);
}
static struct script *
script_new(struct attr *parent, struct attr **attrs)
{
struct script *scr=g_new0(struct script, 1);
scr->func=&script_func;
navit_object_ref((struct navit_object *)scr);
scr->attrs=attr_list_dup(attrs);
attrs=scr->attrs;
scr->cb=callback_new_1(callback_cast(script_run), scr);
scr->parent=*parent;
while (attrs && *attrs)
script_set_attr_int(scr, *attrs++);
dbg(lvl_debug,"return %p\n",scr);
return scr;
}
struct navit_vehicle *
navit_add_vehicle(struct navit *this_, struct vehicle *v, const char *name, struct color *c, int update, int follow)
{
struct navit_vehicle *nv=g_new0(struct navit_vehicle, 1);
nv->vehicle=v;
nv->name=g_strdup(name);
nv->update_curr=nv->update=update;
nv->follow_curr=nv->follow=follow;
nv->cursor=cursor_new(this_->gra, v, c, this_->trans);
nv->update_cb=callback_new_1(callback_cast(navit_cursor_update), this_);
cursor_add_callback(nv->cursor, nv->update_cb);
this_->vehicles=g_list_append(this_->vehicles, nv);
return nv;
}
/**
* @brief Create android_vehicle
*
* @param meth
* @param cbl
* @param attrs
* @returns vehicle_priv
*/
static struct vehicle_priv *
vehicle_android_new_android(struct vehicle_methods *meth,
struct callback_list *cbl,
struct attr **attrs)
{
struct vehicle_priv *ret;
dbg(0, "enter\n");
ret = g_new0(struct vehicle_priv, 1);
ret->cbl = cbl;
ret->cb=callback_new_1(callback_cast(vehicle_android_callback), ret);
*meth = vehicle_android_methods;
vehicle_android_init(ret);
dbg(0, "return\n");
return ret;
}
static struct vehicle_priv *
vehicle_demo_new(struct vehicle_methods
*meth, struct callback_list
*cbl, struct attr **attrs)
{
struct vehicle_priv *ret;
dbg(1, "enter\n");
ret = g_new0(struct vehicle_priv, 1);
ret->cbl = cbl;
ret->interval=1000;
ret->config_speed=40;
ret->timer_callback=callback_new_1(callback_cast(vehicle_demo_timer), ret);
*meth = vehicle_demo_methods;
while (attrs && *attrs)
vehicle_demo_set_attr_do(ret, *attrs++);
if (!ret->timer)
ret->timer=event_add_timeout(ret->interval, 1, ret->timer_callback);
return ret;
}
static void event_sdl_main_loop_run(void) {
#ifdef USE_WEBOS_ACCELEROMETER
struct callback* accel_cb = NULL;
struct event_timeout* accel_to = NULL;
if (PDL_GetPDKVersion() > 100) {
accel_cb = callback_new_1(callback_cast(sdl_accelerometer_handler), gr);
accel_to = event_add_timeout(200, 1, accel_cb);
}
#endif
graphics_sdl_idle(NULL);
event_sdl_watch_stopthread();
#ifdef USE_WEBOS_ACCELEROMETER
SDL_JoystickClose(accelerometer);
if (PDL_GetPDKVersion() > 100) {
event_remove_timeout(accel_to);
callback_destroy(accel_cb);
}
#endif
}
struct graphics_opengl_window_system *
graphics_opengl_x11_new(void *displayname, int w, int h, int depth, struct graphics_opengl_window_system_methods **methods)
{
struct graphics_opengl_window_system *ret=g_new0(struct graphics_opengl_window_system, 1);
XSetWindowAttributes attributes;
unsigned long valuemask;
ret->cb=callback_new_1(callback_cast(graphics_opengl_x11_watch), ret);
if (!event_request_system("glib", "graphics_opengl_x11_new"))
goto error;
*methods=&graphics_opengl_x11_methods;
ret->display=XOpenDisplay(displayname);
if (!ret->display) {
dbg(lvl_error,"failed to open display\n");
goto error;
}
ret->watch=event_add_watch(ConnectionNumber(ret->display), event_watch_cond_read, ret->cb);
ret->screen=XDefaultScreen(ret->display);
ret->root_window=RootWindow(ret->display, ret->screen);
if (!XMatchVisualInfo(ret->display, ret->screen, depth, TrueColor, &ret->visual)) {
dbg(lvl_error,"failed to find visual\n");
goto error;
}
ret->colormap=XCreateColormap(ret->display, ret->root_window, ret->visual.visual, AllocNone);
valuemask = /* CWBackPixel | */ CWBorderPixel | CWEventMask | CWColormap ; // | CWBackingStore;
attributes.colormap = ret->colormap;
attributes.border_pixel = 0;
attributes.event_mask = StructureNotifyMask | ExposureMask | ButtonPressMask | ButtonMotionMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask;
attributes.backing_store = Always;
ret->window=XCreateWindow(ret->display, RootWindow(ret->display, ret->screen), 0, 0, w, h, 0, ret->visual.depth, InputOutput, ret->visual.visual, valuemask, &attributes);
XMapWindow(ret->display, ret->window);
XFlush(ret->display);
graphics_opengl_x11_watch(ret);
return ret;
error:
graphics_opengl_x11_destroy(ret);
return NULL;
}
static struct vehicle_priv *
vehicle_webos_new(struct vehicle_methods
*meth, struct callback_list
*cbl, struct attr **attrs)
{
struct vehicle_priv *priv;
priv = g_new0(struct vehicle_priv, 1);
priv->attrs = attrs;
priv->cbl = cbl;
priv->timeout_cb = callback_new_1(callback_cast(vehicle_webos_timeout_callback), priv);
*meth = vehicle_webos_methods;
while (*attrs) {
vehicle_webos_set_attr_do(priv, *attrs, 1);
attrs++;
}
vehicle_webos_open(priv);
return priv;
}
/** @fn static struct vehicle_priv * vehicle_file_new_file(
* struct vehicle_methods *meth,
* struct callback_list *cbl,
* struct attr **attrs)
*****************************************************************************
* @b Description: Function called to initialize the plugin
*****************************************************************************
* @param meth : ?
* @param cbl : ?
* @param attrs : ?
*****************************************************************************
* @return pointer on the private data of the plugin
*****************************************************************************
* @remarks private data is allocated by this function (g_new0)
*****************************************************************************
**/
static struct vehicle_priv *
vehicle_file_new_file(struct vehicle_methods
*meth, struct callback_list
*cbl, struct attr **attrs)
{
struct vehicle_priv *ret;
struct attr *source;
struct attr *time;
struct attr *on_eof;
struct attr *baudrate;
struct attr *checksum_ignore;
dbg(1, "enter\n");
source = attr_search(attrs, NULL, attr_source);
if(source == NULL){
dbg(0,"Missing source attribute");
return NULL;
}
ret = g_new0(struct vehicle_priv, 1); // allocate and initialize to 0
ret->fd = -1;
ret->cbl = cbl;
ret->source = g_strdup(source->u.str);
ret->buffer = g_malloc(buffer_size);
ret->time=1000;
ret->baudrate=B4800;
time = attr_search(attrs, NULL, attr_time);
if (time)
ret->time=time->u.num;
baudrate = attr_search(attrs, NULL, attr_baudrate);
if (baudrate) {
switch (baudrate->u.num) {
case 4800:
ret->baudrate=B4800;
break;
case 9600:
ret->baudrate=B9600;
break;
case 19200:
ret->baudrate=B19200;
break;
#ifdef B38400
case 38400:
ret->baudrate=B38400;
break;
#endif
#ifdef B57600
case 57600:
ret->baudrate=B57600;
break;
#endif
#ifdef B115200
case 115200:
ret->baudrate=B115200;
break;
#endif
}
}
checksum_ignore = attr_search(attrs, NULL, attr_checksum_ignore);
if (checksum_ignore)
ret->checksum_ignore=checksum_ignore->u.num;
ret->attrs = attrs;
on_eof = attr_search(attrs, NULL, attr_on_eof);
if (on_eof && !strcasecmp(on_eof->u.str, "stop"))
ret->on_eof=1;
if (on_eof && !strcasecmp(on_eof->u.str, "exit"))
ret->on_eof=2;
dbg(0,"on_eof=%d\n", ret->on_eof);
*meth = vehicle_file_methods;
ret->cb=callback_new_1(callback_cast(vehicle_file_io), ret);
ret->cbt=callback_new_1(callback_cast(vehicle_file_enable_watch_timer), ret);
ret->sat_item.type=type_position_sat;
ret->sat_item.id_hi=ret->sat_item.id_lo=0;
ret->sat_item.priv_data=ret;
ret->sat_item.meth=&vehicle_file_sat_methods;
#ifdef _WIN32
ret->no_data_count = 0;
#endif
dbg(1, "vehicle_file_new_file:open\n");
if (!vehicle_file_open(ret)) {
dbg(0, "Failed to open '%s'\n", ret->source);
}
vehicle_file_enable_watch(ret);
// vehicle_file_destroy(ret);
// return NULL;
dbg(1, "leave\n");
return ret;
}
static struct vehicle_priv *
vehicle_wince_new(struct vehicle_methods
*meth, struct callback_list
*cbl, struct attr **attrs)
{
struct vehicle_priv *ret;
struct attr *source;
struct attr *time;
struct attr *on_eof;
struct attr *baudrate;
struct attr *checksum_ignore;
struct attr *handle_bluetooth;
char *cp;
dbg(1, "enter\n");
source = attr_search(attrs, NULL, attr_source);
ret = g_new0(struct vehicle_priv, 1);
ret->fd = -1;
ret->cbl = cbl;
ret->file_type = file_type_device;
cp = strchr(source->u.str,':');
if (cp)
{
if ( strncmp(source->u.str, "file", 4) == 0 )
ret->file_type = file_type_file;
cp++;
}
else
cp = source->u.str;
ret->source = g_strdup(cp);
ret->buffer = g_malloc(buffer_size);
ret->time=1000;
ret->baudrate=0; // do not change the rate if not configured
time = attr_search(attrs, NULL, attr_time);
if (time)
ret->time=time->u.num;
baudrate = attr_search(attrs, NULL, attr_baudrate);
if (baudrate) {
ret->baudrate = baudrate->u.num;
}
checksum_ignore = attr_search(attrs, NULL, attr_checksum_ignore);
if (checksum_ignore)
ret->checksum_ignore=checksum_ignore->u.num;
ret->attrs = attrs;
on_eof = attr_search(attrs, NULL, attr_on_eof);
if (on_eof && !strcasecmp(on_eof->u.str, "stop"))
ret->on_eof=1;
if (on_eof && !strcasecmp(on_eof->u.str, "exit"))
ret->on_eof=2;
dbg(0,"on_eof=%d\n", ret->on_eof);
*meth = vehicle_wince_methods;
ret->priv_cbl = callback_list_new();
callback_list_add(ret->priv_cbl, callback_new_1(callback_cast(vehicle_wince_io), ret));
ret->sat_item.type=type_position_sat;
ret->sat_item.id_hi=ret->sat_item.id_lo=0;
ret->sat_item.priv_data=ret;
ret->sat_item.meth=&vehicle_wince_sat_methods;
ret->read_buffer = g_malloc(buffer_size);
handle_bluetooth = attr_search(attrs, NULL, attr_bluetooth);
if ( handle_bluetooth && handle_bluetooth->u.num == 1 )
initBth(ret);
if (vehicle_wince_open(ret)) {
vehicle_wince_enable_watch(ret);
return ret;
}
dbg(0, "Failed to open '%s'\n", ret->source);
vehicle_wince_destroy(ret);
return NULL;
}
/** @fn static int vehicle_file_open(struct vehicle_priv *priv)
*****************************************************************************
* @b Description: open dialogue with the GPS
*****************************************************************************
* @param priv : pointer on the private data of the plugin
*****************************************************************************
* @return 1 if ok
* 0 if error
*****************************************************************************
**/
static int
vehicle_file_open(struct vehicle_priv *priv)
{
char *name;
#ifndef _WIN32
struct termios tio;
#else
#define O_NDELAY 0
#endif
name = priv->source + 5;
if (!strncmp(priv->source, "file:", 5)) {
priv->fd = open(name, O_RDONLY | O_NDELAY);
if (priv->fd < 0)
return 0;
if (file_is_reg(name)) {
priv->file_type = file_type_file;
}
#ifndef _WIN32
else {
tcgetattr(priv->fd, &tio);
cfmakeraw(&tio);
cfsetispeed(&tio, priv->baudrate);
cfsetospeed(&tio, priv->baudrate);
tio.c_cc[VMIN] = 0;
tio.c_cc[VTIME] = 200;
tcsetattr(priv->fd, TCSANOW, &tio);
priv->file_type = file_type_device;
}
} else if (!strncmp(priv->source,"pipe:", 5)) {
priv->file = popen(name, "r");
if (!priv->file)
return 0;
priv->fd = fileno(priv->file);
priv->file_type = file_type_pipe;
#endif //!_WIN32
#if defined(HAVE_SOCKET) || defined(HAVE_WINSOCK)
} else if (!strncmp(priv->source,"socket:", 7)) {
#ifdef _WIN32
WSADATA wsi;
WSAStartup(0x00020002,&wsi);
#endif
char *p,*s=g_strdup(priv->source+7);
struct sockaddr_in sin;
p=strchr(s,':');
if (!p) {
dbg(0,"port number missing in %s\n",s);
g_free(s);
return 0;
}
*p++='\0';
sin.sin_family=AF_INET;
sin.sin_port=ntohs(atoi(p));
if (!inet_aton(s, &sin.sin_addr)) {
dbg(0,"failed to parse %s\n",s);
g_free(s);
return 0;
}
priv->fd = socket(PF_INET, SOCK_STREAM, 0);
if (priv->fd != -1) {
if (connect(priv->fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
dbg(0,"failed to connect to %s:%s\n",s,p);
g_free(s);
return 0;
}
}
priv->file_type = file_type_socket;
#endif //HAVE_SOCKET
} else if (!strncmp(priv->source,"serial:",7)) {
#ifdef _WIN32
char* raw_setting_str = g_strdup( priv->source );
char* strport = strchr(raw_setting_str, ':' );
char* strsettings = strchr(raw_setting_str, ' ' );
if ( strport && strsettings )
{
strport++;
*strsettings = '\0';
strsettings++;
priv->fd=serial_io_init( strport, strsettings );
}
g_free( raw_setting_str );
priv->file_type = file_type_serial;
// Add the callback
dbg(2, "Add the callback ...\n", priv->source);
priv->timeout_callback=callback_new_1(callback_cast(vehicle_win32_serial_track), priv);
#else
//TODO - add linux serial
#endif //!_WIN32
}
return(priv->fd != -1);
}
