navit/navit/osd.c

/**
 * ZANavi, Zoff Android Navigation system.
 * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <glib.h>
#include "debug.h"
#include "plugin.h"
#include "item.h"
#include "color.h"
#include "point.h"
#include "navit.h"
#include "graphics.h"
#include "command.h"
#include "callback.h"
#include "osd.h"

struct osd
{
        struct osd_methods meth;
        struct osd_priv *priv;
};

static GHashTable *osd_hash = NULL;

struct osd *
osd_new(struct attr *parent, struct attr **attrs)
{
        struct attr *attr;
        struct osd *o;
        struct osd_priv *(*new)(struct navit *nav, struct osd_methods *meth, struct attr **attrs);
        struct attr *type = attr_search(attrs, NULL, attr_type);

        if (!type)
        {
                return NULL;
        }

        //dbg(0, "oo 001\n");
        new = plugin_get_osd_type(type->u.str);
        //dbg(0, "oo 002\n");
        if (!new)
        {
                return NULL;
        }

        o=g_new0(struct osd, 1);
        //dbg(0, "oo 003\n");
        o->priv = new(parent->u.navit, &o->meth, attrs);
        //dbg(0, "oo 004\n");

        attr = attr_search(attrs, NULL, attr_name);
        if (attr && attr->u.str)
        {
                if (NULL == osd_hash)
                {
                        //dbg(0, "oo 005\n");
                        osd_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free_func, NULL);
                }
                //dbg(0, "oo 006\n");
                g_hash_table_insert(osd_hash, g_strdup(attr->u.str), o);
        }
        //dbg(0, "oo 007\n");

        return o;
}

struct osd*
osd_get_osd_by_name(char *name)
{
        return g_hash_table_lookup(osd_hash, name);
}

int osd_set_attr(struct osd *osd, struct attr* attr)
{
        if (osd && osd->meth.set_attr)
        {
                osd->meth.set_attr(osd->priv, attr);
        }
        return 0;
}

void osd_wrap_point(struct point *p, struct navit *nav)
{
        if (p->x < 0)
                p->x += navit_get_width(nav);
        if (p->y < 0)
                p->y += navit_get_height(nav);

}

static void osd_evaluate_command(struct osd_item *this, struct navit *nav)
{
        struct attr navit;
        navit.type = attr_navit;
        navit.u.navit = nav;
        //dbg(0, "calling command '%s'\n", this->command);
        command_evaluate(&navit, this->command);
}

void osd_std_click(struct osd_item *this, struct navit *nav, int pressed, int button, struct point *p)
{
        /*
         struct point bp = this->p;
         if (!this->command || !this->command[0])
         return;
         osd_wrap_point(&bp, nav);
         if ((p->x < bp.x || p->y < bp.y || p->x > bp.x + this->w || p->y > bp.y + this->h || !this->configured) && !this->pressed)
         return;
         if (button != 1)
         return;
         if (!!pressed == !!this->pressed)
         return;
         if (navit_ignore_button(nav))
         return;
         this->pressed = pressed;
         if (pressed && this->command)
         osd_evaluate_command(this, nav);
         */
}

void osd_std_resize(struct osd_item *item)
{
        // graphics_overlay_resize(item->gr, &item->p, item->w, item->h, 65535, 1);
}

static void osd_std_calculate_sizes(struct osd_item *item, struct osd_priv *priv, int w, int h)
{
        /*
         struct attr vehicle_attr;

         if (item->rel_w) {
         item->w = (item->rel_w * w) / 100;
         }

         if (item->rel_h) {
         item->h = (item->rel_h * h) / 100;
         }

         if (item->rel_x) {
         item->p.x = (item->rel_x * w) / 100;
         }

         if (item->rel_y) {
         item->p.y = (item->rel_y * h) / 100;
         }

         osd_std_resize(item);
         if (item->meth.draw) {
         if (navit_get_attr(item->navit, attr_vehicle, &vehicle_attr, NULL)) {
         item->meth.draw(priv, item->navit, vehicle_attr.u.vehicle);
         }
         }
         */
}

static void osd_std_keypress(struct osd_item *item, struct navit *nav, char *key)
{
#if 0
        int i;
        dbg(0,"key=%s\n",key);
        for (i = 0; i < strlen(key); i++)
        {
                dbg(0,"key:0x%02x\n",key[i]);
        }
        for (i = 0; i < strlen(item->accesskey); i++)
        {
                dbg(0,"accesskey:0x%02x\n",item->accesskey[i]);
        }
#endif
        if (item->accesskey && key && !strcmp(key, item->accesskey))
                osd_evaluate_command(item, nav);
}

