/**
* calendar_config_get_tasks_overdue_color:
* @color: the location to store the color
*
* Queries the color to be used to display overdue tasks.
**/
void
calendar_config_get_tasks_overdue_color (GdkColor *color)
{
const gchar *key = CALENDAR_CONFIG_TASKS_OVERDUE_COLOR;
GError *error = NULL;
gchar *color_spec;
g_return_if_fail (color != NULL);
calendar_config_init ();
color_spec = gconf_client_get_string (config, key, &error);
if (color_spec != NULL && !gdk_color_parse (color_spec, color))
g_warning ("Unknown color \"%s\"", color_spec);
else if (error != NULL) {
g_warning ("%s", error->message);
g_error_free (error);
}
g_free (color_spec);
}
void
build_example1(GtkWidget *plot)
{
GdkColor color;
GtkPlotAxis *axis;
dataset = gtk_plot_add_function(GTK_PLOT(plot), (GtkPlotFunc)function);
gtk_widget_show(GTK_WIDGET(dataset));
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset,
GTK_PLOT_SYMBOL_DIAMOND,
GTK_PLOT_SYMBOL_EMPTY,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset,
GTK_PLOT_LINE_SOLID,
0, 0, 1, &color);
}
gboolean draw_city_dots_timezone_map() {
int i;
GtkWidget *drawarea = lookup_widget(MainWindow,"drawingarea1");
GdkGC *gc = gdk_gc_new(drawarea->window);
GdkColor color;
gdk_color_parse("yellow",&color);
gdk_colormap_alloc_color(gdk_colormap_get_system(),&color,TRUE,TRUE);
gtk_widget_modify_fg(drawarea,GTK_STATE_NORMAL,&color);
gdk_gc_set_foreground(gc,&color);
for (i = 0; i < timezones_count; i++) {
// debug("Drawing point %d %d of %s\n",
// map2canvas_lon(timezones[i].lon,MAP_WIDTH),
// map2canvas_lat(timezones[i].lat,MAP_HEIGHT),
// timezones[i].tz);
gdk_draw_point(drawarea->window,gc,
map2canvas_lon(timezones[i].lon,MAP_WIDTH),
map2canvas_lat(timezones[i].lat,MAP_HEIGHT));
}
g_object_unref(gc);
return TRUE;
}
static gboolean cb_hime_win_color( GtkWidget *widget,
gpointer data)
{
COLORSEL *sel = (COLORSEL *)data;
GtkWidget *color_selector = gtk_color_selection_dialog_new (_(sel->title));
gdk_color_parse(*sel->color_str, sel->color);
gtk_color_selection_set_current_color(
GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(color_selector))),
sel->color);
sel->color_selector = color_selector;
gtk_widget_show((GtkWidget*)color_selector);
if (gtk_dialog_run(GTK_DIALOG(color_selector)) == GTK_RESPONSE_OK)
cb_save_hime_win_color((GtkWidget *)color_selector, (gpointer) sel);
gtk_widget_destroy(color_selector);
return TRUE;
}
void populate_note_popup(GtkTextView *entry, GtkMenu *menu, Note *note)
{
GtkWidget *color_menu;
GtkWidget *color_item;
GtkWidget *item;
GtkWidget *label;
GtkWidget *color_box;
GtkWidget *hbox;
GdkColor gcolor;
int i;
color_menu = gtk_menu_new();
color_item = gtk_menu_item_new_with_label("Color");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(color_item), color_menu);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), color_item);
current_note = note;
for(i=0; i < num_color_schemes; i++) {
item = gtk_menu_item_new();
label = gtk_label_new(color_schemes[i].name);
color_box = gtk_event_box_new();
gtk_widget_set_size_request(color_box, 15, -1);
hbox = gtk_hbox_new(FALSE, 4);
gdk_color_parse(color_schemes[i].top, &gcolor);
gtk_widget_modify_bg(color_box, GTK_STATE_NORMAL, &gcolor);
gtk_widget_modify_bg(color_box, GTK_STATE_PRELIGHT, &gcolor);
gtk_container_add(GTK_CONTAINER(item), hbox);
gtk_box_pack_start(GTK_BOX(hbox), color_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), item);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(set_current_note_color), &color_schemes[i]);
}
gtk_widget_show_all(GTK_WIDGET(menu));
}
void
drawindicator(Client *c) {
gint width;
gchar *uri;
GtkWidget *w;
GdkGC *gc;
GdkColor fg;
uri = geturi(c);
w = c->indicator;
width = c->progress * w->allocation.width / 100;
gc = gdk_gc_new(w->window);
gdk_color_parse(strstr(uri, "https://") == uri ?
progress_trust : progress, &fg);
gdk_gc_set_rgb_fg_color(gc, &fg);
gdk_draw_rectangle(w->window,
w->style->bg_gc[GTK_WIDGET_STATE(w)],
TRUE, 0, 0, w->allocation.width, w->allocation.height);
gdk_draw_rectangle(w->window, gc, TRUE, 0, 0, width,
w->allocation.height);
g_object_unref(gc);
}
/* TODO: share this code with file.c */
VikLayerTypedParamData *layer_data_typed_param_copy_from_string ( guint8 type, const gchar *str )
{
g_assert ( type != VIK_LAYER_PARAM_STRING_LIST );
VikLayerTypedParamData *rv = g_new(VikLayerTypedParamData,1);
rv->type = type;
switch ( type )
{
case VIK_LAYER_PARAM_DOUBLE: rv->data.d = strtod(str, NULL); break;
case VIK_LAYER_PARAM_UINT: rv->data.u = strtoul(str, NULL, 10); break;
case VIK_LAYER_PARAM_INT: rv->data.i = strtol(str, NULL, 10); break;
case VIK_LAYER_PARAM_BOOLEAN: rv->data.b = TEST_BOOLEAN(str); break;
case VIK_LAYER_PARAM_COLOR: memset(&(rv->data.c), 0, sizeof(rv->data.c)); /* default: black */
gdk_color_parse ( str, &(rv->data.c) ); break;
/* STRING or STRING_LIST -- if STRING_LIST, just set param to add a STRING */
default: {
gchar *s = g_strdup(str);
rv->data.s = s;
rv->freeme = s;
}
}
return rv;
}
static GtkCssValue *
gtk_css_custom_property_create_initial_value (GParamSpec *pspec)
{
GValue value = G_VALUE_INIT;
GtkCssValue *result;
g_value_init (&value, pspec->value_type);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (pspec->value_type == GTK_TYPE_THEMING_ENGINE)
g_value_set_object (&value, gtk_theming_engine_load (NULL));
else if (pspec->value_type == PANGO_TYPE_FONT_DESCRIPTION)
g_value_take_boxed (&value, pango_font_description_from_string ("Sans 10"));
else if (pspec->value_type == GDK_TYPE_RGBA)
{
GdkRGBA color;
gdk_rgba_parse (&color, "pink");
g_value_set_boxed (&value, &color);
}
else if (pspec->value_type == g_type_from_name ("GdkColor"))
{
GdkColor color;
gdk_color_parse ("pink", &color);
g_value_set_boxed (&value, &color);
}
else if (pspec->value_type == GTK_TYPE_BORDER)
{
g_value_take_boxed (&value, gtk_border_new ());
}
else
g_param_value_set_default (pspec, &value);
G_GNUC_END_IGNORE_DEPRECATIONS
result = _gtk_css_typed_value_new (&value);
g_value_unset (&value);
return result;
}
/**
* uber_line_graph_add_line:
* @graph: A #UberLineGraph.
* @color: A #GdkColor for the line or %NULL.
*
* Adds a new line to the graph. If color is %NULL, the next value
* in the default color list will be used.
*
* See uber_line_graph_remove_line().
*
* Returns: The line identifier.
* Side effects: None.
*/
guint
uber_line_graph_add_line (UberLineGraph *graph, /* IN */
const GdkColor *color) /* IN */
{
UberLineGraphPrivate *priv;
LineInfo info = { { 0 } };
g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), 0);
priv = graph->priv;
/*
* Retrieve the lines color.
*/
if (color) {
info.color = *color;
} else {
gdk_color_parse("#729fcf", &info.color);
}
/*
* Allocate buffers for data points.
*/
info.raw_data = g_ring_sized_new(sizeof(gdouble), priv->stride, NULL);
info.scaled_data = g_ring_sized_new(sizeof(gdouble), priv->stride, NULL);
uber_line_graph_init_ring(info.raw_data);
uber_line_graph_init_ring(info.scaled_data);
/*
* Store the newly crated line.
*/
g_array_append_val(priv->lines, info);
/*
* Mark the graph for full redraw.
*/
uber_graph_redraw(UBER_GRAPH(graph));
/*
* Line indexes start from 1.
*/
return priv->lines->len;
}
static void
sload_read_config(Control *ctrl, xmlNodePtr node)
{
xmlChar *value;
t_sload *sload;
sload = (t_sload *)ctrl->data;
if (node == NULL || node->children == NULL)
return;
node = node->children;
if (!xmlStrEqual(node->name, (const xmlChar *)SLOAD_ROOT))
return;
if ((value = xmlGetProp(node, (const xmlChar *)"Use_Label")))
{
sload->options.use_label = atoi(value);
g_free(value);
}
if ((value = xmlGetProp(node, (const xmlChar *)"Color")))
{
gdk_color_parse(value, &sload->options.color);
g_free(value);
}
if ((value = xmlGetProp(node, (const xmlChar *) "Text")))
{
if (sload->options.label_text)
g_free(sload->options.label_text);
sload->options.label_text = g_strdup((gchar *)value);
g_free(value);
}
setup_sload(sload);
}
void load_lastwallpaperfile_cb ( GtkWidget *widget, AnypaperWindow *window )
{
GtkWidget *dialog;
GdkColor color;
gint positionx, positiony, rangex, rangey;
dialog = gtk_file_chooser_dialog_new ("Open File", GTK_WINDOW(window->priv->window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), lastwallpaperfile);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
block_callback(window);
g_free(lastwallpaperfile);
lastwallpaperfile = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
anypaper_parameters_load(window->parameters, lastwallpaperfile);
positionx = window->parameters->positionx;
positiony = window->parameters->positiony;
anypaper_image_make (window->image, window->parameters);
rangex = window->parameters->positionx;
rangey = window->parameters->positiony;
anypaper_parameters_position_test(window->parameters, rangex, rangey, positionx, positiony);
anypaper_image_move (window->image, window->parameters);
gtk_entry_set_text (GTK_ENTRY (window->priv->file_entry), window->parameters->file);
anypaper_window_set_position_range(window, rangex, rangey);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (window->priv->spin1), window->parameters->positionx);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (window->priv->spin2), window->parameters->positiony);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (window->priv->spin3), window->parameters->width);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (window->priv->spin4), window->parameters->height);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (window->priv->spin5), window->parameters->scalex);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (window->priv->spin6), window->parameters->scaley);
gtk_combo_box_set_active (GTK_COMBO_BOX (window->priv->combo), window->parameters->style);
gdk_color_parse (window->parameters->background, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON(window->priv->cbutton), &color);
gtk_image_set_from_pixbuf(GTK_IMAGE(window->priv->preview), window->image->preview);
unblock_callback(window);
}
gtk_widget_destroy (dialog);
}
/* start == -1 for all */
extern char *change_grid_color(List button_list, int start, int end,
int color_inx, bool only_change_unused,
enum node_states state_override)
{
ListIterator itr = NULL;
grid_button_t *grid_button = NULL;
GdkColor color;
char *new_col = NULL;
if (!button_list)
return NULL;
if (color_inx >= 0) {
color_inx %= sview_colors_cnt;
new_col = sview_colors[color_inx];
} else if (color_inx == MAKE_BLACK) {
new_col = blank_color;
} else if (color_inx == MAKE_TOPO_1) {
new_col = topo1_color;
} else if (color_inx == MAKE_TOPO_2) {
new_col = topo2_color;
} else
new_col = white_color;
gdk_color_parse(new_col, &color);
itr = list_iterator_create(button_list);
while ((grid_button = list_next(itr))) {
if ((start != -1) &&
((grid_button->inx < start) || (grid_button->inx > end)))
continue;
_change_button_color(grid_button, color_inx, new_col,
color, only_change_unused, state_override);
}
list_iterator_destroy(itr);
return sview_colors[color_inx];
}
void draw_rect_stroke_to_window(GdkWindow *window,
int x,
int y,
int width,
int height,
char *color_spec,
double line_width)
{
cairo_t *cr = NULL;
GdkColor color;
cr = gdk_cairo_create(window);
if (!cr)
return;
gdk_color_parse(color_spec, &color);
draw_rect_stroke_to_cr(cr, x, y, width, height, &color, line_width);
if (cr) {
cairo_destroy(cr);
cr = NULL;
}
}
manipulation manipulation_resize_new()
{
manipulation resize;
resize = (manipulation) g_malloc(sizeof(struct manip_str));
resize->type = MANIP_RESIZE;
resize->icon = &pixdata_resize;
resize->settings = (resize_settings) g_malloc(sizeof(struct manip_resize_set));
((resize_settings)resize->settings)->new_w_pc = 100.0;
((resize_settings)resize->settings)->new_h_pc = 100.0;
((resize_settings)resize->settings)->new_w_px = 640;
((resize_settings)resize->settings)->new_h_px = 480;
((resize_settings)resize->settings)->resize_mode = RESIZE_PERCENT;
((resize_settings)resize->settings)->stretch_mode = STRETCH_ALLOW;
gdk_color_parse("black", &(((resize_settings)resize->settings)->padding_color));
gdk_colormap_alloc_color(gdk_colormap_get_system(), &(((resize_settings)resize->settings)->padding_color), TRUE, TRUE);
((resize_settings)resize->settings)->padding_color_alpha = G_MAXUINT16;
((resize_settings)resize->settings)->interpolation = GIMP_INTERPOLATION_CUBIC;
((resize_settings)resize->settings)->change_res = FALSE;
((resize_settings)resize->settings)->new_res_x = 72.000;
((resize_settings)resize->settings)->new_res_y = 72.000;
return resize;
}
gboolean on_darea_expose ()
{
GdkGC *gc = gdk_gc_new(GDK_DRAWABLE(widget->window));
GdkColor color;
gdk_color_parse("RED", &color);
gdk_gc_set_foreground(gc, &color);
a+=10;
b+=10;
printf("ok");
gdk_draw_line((widget->window), gc, a, a,b,b);
return TRUE;
//gtk_timeout_add(100, (GtkFunction)draw_line(widget, gc, a, b), NULL);
}
NS_IMETHODIMP
nsGNOMEShellService::GetDesktopBackgroundColor(PRUint32 *aColor)
{
nsCOMPtr<nsIGConfService> gconf = do_GetService(NS_GCONFSERVICE_CONTRACTID);
nsCAutoString background;
gconf->GetString(NS_LITERAL_CSTRING(kDesktopColorKey), background);
if (background.IsEmpty()) {
*aColor = 0;
return NS_OK;
}
GdkColor color;
gboolean success = gdk_color_parse(background.get(), &color);
NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);
*aColor = COLOR_16_TO_8_BIT(color.red) << 16 |
COLOR_16_TO_8_BIT(color.green) << 8 |
COLOR_16_TO_8_BIT(color.blue);
return NS_OK;
}
GtkWidget *
gtk_create_menu_bar(GtkWidget *event_box) {
GtkWidget *menu_bar, *menu, *menu_items, *action_menu, *help_menu;
GdkColor color;
menu_bar = gtk_menu_bar_new();
menu = gtk_menu_new();
menu_items = gtk_menu_item_new_with_label("Restart Game");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
g_signal_connect(menu_items, "activate", G_CALLBACK(restart_game_menu_event_handler),
(gpointer) event_box);
menu_items = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
menu_items = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
g_signal_connect(menu_items, "activate", G_CALLBACK(quit_menu_event_handler),
NULL);
action_menu = gtk_menu_item_new_with_mnemonic("_Action");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(action_menu), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), action_menu);
menu = gtk_menu_new();
menu_items = gtk_menu_item_new_with_label("About");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
g_signal_connect(menu_items, "activate", G_CALLBACK(about_menu_event_handler),
(gpointer) event_box);
help_menu = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_menu), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help_menu);
gdk_color_parse(MENU_BAR_COLOR, &color);
gtk_widget_modify_bg(menu_bar, GTK_STATE_NORMAL, &color);
return menu_bar;
}
int
gtk_parse_nearest_color (struct device *d, GdkColor *color, Bufbyte *name,
Bytecount len, Error_behavior errb)
{
GdkColormap *cmap;
GdkVisual *visual;
int result;
cmap = DEVICE_GTK_COLORMAP(d);
visual = DEVICE_GTK_VISUAL (d);
xzero (*color);
{
const Extbyte *extname;
Extcount extnamelen;
TO_EXTERNAL_FORMAT (DATA, (name, len), ALLOCA, (extname, extnamelen), Qbinary);
result = gdk_color_parse (extname, color);
}
if (result == FALSE)
{
maybe_signal_simple_error ("unrecognized color", make_string (name, len),
Qcolor, errb);
return 0;
}
result = allocate_nearest_color (cmap, visual, color);
if (!result)
{
maybe_signal_simple_error ("couldn't allocate color",
make_string (name, len), Qcolor, errb);
return 0;
}
return result;
}
static void
update_background_color (GeditView *view)
{
GtkSourceView *source_view = GTK_SOURCE_VIEW (view);
GtkSourceStyle *style;
GtkSourceStyleScheme *scheme;
GtkTextBuffer *buffer;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
scheme = gtk_source_buffer_get_style_scheme (GTK_SOURCE_BUFFER (buffer));
style = gtk_source_style_scheme_get_style (scheme, "search-match");
if (style)
{
gboolean bgset;
gchar *bg;
g_object_get (style, "background-set", &bgset, "background", &bg, NULL);
if (bgset)
{
GdkColor color;
gdk_color_parse (bg, &color);
gtk_source_view_set_mark_category_background (source_view,
BOOKMARK_CATEGORY,
&color);
g_free (bg);
return;
}
}
gtk_source_view_set_mark_category_background (source_view,
BOOKMARK_CATEGORY,
NULL);
}
void change_tsin_font_size()
{
if (!top_bin)
return;
GdkColor fg;
gdk_color_parse(gcin_win_color_fg, &fg);
set_label_font_size(label_pho, gcin_font_size_tsin_pho_in);
int i;
for(i=0; i < MAX_PH_BF_EXT; i++) {
GtkWidget *label = chars[i].label;
if (!label)
continue;
set_label_font_size(label, gcin_font_size);
if (gcin_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &fg);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
}
compact_win0();
// change_win1_font();
set_win0_bg();
// change_tsin_line_color();
}
static void
wireframeInitColor (WireFrame *wireframe)
{
ScreenInfo *screen_info;
gchar *color;
GdkColor gcolor;
screen_info = wireframe->screen_info;
color = getUIStyle (myScreenGetGtkWidget (screen_info), "bg", "selected");
if (gdk_color_parse (color, &gcolor))
{
wireframe->red = (gdouble) gcolor.red / (gdouble) 65535;
wireframe->green = (gdouble) gcolor.green / (gdouble) 65535;
wireframe->blue = (gdouble) gcolor.blue / (gdouble) 65535;
}
else
{
g_warning ("Cannot parse color %s", color);
wireframe->red = 0.0;
wireframe->green = 0.5;
wireframe->blue = 1.0;
}
g_free (color);
}
void capture_left_bot_black(t_terrain* terrain, GtkWidget* button, int count)
{
t_terrain* move;
t_terrain* begin;
GdkColor black;
begin = terrain;
move = begin;
gdk_color_parse ("black", &black);
while (terrain->button != button)
terrain = terrain->next;
while (count != 0)
{
while (move->next != 0 && (move->x != terrain->x - count
|| move->y != terrain->y + count))
move = move->next;
gtk_widget_modify_bg(GTK_WIDGET(move->button), GTK_STATE_NORMAL, &black);
move->color = 2;
move = begin;
count = count - 1;
}
gtk_widget_modify_bg(GTK_WIDGET(terrain->button), GTK_STATE_NORMAL, &black);
terrain->color = 2;
}
static gint
luaH_eventbox_newindex(lua_State *L, luakit_token_t token)
{
size_t len;
widget_t *w = luaH_checkwidget(L, 1);
const gchar *tmp;
GdkColor c;
switch(token)
{
case L_TK_BG:
tmp = luaL_checklstring(L, 3, &len);
if (!gdk_color_parse(tmp, &c))
luaL_argerror(L, 3, "unable to parse colour");
gtk_widget_modify_bg(GTK_WIDGET(w->widget), GTK_STATE_NORMAL, &c);
g_object_set_data_full(G_OBJECT(w->widget), "bg", g_strdup(tmp), g_free);
break;
default:
return 0;
}
return luaH_object_emit_property_signal(L, 1);
}
static void
pref_to_color_list (void)
{
gint i;
EATreePos ep;
if (!get_color_store (&ep))
return;
/* clear list */
gtk_list_store_clear (ep.gs);
for (i = 0; pref.colors[i]; ++i)
{
GdkColor gdk_color;
gchar **colors_protocols = NULL;
gchar *protocol = NULL;
GtkTreeIter it;
colors_protocols = g_strsplit (pref.colors[i], ";", 0);
/* converting color */
gdk_color_parse (colors_protocols[0], &gdk_color);
/* converting proto name */
if (!colors_protocols[1])
protocol = "";
else
protocol = colors_protocols[1];
/* adds a new row */
gtk_list_store_append (ep.gs, &it);
gtk_list_store_set (ep.gs, &it, 0, COLSPACES, 1, &gdk_color,
2, protocol, -1);
g_strfreev(colors_protocols);
}
}
void
gthumb_draw_frame (int image_x,
int image_y,
int image_w,
int image_h,
GdkDrawable *drawable,
GdkColor *frame_color)
{
GdkGC *gc;
GdkColor white;
int frame_width;
gc = gdk_gc_new (drawable);
gdk_color_parse ("#FFFFFF", &white);
gdk_gc_set_rgb_fg_color (gc, &white);
gdk_draw_rectangle (drawable,
gc,
TRUE,
image_x, image_y,
image_w, image_h);
gdk_gc_set_rgb_fg_color (gc, frame_color);
gdk_gc_set_line_attributes (gc, FRAME_WIDTH, 0, 0, 0);
frame_width = FRAME_WIDTH - 2;
gdk_draw_rectangle (drawable,
gc,
FALSE,
image_x - frame_width,
image_y - frame_width,
image_w + (frame_width * 2) - 1,
image_h + (frame_width * 2) - 1);
g_object_unref (gc);
}
static void on_set_defaults (GtkButton* btn, gpointer ptr)
{
desktop_font = "Roboto Light 12";
gtk_font_button_set_font_name (GTK_FONT_BUTTON (font), desktop_font);
desktop_picture = "/usr/share/pixel-wallpaper/road.jpg";
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dpic), desktop_picture);
desktop_mode = "crop";
gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 3);
icon_size = 36;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb3), TRUE);
gdk_color_parse ("#4D98F5", &theme_colour);
gtk_color_button_set_color (GTK_COLOR_BUTTON (hcol), &theme_colour);
gdk_color_parse ("#D6D3DE", &desktop_colour);
gtk_color_button_set_color (GTK_COLOR_BUTTON (dcol), &desktop_colour);
gdk_color_parse ("#E8E8E8", &desktoptext_colour);
gtk_color_button_set_color (GTK_COLOR_BUTTON (dtcol), &desktoptext_colour);
gdk_color_parse ("#000000", &bartext_colour);
gtk_color_button_set_color (GTK_COLOR_BUTTON (btcol), &bartext_colour);
gdk_color_parse ("#EDECEB", &bar_colour);
gtk_color_button_set_color (GTK_COLOR_BUTTON (bcol), &bar_colour);
gdk_color_parse ("#FFFFFF", &themetext_colour);
gtk_color_button_set_color (GTK_COLOR_BUTTON (htcol), &themetext_colour);
barpos = 0;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb1), TRUE);
show_docs = 0;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb1), show_docs);
show_trash = 1;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb2), show_trash);
show_mnts = 0;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb3), show_mnts);
set_openbox_theme ("PiX");
set_lxsession_theme ("PiX");
save_lxsession_settings ();
save_pcman_settings ();
save_obconf_settings ();
save_obpix_settings ();
save_gtk3_settings ();
save_lxpanel_settings ();
if (needs_refresh) system (RELOAD_LXSESSION);
system (RELOAD_LXPANEL);
system (RELOAD_OPENBOX);
system (RELOAD_PCMANFM);
}
static GtkWidget*
create_window2 (void)
{
GtkWidget *window, *button1, *button2, *button3, *ticker;
GtkImage *imageClient, *imageWellth, *imageBG;
GError** error = NULL;
/* Load UI from file */
/* Auto-connect signal handlers */
gtk_builder_connect_signals (InitialBuilder, NULL);
/* Get the window object from the ui file */
window = GTK_WIDGET (gtk_builder_get_object (InitialBuilder, INITIAL_WINDOW));
if (!window)
{
g_critical ("Widget \"%s\" is missing in file %s.",
INITIAL_WINDOW,
INITIAL_UI_FILE);
}
//GdkPixbufAnimation * pixbufclntanm = gdk_pixbuf_animation_new_from_file(CLIENT_LOGO, error);
GdkPixbufAnimation * pixbufwlthanm = gdk_pixbuf_animation_new_from_file(WELLTH_LOGO, error);
//imageClient = (GtkImage *) GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "clnt_logo"));
imageWellth = (GtkImage *) GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "wellth_logo"));
//gtk_image_set_from_animation(GTK_IMAGE(imageClient), pixbufclntanm);
gtk_image_set_from_animation (GTK_IMAGE(imageWellth), pixbufwlthanm);
//GdkPixbufAnimation * pixbufBGanm = gdk_pixbuf_animation_new_from_file(BG2, error);
imageBG = (GtkImage *) GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "image1"));
gtk_image_set_from_animation(GTK_IMAGE(imageBG), pixbufBGanm);
GdkPixbufAnimation * pixbufswipecard = gdk_pixbuf_animation_new_from_file(SMART_CARD, error);
GtkImage *sc = (GtkImage *) GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "image2"));
gtk_image_set_from_animation(GTK_IMAGE(sc), pixbufswipecard);
#ifdef DISPLAY_ADD
GdkPixbufAnimation * pixbufaddanm = gdk_pixbuf_animation_new_from_file(ADDS2, error);
GtkImage *add = (GtkImage *) GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "adds"));
gtk_image_set_from_animation(GTK_IMAGE(add), pixbufaddanm);
#endif
// button1 = GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "back"));
// g_signal_connect (G_OBJECT (button1), "clicked",
// G_CALLBACK (back_button_clicked),
// NULL);
GdkColor color;
gdk_color_parse ("#FF0000", &color);
gtk_widget_modify_bg ( GTK_WIDGET(button1), GTK_STATE_NORMAL, &color);
button2 = GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "login"));
g_signal_connect (G_OBJECT (button2), "clicked",
G_CALLBACK (login_button_clicked),
NULL);
//button3 = GTK_WIDGET (gtk_builder_get_object (InitialBuilder, "sign_up"));
// g_signal_connect (G_OBJECT (button3), "clicked",
// G_CALLBACK (signup_button_clicked),
// NULL);
//ticker = GTK_WIDGET (gtk_builder_get_object(InitialBuilder, "entry1"));
//gtk_entry_set_text(ticker, ticker_text);
priv = g_malloc (sizeof (struct _Private));
/* ANJUTA: Widgets initialization for WindowMain.ui - DO NOT REMOVE */
//g_object_unref (InitialBuilder);
return window;
}
int l_zarzvan(int metka_rr, //0-ввод и корек. 1-выбор
iceb_u_str *kod,iceb_u_str *naim,GtkWidget *wpredok)
{
l_zarzvan_data data;
char bros[512];
GdkColor color;
data.poisk.clear_data();
data.metka_rr=metka_rr;
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
//gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);
sprintf(bros,"%s %s",name_system,gettext("Список званий"));
gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_zarzvan_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);
data.label_kolstr=gtk_label_new (gettext("Список званий"));
//gdk_color_parse("green",&color);
//gtk_widget_modify_fg(data.label_kolstr,GTK_STATE_NORMAL,&color);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.label_poisk=gtk_label_new ("");
gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(bros,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);
sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);
sprintf(bros,"%sF3 %s",RFK,gettext("Удалить"));
data.knopka[SFK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
tooltips[SFK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить неиспользуемые коды"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3);
gtk_widget_show(data.knopka[SFK3]);
sprintf(bros,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);
sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);
sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_zarzvan_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
l_zarzvan_create_list(&data);
gtk_widget_show(data.window);
if(metka_rr == 0)
gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));
gtk_main();
if(data.metka_voz == 0)
{
kod->new_plus(data.kodv.ravno());
naim->new_plus(data.naimv.ravno());
}
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.metka_voz);
}
/**
* Read in a Viking file and return how successful the parsing was
* ATM this will always work, in that even if there are parsing problems
* then there will be no new values to override the defaults
*
* TODO flow up line number(s) / error messages of problems encountered...
*
*/
static gboolean file_read ( VikAggregateLayer *top, FILE *f, const gchar *dirpath, VikViewport *vp )
{
Stack *stack;
struct LatLon ll = { 0.0, 0.0 };
gchar buffer[4096];
gchar *line;
guint16 len;
long line_num = 0;
VikLayerParam *params = NULL; /* for current layer, so we don't have to keep on looking up interface */
guint8 params_count = 0;
GHashTable *string_lists = g_hash_table_new(g_direct_hash,g_direct_equal);
gboolean successful_read = TRUE;
push(&stack);
stack->under = NULL;
stack->data = (gpointer) top;
while ( fgets ( buffer, 4096, f ) )
{
line_num++;
line = buffer;
while ( *line == ' ' || *line =='\t' )
line++;
if ( line[0] == '#' )
continue;
len = strlen(line);
if ( len > 0 && line[len-1] == '\n' )
line[--len] = '\0';
if ( len > 0 && line[len-1] == '\r' )
line[--len] = '\0';
if ( len == 0 )
continue;
if ( line[0] == '~' )
{
line++; len--;
if ( *line == '\0' )
continue;
else if ( str_starts_with ( line, "Layer ", 6, TRUE ) )
{
int parent_type = VIK_LAYER(stack->data)->type;
if ( ( ! stack->data ) || ((parent_type != VIK_LAYER_AGGREGATE) && (parent_type != VIK_LAYER_GPS)) )
{
successful_read = FALSE;
g_warning ( "Line %ld: Layer command inside non-Aggregate Layer (type %d)", line_num, parent_type );
push(&stack); /* inside INVALID layer */
stack->data = NULL;
continue;
}
else
{
VikLayerTypeEnum type = vik_layer_type_from_string ( line+6 );
push(&stack);
if ( type == VIK_LAYER_NUM_TYPES )
{
successful_read = FALSE;
g_warning ( "Line %ld: Unknown type %s", line_num, line+6 );
stack->data = NULL;
}
else if (parent_type == VIK_LAYER_GPS)
{
stack->data = (gpointer) vik_gps_layer_get_a_child(VIK_GPS_LAYER(stack->under->data));
params = vik_layer_get_interface(type)->params;
params_count = vik_layer_get_interface(type)->params_count;
}
else
{
stack->data = (gpointer) vik_layer_create ( type, vp, FALSE );
params = vik_layer_get_interface(type)->params;
params_count = vik_layer_get_interface(type)->params_count;
}
}
}
else if ( str_starts_with ( line, "EndLayer", 8, FALSE ) )
{
if ( stack->under == NULL ) {
successful_read = FALSE;
g_warning ( "Line %ld: Mismatched ~EndLayer command", line_num );
}
else
{
/* add any string lists we've accumulated */
gpointer layer_and_vp[2];
layer_and_vp[0] = stack->data;
layer_and_vp[1] = vp;
g_hash_table_foreach ( string_lists, (GHFunc) string_list_set_param, layer_and_vp );
g_hash_table_remove_all ( string_lists );
if ( stack->data && stack->under->data )
{
if (VIK_LAYER(stack->under->data)->type == VIK_LAYER_AGGREGATE) {
vik_aggregate_layer_add_layer ( VIK_AGGREGATE_LAYER(stack->under->data), VIK_LAYER(stack->data), FALSE );
vik_layer_post_read ( VIK_LAYER(stack->data), vp, TRUE );
}
else if (VIK_LAYER(stack->under->data)->type == VIK_LAYER_GPS) {
/* TODO: anything else needs to be done here ? */
}
else {
successful_read = FALSE;
g_warning ( "Line %ld: EndLayer command inside non-Aggregate Layer (type %d)", line_num, VIK_LAYER(stack->data)->type );
}
}
pop(&stack);
}
}
else if ( str_starts_with ( line, "LayerData", 9, FALSE ) )
{
if ( stack->data && vik_layer_get_interface(VIK_LAYER(stack->data)->type)->read_file_data )
{
/* must read until hits ~EndLayerData */
if ( ! vik_layer_get_interface(VIK_LAYER(stack->data)->type)->read_file_data ( VIK_LAYER(stack->data), f, dirpath ) )
successful_read = FALSE;
}
else
{ /* simply skip layer data over */
while ( fgets ( buffer, 4096, f ) )
{
line_num++;
line = buffer;
len = strlen(line);
if ( len > 0 && line[len-1] == '\n' )
line[--len] = '\0';
if ( len > 0 && line[len-1] == '\r' )
line[--len] = '\0';
if ( strcasecmp ( line, "~EndLayerData" ) == 0 )
break;
}
continue;
}
}
else
{
successful_read = FALSE;
g_warning ( "Line %ld: Unknown tilde command", line_num );
}
}
else
{
gint32 eq_pos = -1;
guint16 i;
if ( ! stack->data )
continue;
for ( i = 0; i < len; i++ )
if ( line[i] == '=' )
eq_pos = i;
if ( stack->under == NULL && eq_pos == 12 && strncasecmp ( line, "FILE_VERSION", eq_pos ) == 0) {
gint version = strtol(line+13, NULL, 10);
g_debug ( "%s: reading file version %d", __FUNCTION__, version );
if ( version > VIKING_FILE_VERSION )
successful_read = FALSE;
// However we'll still carry and attempt to read whatever we can
}
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "xmpp", eq_pos ) == 0) /* "hard coded" params: global & for all layer-types */
vik_viewport_set_xmpp ( VIK_VIEWPORT(vp), strtod ( line+5, NULL ) );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "ympp", eq_pos ) == 0)
vik_viewport_set_ympp ( VIK_VIEWPORT(vp), strtod ( line+5, NULL ) );
else if ( stack->under == NULL && eq_pos == 3 && strncasecmp ( line, "lat", eq_pos ) == 0 )
ll.lat = strtod ( line+4, NULL );
else if ( stack->under == NULL && eq_pos == 3 && strncasecmp ( line, "lon", eq_pos ) == 0 )
ll.lon = strtod ( line+4, NULL );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "utm" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_UTM);
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "expedia" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_EXPEDIA );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "google" ) == 0)
{
successful_read = FALSE;
g_warning ( _("Draw mode '%s' no more supported"), "google" );
}
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "kh" ) == 0)
{
successful_read = FALSE;
g_warning ( _("Draw mode '%s' no more supported"), "kh" );
}
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "mercator" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_MERCATOR );
else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "latlon" ) == 0)
vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_LATLON );
else if ( stack->under == NULL && eq_pos == 5 && strncasecmp ( line, "color", eq_pos ) == 0 )
vik_viewport_set_background_color ( VIK_VIEWPORT(vp), line+6 );
else if ( stack->under == NULL && eq_pos == 14 && strncasecmp ( line, "highlightcolor", eq_pos ) == 0 )
vik_viewport_set_highlight_color ( VIK_VIEWPORT(vp), line+15 );
else if ( stack->under == NULL && eq_pos == 9 && strncasecmp ( line, "drawscale", eq_pos ) == 0 )
vik_viewport_set_draw_scale ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+10) );
else if ( stack->under == NULL && eq_pos == 14 && strncasecmp ( line, "drawcentermark", eq_pos ) == 0 )
vik_viewport_set_draw_centermark ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+15) );
else if ( stack->under == NULL && eq_pos == 13 && strncasecmp ( line, "drawhighlight", eq_pos ) == 0 )
vik_viewport_set_draw_highlight ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+14) );
else if ( stack->under && eq_pos == 4 && strncasecmp ( line, "name", eq_pos ) == 0 )
vik_layer_rename ( VIK_LAYER(stack->data), line+5 );
else if ( eq_pos == 7 && strncasecmp ( line, "visible", eq_pos ) == 0 )
VIK_LAYER(stack->data)->visible = TEST_BOOLEAN(line+8);
else if ( eq_pos != -1 && stack->under )
{
gboolean found_match = FALSE;
/* go thru layer params. if len == eq_pos && starts_with jazz, set it. */
/* also got to check for name and visible. */
if ( ! params )
{
successful_read = FALSE;
g_warning ( "Line %ld: No options for this kind of layer", line_num );
continue;
}
for ( i = 0; i < params_count; i++ )
if ( strlen(params[i].name) == eq_pos && strncasecmp ( line, params[i].name, eq_pos ) == 0 )
{
VikLayerParamData x;
line += eq_pos+1;
if ( params[i].type == VIK_LAYER_PARAM_STRING_LIST ) {
GList *l = g_list_append ( g_hash_table_lookup ( string_lists, GINT_TO_POINTER ((gint) i) ),
g_strdup(line) );
g_hash_table_replace ( string_lists, GINT_TO_POINTER ((gint)i), l );
/* add the value to a list, possibly making a new list.
* this will be passed to the layer when we read an ~EndLayer */
} else {
switch ( params[i].type )
{
case VIK_LAYER_PARAM_DOUBLE: x.d = strtod(line, NULL); break;
case VIK_LAYER_PARAM_UINT: x.u = strtoul(line, NULL, 10); break;
case VIK_LAYER_PARAM_INT: x.i = strtol(line, NULL, 10); break;
case VIK_LAYER_PARAM_BOOLEAN: x.b = TEST_BOOLEAN(line); break;
case VIK_LAYER_PARAM_COLOR: memset(&(x.c), 0, sizeof(x.c)); /* default: black */
gdk_color_parse ( line, &(x.c) ); break;
/* STRING or STRING_LIST -- if STRING_LIST, just set param to add a STRING */
default: x.s = line;
}
vik_layer_set_param ( VIK_LAYER(stack->data), i, x, vp, TRUE );
}
found_match = TRUE;
break;
}
if ( ! found_match ) {
// ATM don't flow up this issue because at least one internal parameter has changed from version 1.3
// and don't what to worry users about raising such issues
// TODO Maybe hold old values here - compare the line value against them and if a match
// generate a different style of message in the GUI...
// successful_read = FALSE;
g_warning ( "Line %ld: Unknown parameter. Line:\n%s", line_num, line );
}
}
else {
successful_read = FALSE;
g_warning ( "Line %ld: Invalid parameter or parameter outside of layer.", line_num );
}
}
/* could be:
[Layer Type=Bla]
[EndLayer]
[LayerData]
name=this
#comment
*/
}
while ( stack )
{
if ( stack->under && stack->under->data && stack->data )
{
vik_aggregate_layer_add_layer ( VIK_AGGREGATE_LAYER(stack->under->data), VIK_LAYER(stack->data), FALSE );
vik_layer_post_read ( VIK_LAYER(stack->data), vp, TRUE );
}
pop(&stack);
}
if ( ll.lat != 0.0 || ll.lon != 0.0 )
vik_viewport_set_center_latlon ( VIK_VIEWPORT(vp), &ll, TRUE );
if ( ( ! VIK_LAYER(top)->visible ) && VIK_LAYER(top)->realized )
vik_treeview_item_set_visible ( VIK_LAYER(top)->vt, &(VIK_LAYER(top)->iter), FALSE );
/* delete anything we've forgotten about -- should only happen when file ends before an EndLayer */
g_hash_table_foreach ( string_lists, string_list_delete, NULL );
g_hash_table_destroy ( string_lists );
return successful_read;
}
static void
source_list_changed_cb (ESourceList *source_list,
ESourceComboBox *source_combo_box)
{
ESourceComboBoxPrivate *priv;
GtkComboBox *combo_box;
GtkTreeModel *model;
GtkListStore *store;
GtkTreeIter iter;
GtkTreePath *path;
GSList *groups;
GSList *sources, *s;
const gchar *name;
const gchar *uid;
gchar *indented_name;
gboolean visible = FALSE;
gboolean iter_valid;
priv = source_combo_box->priv;
g_hash_table_remove_all (priv->uid_index);
combo_box = GTK_COMBO_BOX (source_combo_box);
gtk_combo_box_set_active (combo_box, -1);
model = gtk_combo_box_get_model (combo_box);
store = GTK_LIST_STORE (model);
gtk_list_store_clear (store);
for (groups = e_source_list_peek_groups (source_list);
groups != NULL; groups = groups->next) {
/* Only show source groups that have sources. */
if (e_source_group_peek_sources (groups->data) == NULL)
continue;
name = e_source_group_peek_name (groups->data);
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
COLUMN_COLOR, NULL,
COLUMN_NAME, name,
COLUMN_SENSITIVE, FALSE,
COLUMN_SOURCE, groups->data,
-1);
sources = get_sorted_sources (e_source_group_peek_sources (groups->data));
for (s = sources; s != NULL; s = s->next) {
const gchar *color_spec;
GdkColor color;
name = e_source_peek_name (s->data);
indented_name = g_strconcat (" ", name, NULL);
color_spec = e_source_peek_color_spec (s->data);
if (color_spec != NULL) {
gdk_color_parse (color_spec, &color);
visible = TRUE;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
COLUMN_COLOR, color_spec ? &color : NULL,
COLUMN_NAME, indented_name,
COLUMN_SENSITIVE, TRUE,
COLUMN_SOURCE, s->data,
-1);
uid = e_source_peek_uid (s->data);
path = gtk_tree_model_get_path (model, &iter);
g_hash_table_insert (
priv->uid_index, g_strdup (uid),
gtk_tree_row_reference_new (model, path));
gtk_tree_path_free (path);
g_free (indented_name);
}
g_slist_free (sources);
}
/* Set the visible column based on whether we've seen a color. */
iter_valid = gtk_tree_model_get_iter_first (model, &iter);
while (iter_valid) {
gtk_list_store_set (
store, &iter, COLUMN_VISIBLE, visible, -1);
iter_valid = gtk_tree_model_iter_next (model, &iter);
}
}