static void osd_std_reconfigure(struct osd_item *item, struct command_saved *cs)
{
        /*
         if (!command_saved_error(cs)) {
         graphics_overlay_disable(item->gr, !command_saved_get_int(cs));
         } else {
         dbg(0, "Error in saved command: %i\n", command_saved_error(cs));
         }
         */
}

void osd_set_std_attr(struct attr **attrs, struct osd_item *item, int flags)
{
        struct attr *attr;

        item->flags = flags;
        item->osd_configuration = -1;
        item->color_white.r = 0xffff;
        item->color_white.g = 0xffff;
        item->color_white.b = 0xffff;
        item->color_white.a = 0xffff;
        item->text_color.r = 0xffff;
        item->text_color.g = 0xffff;
        item->text_color.b = 0xffff;
        item->text_color.a = 0xffff;
        if (flags & 1)
        {
                item->color_bg.r = 0x0808;
                item->color_bg.g = 0x0808;
                item->color_bg.b = 0xf8f8;
                item->color_bg.a = 0x0000;
        }
        else
        {
                item->color_bg.r = 0x0;
                item->color_bg.g = 0x0;
                item->color_bg.b = 0x0;
                item->color_bg.a = 0x5fff;
        }

        attr = attr_search(attrs, NULL, attr_osd_configuration);
        if (attr)
                item->osd_configuration = attr->u.num;

        attr = attr_search(attrs, NULL, attr_enable_expression);
        if (attr)
        {
                item->enable_cs = command_saved_new(attr->u.str, item->navit, NULL);
        }

        attr = attr_search(attrs, NULL, attr_w);
        if (attr)
        {
                if (attr->u.num > ATTR_REL_MAXABS)
                {
                        item->rel_w = attr->u.num - ATTR_REL_RELSHIFT;
                }
                else
                {
                        item->rel_w = 0;
                        item->w = attr->u.num;
                }
        }

        attr = attr_search(attrs, NULL, attr_h);
        if (attr)
        {
                if (attr->u.num > ATTR_REL_MAXABS)
                {
                        item->rel_h = attr->u.num - ATTR_REL_RELSHIFT;
                }
                else
                {
                        item->rel_h = 0;
                        item->h = attr->u.num;
                }
        }

        attr = attr_search(attrs, NULL, attr_x);
        if (attr)
        {
                if (attr->u.num > ATTR_REL_MAXABS)
                {
                        item->rel_x = attr->u.num - ATTR_REL_RELSHIFT;
                }
                else
                {
                        item->rel_x = 0;
                        item->p.x = attr->u.num;
                }
        }

        attr = attr_search(attrs, NULL, attr_y);
        if (attr)
        {
                if (attr->u.num > ATTR_REL_MAXABS)
                {
                        item->rel_y = attr->u.num - ATTR_REL_RELSHIFT;
                }
                else
                {
                        item->rel_y = 0;
                        item->p.y = attr->u.num;
                }
        }

        attr = attr_search(attrs, NULL, attr_font_size);
        if (attr)
                item->font_size = attr->u.num;

        attr = attr_search(attrs, NULL, attr_background_color);
        if (attr)
                item->color_bg = *attr->u.color;
        attr = attr_search(attrs, NULL, attr_command);
        if (attr)
                item->command = g_strdup(attr->u.str);
        attr = attr_search(attrs, NULL, attr_text_color);
        if (attr)
                item->text_color = *attr->u.color;
        attr = attr_search(attrs, NULL, attr_flags);
        if (attr)
                item->attr_flags = attr->u.num;
        attr = attr_search(attrs, NULL, attr_accesskey);
        if (attr)
                item->accesskey = g_strdup(attr->u.str);
        attr = attr_search(attrs, NULL, attr_font);
        if (attr)
                item->font_name = g_strdup(attr->u.str);

}
void osd_std_config(struct osd_item *item, struct navit *navit)
{
        struct attr attr;
        //dbg(1, "enter\n");
        if (item->enable_cs)
        {
                item->reconfig_cb = callback_new_1(callback_cast(osd_std_reconfigure), item);
                command_saved_set_cb(item->enable_cs, item->reconfig_cb);

                if (!command_saved_error(item->enable_cs))
                {
                        item->configured = !!command_saved_get_int(item->enable_cs);
                }
                else
                {
                        //dbg(0, "Error in saved command: %i.\n", command_saved_error(item->enable_cs));
                }
        }
        else
        {
                if (!navit_get_attr(navit, attr_osd_configuration, &attr, NULL))
                        attr.u.num = -1;
                item->configured = !!(attr.u.num & item->osd_configuration);
        }

        //if (item->gr && !(item->flags & 16)) 
        //      graphics_overlay_disable(item->gr, !item->configured);
}

void osd_set_std_config(struct navit *nav, struct osd_item *item)
{
        item->cb = callback_new_attr_2(callback_cast(osd_std_config), attr_osd_configuration, item, nav);
        callback_add_names(item->cb, "osd_set_std_config", "osd_std_config");
        navit_add_callback(nav, item->cb);
        osd_std_config(item, nav);
}

void osd_set_std_graphic(struct navit *nav, struct osd_item *item, struct osd_priv *priv)
{
        // struct graphics *navit_gr;

        // navit_gr = navit_get_graphics(nav);
        item->gr = NULL;
        // DISABLE OVERLAYS // graphics_overlay_new(navit_gr, &item->p, item->w, item->h, 65535, 1);

        // item->graphic_bg = graphics_gc_new(item->gr);
        // graphics_gc_set_foreground(item->graphic_bg, &item->color_bg);
        // graphics_background_gc(item->gr, item->graphic_bg);

        // item->graphic_fg_white = graphics_gc_new(item->gr);
        // graphics_gc_set_foreground(item->graphic_fg_white, &item->color_white);

        // if (item->flags & 2) {
        //      item->font = graphics_named_font_new(item->gr, item->font_name, item->font_size, 1);
        //      item->graphic_fg_text = graphics_gc_new(item->gr);
        //      graphics_gc_set_foreground(item->graphic_fg_text, &item->text_color);
        // }

        osd_set_std_config(nav, item);

        item->resize_cb = callback_new_attr_2(callback_cast(osd_std_calculate_sizes), attr_resize, item, priv);
        callback_add_names(item->resize_cb, "osd_set_std_graphic", "osd_std_calculate_sizes");

        // graphics_add_callback(navit_gr, item->resize_cb);
        //dbg(0, "accesskey %s\n", item->accesskey);
        // if (item->accesskey) {
        //      item->keypress_cb=callback_new_attr_2(callback_cast(osd_std_keypress), attr_keypress, item, nav);
        //      graphics_add_callback(navit_gr, item->keypress_cb);
        // }

}

void osd_std_draw(struct osd_item *item)
{
        /*

         struct point p[2];
         int flags=item->attr_flags;

         graphics_draw_mode(item->gr, draw_mode_begin);
         p[0].x=0;
         p[0].y=0;
         graphics_draw_rectangle(item->gr, item->graphic_bg, p, item->w, item->h);
         p[1].x=item->w-1;
         p[1].y=0;
         if (flags & 1)
         graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
         p[0].x=item->w-1;
         p[0].y=item->h-1;
         if (flags & 2)
         graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
         p[1].x=0;
         p[1].y=item->h-1;
         if (flags & 4)
         graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
         p[0].x=0;
         p[0].y=0;
         if (flags & 8)
         graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);

         */
}

1	/**
2	* ZANavi, Zoff Android Navigation system.
3	* Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* version 2 as published by the Free Software Foundation.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the
16	* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17	* Boston, MA 02110-1301, USA.
18	*/
19
20	/**
21	* Navit, a modular navigation system.
22	* Copyright (C) 2005-2008 Navit Team
23	*
24	* This program is free software; you can redistribute it and/or
25	* modify it under the terms of the GNU General Public License
26	* version 2 as published by the Free Software Foundation.
27	*
28	* This program is distributed in the hope that it will be useful,
29	* but WITHOUT ANY WARRANTY; without even the implied warranty of
30	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31	* GNU General Public License for more details.
32	*
33	* You should have received a copy of the GNU General Public License
34	* along with this program; if not, write to the
35	* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
36	* Boston, MA 02110-1301, USA.
37	*/
38
39	#include <glib.h>
40	#include "debug.h"
41	#include "plugin.h"
42	#include "item.h"
43	#include "color.h"
44	#include "point.h"
45	#include "navit.h"
46	#include "graphics.h"
47	#include "command.h"
48	#include "callback.h"
49	#include "osd.h"
50
51	struct osd
52	{
53	struct osd_methods meth;
54	struct osd_priv *priv;
55	};
56
57	static GHashTable *osd_hash = NULL;
58
59	struct osd *
60	osd_new(struct attr parent, struct attr *attrs)
61	{
62	struct attr *attr;
63	struct osd *o;
64	struct osd_priv (new)(struct navit nav, struct osd_methods meth, struct attr **attrs);
65	struct attr *type = attr_search(attrs, NULL, attr_type);
66
67	if (!type)
68	{
69	return NULL;
70	}
71
72	//dbg(0, "oo 001\n");
73	new = plugin_get_osd_type(type->u.str);
74	//dbg(0, "oo 002\n");
75	if (!new)
76	{
77	return NULL;
78	}
79
80	o=g_new0(struct osd, 1);
81	//dbg(0, "oo 003\n");
82	o->priv = new(parent->u.navit, &o->meth, attrs);
83	//dbg(0, "oo 004\n");
84
85	attr = attr_search(attrs, NULL, attr_name);
86	if (attr && attr->u.str)
87	{
88	if (NULL == osd_hash)
89	{
90	//dbg(0, "oo 005\n");
91	osd_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free_func, NULL);
92	}
93	//dbg(0, "oo 006\n");
94	g_hash_table_insert(osd_hash, g_strdup(attr->u.str), o);
95	}
96	//dbg(0, "oo 007\n");
97
98	return o;
99	}
100
101	struct osd*
102	osd_get_osd_by_name(char *name)
103	{
104	return g_hash_table_lookup(osd_hash, name);
105	}
106
107	int osd_set_attr(struct osd osd, struct attr attr)
108	{
109	if (osd && osd->meth.set_attr)
110	{
111	osd->meth.set_attr(osd->priv, attr);
112	}
113	return 0;
114	}
115
116	void osd_wrap_point(struct point p, struct navit nav)
117	{
118	if (p->x < 0)
119	p->x += navit_get_width(nav);
120	if (p->y < 0)
121	p->y += navit_get_height(nav);
122
123	}
124
125	static void osd_evaluate_command(struct osd_item this, struct navit nav)
126	{
127	struct attr navit;
128	navit.type = attr_navit;
129	navit.u.navit = nav;
130	//dbg(0, "calling command '%s'\n", this->command);
131	command_evaluate(&navit, this->command);
132	}
133
134	void osd_std_click(struct osd_item this, struct navit nav, int pressed, int button, struct point *p)
135	{
136	/*
137	struct point bp = this->p;
138	if (!this->command \|\| !this->command[0])
139	return;
140	osd_wrap_point(&bp, nav);
141	if ((p->x < bp.x \|\| p->y < bp.y \|\| p->x > bp.x + this->w \|\| p->y > bp.y + this->h \|\| !this->configured) && !this->pressed)
142	return;
143	if (button != 1)
144	return;
145	if (!!pressed == !!this->pressed)
146	return;
147	if (navit_ignore_button(nav))
148	return;
149	this->pressed = pressed;
150	if (pressed && this->command)
151	osd_evaluate_command(this, nav);
152	*/
153	}
154
155	void osd_std_resize(struct osd_item *item)
156	{
157	// graphics_overlay_resize(item->gr, &item->p, item->w, item->h, 65535, 1);
158	}
159
160	static void osd_std_calculate_sizes(struct osd_item item, struct osd_priv priv, int w, int h)
161	{
162	/*
163	struct attr vehicle_attr;
164
165	if (item->rel_w) {
166	item->w = (item->rel_w * w) / 100;
167	}
168
169	if (item->rel_h) {
170	item->h = (item->rel_h * h) / 100;
171	}
172
173	if (item->rel_x) {
174	item->p.x = (item->rel_x * w) / 100;
175	}
176
177	if (item->rel_y) {
178	item->p.y = (item->rel_y * h) / 100;
179	}
180
181	osd_std_resize(item);
182	if (item->meth.draw) {
183	if (navit_get_attr(item->navit, attr_vehicle, &vehicle_attr, NULL)) {
184	item->meth.draw(priv, item->navit, vehicle_attr.u.vehicle);
185	}
186	}
187	*/
188	}
189
190	static void osd_std_keypress(struct osd_item item, struct navit nav, char *key)
191	{
192	#if 0
193	int i;
194	dbg(0,"key=%s\n",key);
195	for (i = 0; i < strlen(key); i++)
196	{
197	dbg(0,"key:0x%02x\n",key[i]);
198	}
199	for (i = 0; i < strlen(item->accesskey); i++)
200	{
201	dbg(0,"accesskey:0x%02x\n",item->accesskey[i]);
202	}
203	#endif
204	if (item->accesskey && key && !strcmp(key, item->accesskey))
205	osd_evaluate_command(item, nav);
206	}
207
208	static void osd_std_reconfigure(struct osd_item item, struct command_saved cs)
209	{
210	/*
211	if (!command_saved_error(cs)) {
212	graphics_overlay_disable(item->gr, !command_saved_get_int(cs));
213	} else {
214	dbg(0, "Error in saved command: %i\n", command_saved_error(cs));
215	}
216	*/
217	}
218
219	void osd_set_std_attr(struct attr *attrs, struct osd_item item, int flags)
220	{
221	struct attr *attr;
222
223	item->flags = flags;
224	item->osd_configuration = -1;
225	item->color_white.r = 0xffff;
226	item->color_white.g = 0xffff;
227	item->color_white.b = 0xffff;
228	item->color_white.a = 0xffff;
229	item->text_color.r = 0xffff;
230	item->text_color.g = 0xffff;
231	item->text_color.b = 0xffff;
232	item->text_color.a = 0xffff;
233	if (flags & 1)
234	{
235	item->color_bg.r = 0x0808;
236	item->color_bg.g = 0x0808;
237	item->color_bg.b = 0xf8f8;
238	item->color_bg.a = 0x0000;
239	}
240	else
241	{
242	item->color_bg.r = 0x0;
243	item->color_bg.g = 0x0;
244	item->color_bg.b = 0x0;
245	item->color_bg.a = 0x5fff;
246	}
247
248	attr = attr_search(attrs, NULL, attr_osd_configuration);
249	if (attr)
250	item->osd_configuration = attr->u.num;
251
252	attr = attr_search(attrs, NULL, attr_enable_expression);
253	if (attr)
254	{
255	item->enable_cs = command_saved_new(attr->u.str, item->navit, NULL);
256	}
257
258	attr = attr_search(attrs, NULL, attr_w);
259	if (attr)
260	{
261	if (attr->u.num > ATTR_REL_MAXABS)
262	{
263	item->rel_w = attr->u.num - ATTR_REL_RELSHIFT;
264	}
265	else
266	{
267	item->rel_w = 0;
268	item->w = attr->u.num;
269	}
270	}
271
272	attr = attr_search(attrs, NULL, attr_h);
273	if (attr)
274	{
275	if (attr->u.num > ATTR_REL_MAXABS)
276	{
277	item->rel_h = attr->u.num - ATTR_REL_RELSHIFT;
278	}
279	else
280	{
281	item->rel_h = 0;
282	item->h = attr->u.num;
283	}
284	}
285
286	attr = attr_search(attrs, NULL, attr_x);
287	if (attr)
288	{
289	if (attr->u.num > ATTR_REL_MAXABS)
290	{
291	item->rel_x = attr->u.num - ATTR_REL_RELSHIFT;
292	}
293	else
294	{
295	item->rel_x = 0;
296	item->p.x = attr->u.num;
297	}
298	}
299
300	attr = attr_search(attrs, NULL, attr_y);
301	if (attr)
302	{
303	if (attr->u.num > ATTR_REL_MAXABS)
304	{
305	item->rel_y = attr->u.num - ATTR_REL_RELSHIFT;
306	}
307	else
308	{
309	item->rel_y = 0;
310	item->p.y = attr->u.num;
311	}
312	}
313
314	attr = attr_search(attrs, NULL, attr_font_size);
315	if (attr)
316	item->font_size = attr->u.num;
317
318	attr = attr_search(attrs, NULL, attr_background_color);
319	if (attr)
320	item->color_bg = *attr->u.color;
321	attr = attr_search(attrs, NULL, attr_command);
322	if (attr)
323	item->command = g_strdup(attr->u.str);
324	attr = attr_search(attrs, NULL, attr_text_color);
325	if (attr)
326	item->text_color = *attr->u.color;
327	attr = attr_search(attrs, NULL, attr_flags);
328	if (attr)
329	item->attr_flags = attr->u.num;
330	attr = attr_search(attrs, NULL, attr_accesskey);
331	if (attr)
332	item->accesskey = g_strdup(attr->u.str);
333	attr = attr_search(attrs, NULL, attr_font);
334	if (attr)
335	item->font_name = g_strdup(attr->u.str);
336
337	}
338	void osd_std_config(struct osd_item item, struct navit navit)
339	{
340	struct attr attr;
341	//dbg(1, "enter\n");
342	if (item->enable_cs)
343	{
344	item->reconfig_cb = callback_new_1(callback_cast(osd_std_reconfigure), item);
345	command_saved_set_cb(item->enable_cs, item->reconfig_cb);
346
347	if (!command_saved_error(item->enable_cs))
348	{
349	item->configured = !!command_saved_get_int(item->enable_cs);
350	}
351	else
352	{
353	//dbg(0, "Error in saved command: %i.\n", command_saved_error(item->enable_cs));
354	}
355	}
356	else
357	{
358	if (!navit_get_attr(navit, attr_osd_configuration, &attr, NULL))
359	attr.u.num = -1;
360	item->configured = !!(attr.u.num & item->osd_configuration);
361	}
362
363	//if (item->gr && !(item->flags & 16))
364	// graphics_overlay_disable(item->gr, !item->configured);
365	}
366
367	void osd_set_std_config(struct navit nav, struct osd_item item)
368	{
369	item->cb = callback_new_attr_2(callback_cast(osd_std_config), attr_osd_configuration, item, nav);
370	callback_add_names(item->cb, "osd_set_std_config", "osd_std_config");
371	navit_add_callback(nav, item->cb);
372	osd_std_config(item, nav);
373	}
374
375	void osd_set_std_graphic(struct navit nav, struct osd_item item, struct osd_priv *priv)
376	{
377	// struct graphics *navit_gr;
378
379	// navit_gr = navit_get_graphics(nav);
380	item->gr = NULL;
381	// DISABLE OVERLAYS // graphics_overlay_new(navit_gr, &item->p, item->w, item->h, 65535, 1);
382
383	// item->graphic_bg = graphics_gc_new(item->gr);
384	// graphics_gc_set_foreground(item->graphic_bg, &item->color_bg);
385	// graphics_background_gc(item->gr, item->graphic_bg);
386
387	// item->graphic_fg_white = graphics_gc_new(item->gr);
388	// graphics_gc_set_foreground(item->graphic_fg_white, &item->color_white);
389
390	// if (item->flags & 2) {
391	// item->font = graphics_named_font_new(item->gr, item->font_name, item->font_size, 1);
392	// item->graphic_fg_text = graphics_gc_new(item->gr);
393	// graphics_gc_set_foreground(item->graphic_fg_text, &item->text_color);
394	// }
395
396	osd_set_std_config(nav, item);
397
398	item->resize_cb = callback_new_attr_2(callback_cast(osd_std_calculate_sizes), attr_resize, item, priv);
399	callback_add_names(item->resize_cb, "osd_set_std_graphic", "osd_std_calculate_sizes");
400
401	// graphics_add_callback(navit_gr, item->resize_cb);
402	//dbg(0, "accesskey %s\n", item->accesskey);
403	// if (item->accesskey) {
404	// item->keypress_cb=callback_new_attr_2(callback_cast(osd_std_keypress), attr_keypress, item, nav);
405	// graphics_add_callback(navit_gr, item->keypress_cb);
406	// }
407
408	}
409
410	void osd_std_draw(struct osd_item *item)
411	{
412	/*
413
414	struct point p[2];
415	int flags=item->attr_flags;
416
417	graphics_draw_mode(item->gr, draw_mode_begin);
418	p[0].x=0;
419	p[0].y=0;
420	graphics_draw_rectangle(item->gr, item->graphic_bg, p, item->w, item->h);
421	p[1].x=item->w-1;
422	p[1].y=0;
423	if (flags & 1)
424	graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
425	p[0].x=item->w-1;
426	p[0].y=item->h-1;
427	if (flags & 2)
428	graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
429	p[1].x=0;
430	p[1].y=item->h-1;
431	if (flags & 4)
432	graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
433	p[0].x=0;
434	p[0].y=0;
435	if (flags & 8)
436	graphics_draw_lines(item->gr, item->graphic_fg_text, p, 2);
437
438	*/
439	}
440