void gtr_confirm_remove (GtkWindow * parent, TrCore * core, GSList * torrent_ids, gboolean delete_files) { GSList * l; GtkWidget * d; GString * primary_text; GString * secondary_text; struct delete_data * dd; int connected = 0; int incomplete = 0; const int count = g_slist_length (torrent_ids); if (!count) return; dd = g_new0 (struct delete_data, 1); dd->core = core; dd->torrent_ids = torrent_ids; dd->delete_files = delete_files; for (l=torrent_ids; l!=NULL; l=l->next) { const int id = GPOINTER_TO_INT (l->data); tr_torrent * tor = gtr_core_find_torrent (core, id); const tr_stat * stat = tr_torrentStat (tor); if (stat->leftUntilDone) ++incomplete; if (stat->peersConnected) ++connected; } primary_text = g_string_new (NULL); if (!delete_files) { g_string_printf (primary_text, ngettext ("Remove Torrent?", "Remove %d Torrents?", count), count); } else { g_string_printf (primary_text, ngettext ("Delete this torrent's downloaded files?", "Delete these %d torrents' downloaded files?", count), count); } secondary_text = g_string_new (NULL); if (!incomplete && !connected) { g_string_assign (secondary_text, ngettext ( "Once removed, continuing the transfer will require the torrent file or magnet link.", "Once removed, continuing the transfers will require the torrent files or magnet links.", count)); } else if (count == incomplete) { g_string_assign (secondary_text, ngettext ("This torrent has not finished downloading.", "These torrents have not finished downloading.", count)); } else if (count == connected) { g_string_assign (secondary_text, ngettext ("This torrent is connected to peers.", "These torrents are connected to peers.", count)); } else { if (connected) g_string_append (secondary_text, ngettext ("One of these torrents is connected to peers.", "Some of these torrents are connected to peers.", connected)); if (connected && incomplete) g_string_append (secondary_text, "\n"); if (incomplete) g_string_assign (secondary_text, ngettext ("One of these torrents has not finished downloading.", "Some of these torrents have not finished downloading.", incomplete)); } d = gtk_message_dialog_new_with_markup (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "<big><b>%s</b></big>", primary_text->str); if (secondary_text->len) gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (d), "%s", secondary_text->str); gtk_dialog_add_buttons (GTK_DIALOG (d), _("_Cancel"), GTK_RESPONSE_CANCEL, (delete_files ? _("_Delete"): _("Remove")), GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL); g_signal_connect (d, "response", G_CALLBACK (on_remove_dialog_response), dd); gtk_widget_show_all (d); g_string_free (primary_text, TRUE); g_string_free (secondary_text, TRUE); }
static void mex_proxy_controller_changed_cb (GController *controller, GControllerAction action, GControllerReference *ref, MexProxy *proxy) { gint i, n_indices; MexContent *content; MexProxyPrivate *priv = proxy->priv; n_indices = g_controller_reference_get_n_indices (ref); switch (action) { case G_CONTROLLER_ADD: for (i = 0; i < n_indices; i++) { gint content_index = g_controller_reference_get_index_uint (ref, i); content = mex_model_get_content (priv->model, content_index); mex_proxy_add_content (proxy, content); } break; case G_CONTROLLER_REMOVE: { gint length, fillin = 0, start_fillin; GList *positions = NULL, *position; for (i = 0; i < n_indices; i++) { gint content_index = g_controller_reference_get_index_uint (ref, i); if (content_index >= priv->limit) positions = g_list_insert_sorted_with_data (positions, GINT_TO_POINTER (content_index), _insert_position, NULL); else fillin++; content = mex_model_get_content (priv->model, content_index); mex_proxy_remove_content (proxy, content); } position = positions; length = mex_model_get_length (priv->model); start_fillin = priv->limit; for (i = 0; i < MIN (fillin, (length - (gint) priv->limit)); i++) { if ((position != NULL) && (start_fillin == GPOINTER_TO_INT (position->data))) { while ((position != NULL) && (start_fillin == GPOINTER_TO_INT (position->data))) { start_fillin++; if (start_fillin > GPOINTER_TO_INT (position->data)) position = position->next; } } content = mex_model_get_content (priv->model, start_fillin); mex_proxy_add_content (proxy, content); start_fillin++; } g_list_free (positions); } break; case G_CONTROLLER_UPDATE: /* Should be no need for this, GBinding sorts it out for us :) */ break; case G_CONTROLLER_CLEAR: mex_proxy_clear (proxy); break; case G_CONTROLLER_REPLACE: mex_proxy_clear (proxy); i = 0; while ((content = mex_model_get_content (priv->model, i++))) mex_proxy_add_content (proxy, content); break; case G_CONTROLLER_INVALID_ACTION: g_warning (G_STRLOC ": Proxy controller has issued an error"); break; default: g_warning (G_STRLOC ": Unhandled action"); break; } }
/** * gimp_scanner_parse_color: * @scanner: * @dest: * * Return value: * * Since: GIMP 2.4 **/ gboolean gimp_scanner_parse_color (GScanner *scanner, GimpRGB *dest) { guint scope_id; guint old_scope_id; GTokenType token; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; scope_id = g_quark_from_static_string ("gimp_scanner_parse_color"); old_scope_id = g_scanner_set_scope (scanner, scope_id); if (! g_scanner_scope_lookup_symbol (scanner, scope_id, "color-rgb")) { g_scanner_scope_add_symbol (scanner, scope_id, "color-rgb", GINT_TO_POINTER (COLOR_RGB)); g_scanner_scope_add_symbol (scanner, scope_id, "color-rgba", GINT_TO_POINTER (COLOR_RGBA)); g_scanner_scope_add_symbol (scanner, scope_id, "color-hsv", GINT_TO_POINTER (COLOR_HSV)); g_scanner_scope_add_symbol (scanner, scope_id, "color-hsva", GINT_TO_POINTER (COLOR_HSVA)); } token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: { gdouble col[4] = { 0.0, 0.0, 0.0, 1.0 }; gint n_channels = 4; gboolean is_hsv = FALSE; gint i; switch (GPOINTER_TO_INT (scanner->value.v_symbol)) { case COLOR_RGB: n_channels = 3; /* fallthrough */ case COLOR_RGBA: break; case COLOR_HSV: n_channels = 3; /* fallthrough */ case COLOR_HSVA: is_hsv = TRUE; break; } token = G_TOKEN_FLOAT; for (i = 0; i < n_channels; i++) { if (! gimp_scanner_parse_float (scanner, &col[i])) goto finish; } if (is_hsv) { GimpHSV hsv; gimp_hsva_set (&hsv, col[0], col[1], col[2], col[3]); gimp_hsv_clamp (&hsv); gimp_hsv_to_rgb (&hsv, &color); } else { gimp_rgba_set (&color, col[0], col[1], col[2], col[3]); gimp_rgb_clamp (&color); } token = G_TOKEN_RIGHT_PAREN; } break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_NONE; /* indicates success */ goto finish; default: /* do nothing */ break; } } finish: if (token != G_TOKEN_NONE) { g_scanner_get_next_token (scanner); g_scanner_unexp_token (scanner, token, NULL, NULL, NULL, _("fatal parse error"), TRUE); } else { *dest = color; } g_scanner_set_scope (scanner, old_scope_id); return (token == G_TOKEN_NONE); }
/** * fill the reconcile list, * sort each reconcile in its account * * \param * * \return * */ void gsb_reconcile_config_fill ( void ) { GtkTreeModel *model; GSList *tmp_list; GrisbiWinEtat *w_etat; if (!reconcile_treeview) return; w_etat = (GrisbiWinEtat *) grisbi_win_get_w_etat (); model = gtk_tree_view_get_model ( GTK_TREE_VIEW (reconcile_treeview)); gtk_tree_store_clear (GTK_TREE_STORE(model)); /* we make a tree_model containing the accounts, * and for each account, all the reconciles */ tmp_list = gsb_data_account_get_list_accounts (); while (tmp_list) { gint account_number; GtkTreeIter account_iter; GList *reconcile_list; account_number = gsb_data_account_get_no_account (tmp_list -> data); gtk_tree_store_append ( GTK_TREE_STORE (model), &account_iter, NULL ); gtk_tree_store_set ( GTK_TREE_STORE (model), &account_iter, RECONCILIATION_NAME_COLUMN, gsb_data_account_get_name (account_number), RECONCILIATION_WEIGHT_COLUMN, 800, RECONCILIATION_ACCOUNT_COLUMN, account_number, -1 ); /* for each account, get the concerned reconciles */ reconcile_list = gsb_data_reconcile_get_sort_reconcile_list (account_number); if (w_etat->reconcile_sort) reconcile_list = g_list_reverse (reconcile_list); while (reconcile_list) { gint reconcile_number; reconcile_number = GPOINTER_TO_INT (reconcile_list->data); if (gsb_data_reconcile_get_account (reconcile_number) == account_number) { GtkTreeIter reconcile_iter; gchar *init_date, *final_date; gchar *init_balance, *final_balance; init_date = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number)); final_date = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number)); init_balance = utils_real_get_string (gsb_data_reconcile_get_init_balance (reconcile_number)); final_balance = utils_real_get_string (gsb_data_reconcile_get_final_balance (reconcile_number)); gtk_tree_store_append ( GTK_TREE_STORE (model), &reconcile_iter, &account_iter ); gtk_tree_store_set ( GTK_TREE_STORE (model), &reconcile_iter, RECONCILIATION_NAME_COLUMN, gsb_data_reconcile_get_name (reconcile_number), RECONCILIATION_WEIGHT_COLUMN, 400, RECONCILIATION_INIT_DATE_COLUMN, init_date, RECONCILIATION_FINAL_DATE_COLUMN, final_date, RECONCILIATION_INIT_BALANCE_COLUMN, init_balance, RECONCILIATION_FINAL_BALANCE_COLUMN, final_balance, RECONCILIATION_RECONCILE_COLUMN, reconcile_number, RECONCILIATION_ACCOUNT_COLUMN, account_number, -1 ); g_free (init_date); g_free (final_date); g_free (init_balance); g_free (final_balance); } reconcile_list = reconcile_list -> next; } tmp_list = tmp_list -> next; } }
static void wnck_selector_insert_window (WnckSelector *selector, WnckWindow *window) { GtkWidget *item; WnckScreen *screen; WnckWorkspace *workspace; int workspace_n; int i; screen = wnck_selector_get_screen (selector); workspace = wnck_window_get_workspace (window); if (!workspace && !wnck_window_is_pinned (window)) return; item = wnck_selector_create_window (selector, window); if (!workspace || workspace == wnck_screen_get_active_workspace (screen)) { /* window is pinned or in the current workspace * => insert before the separator */ GList *l, *children; i = 0; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { if (GTK_IS_SEPARATOR_MENU_ITEM (l->data)) break; i++; } g_list_free (children); gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu), item, i); } else { workspace_n = wnck_workspace_get_number (workspace); if (workspace_n == wnck_screen_get_workspace_count (screen) - 1) /* window is in last workspace => just append */ gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), item); else { /* insert just before the next workspace item */ GList *l, *children; i = 0; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { int j; j = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data), "wnck-selector-workspace-n")); if (j - 1 == workspace_n + 1) break; i++; } g_list_free (children); gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu), item, i); } } }
static GTokenType plug_in_proc_arg_deserialize (GScanner *scanner, Gimp *gimp, GimpProcedure *procedure, gboolean return_value) { GTokenType token; gint arg_type; gchar *name = NULL; gchar *desc = NULL; GParamSpec *pspec; if (! gimp_scanner_parse_token (scanner, G_TOKEN_LEFT_PAREN)) { token = G_TOKEN_LEFT_PAREN; goto error; } if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL) || GPOINTER_TO_INT (scanner->value.v_symbol) != PROC_ARG) { token = G_TOKEN_SYMBOL; goto error; } if (! gimp_scanner_parse_int (scanner, (gint *) &arg_type)) { token = G_TOKEN_INT; goto error; } if (! gimp_scanner_parse_string (scanner, &name)) { token = G_TOKEN_STRING; goto error; } if (! gimp_scanner_parse_string (scanner, &desc)) { token = G_TOKEN_STRING; goto error; } if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) { token = G_TOKEN_RIGHT_PAREN; goto error; } token = G_TOKEN_LEFT_PAREN; pspec = gimp_pdb_compat_param_spec (gimp, arg_type, name, desc); if (return_value) gimp_procedure_add_return_value (procedure, pspec); else gimp_procedure_add_argument (procedure, pspec); error: g_free (name); g_free (desc); return token; }
void prov_xdk_knopka(GtkWidget *widget,class prov_xdk_data *data) { iceb_u_str shetd; iceb_u_str shetk; iceb_u_str suma; int knop=GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(widget))); data->kl_shift=0; //Сбрасываем нажатый сшифт так как при после запуска нового меню он не сбрасывается switch (knop) { case GDK_plus: //это почемуто не работает Нажата клавиша плюс на основной клавиатуре case GDK_KP_Add: //Нажата клавиша "+" на дополнительной клавиатуре case FK2: if(prov_xdk_prpvblok(data) != 0) return; if(iceb_vprov(data->metkasys,"","","","","",rec.nomdk.ravno(),rec.kodop.ravno(),0, rec.dd,rec.md,rec.gd,"",data->vrem_v,data->ktoz_v,"", data->pods,rec.tipz,0,0,data->window) != 0) return; prov_xdk_create_list(data); return; case SFK2: if(data->kolzap == 0) return; if(prov_xdk_prpvblok(data) != 0) return; shetd.new_plus(data->shet_v.ravno()); shetk.new_plus(data->shet_kor_v.ravno()); suma.new_plus(data->debet_v); if(data->debet_v == 0) { shetd.new_plus(data->shet_kor_v.ravno()); shetk.new_plus(data->shet_v.ravno()); suma.new_plus(data->kredit_v); } if(iceb_vprov(data->metkasys,shetd.ravno(),shetk.ravno(), suma.ravno(),data->datap_v.ravno(),data->koment_v.ravno(), rec.nomdk.ravno(),rec.kodop.ravno(),0, rec.dd,rec.md,rec.gd,"",data->vrem_v,data->ktoz_v,"", data->pods,rec.tipz,data->val_v,data->kekv,data->window) != 0) return; prov_xdk_create_list(data); return; case FK3: if(data->kolzap == 0) return; if(prov_xdk_prpvblok(data) != 0) return; shetd.new_plus(gettext("Удалить запись ? Вы уверены ?")); if(iceb_menu_danet(&shetd,2,data->window) != 1) return; iceb_udprov(data->val_v,data->datap_v.ravno(),data->shet_v.ravno_filtr(), data->shet_kor_v.ravno_filtr(),data->vrem_v, data->debet_v,data->kredit_v,data->koment_v.ravno_filtr(),2,data->window); prov_xdk_create_list(data); return; case SFK3: if(data->kolzap == 0) return; if(prov_xdk_prpvblok(data) != 0) return; shetd.new_plus(gettext("Удалить все проводки ? Вы уверены ?")); if(iceb_menu_danet(&shetd,2,data->window) != 1) return; if(iceb_udprgr(data->metkasys,rec.dd,rec.md,rec.gd,rec.nomdk.ravno(),0,rec.tipz,data->window) != 0) return; prov_xdk_create_list(data); return; case FK4: if(prov_xdk_prpvblok(data) != 0) return; avtprpldw(data->tablica,rec.kodop.ravno(),rec.nomdk.ravno(),rec.kodor1.ravno(),data->shet,NULL,data->window); prov_xdk_create_list(data); return; case FK5: iceb_raspprov(data->zapros.ravno(),rec.dd,rec.md,rec.gd,rec.nomdk.ravno(),6,data->window); memset(data->shet,'\0',sizeof(data->shet)); if(iceb_poldan(rec.nsh.ravno(),data->shet,data->imaf_np.ravno(),data->window) != 0) { iceb_menu_soob(gettext("Не найден бухгалтерский счёт расчётного счёта !"),data->window); } prov_xdk_create_list(data); //перечитать обязательно return; case FK7: if(iceb_u_SRAV(data->tablica,"Pltp",0) == 0) iceb_f_redfil("avtprodok.alx",0,data->window); if(iceb_u_SRAV(data->tablica,"Pltt",0) == 0) iceb_f_redfil("avtprodokt.alx",0,data->window); return; case FK8: return; case FK10: provpdw(data->tablica,data->window); gtk_widget_destroy(data->window); return; } }
/** * mono_process_get_name: * @pid: pid of the process * @buf: byte buffer where to store the name of the prcoess * @len: size of the buffer @buf * * Return the name of the process identified by @pid, storing it * inside @buf for a maximum of len bytes (including the terminating 0). */ char* mono_process_get_name (gpointer pid, char *buf, int len) { #if USE_SYSCTL int res; #ifdef KERN_PROC2 int mib [6]; size_t data_len = sizeof (struct kinfo_proc2); struct kinfo_proc2 processi; #else int mib [4]; size_t data_len = sizeof (struct kinfo_proc); struct kinfo_proc processi; #endif /* KERN_PROC2 */ memset (buf, 0, len); #ifdef KERN_PROC2 mib [0] = CTL_KERN; mib [1] = KERN_PROC2; mib [2] = KERN_PROC_PID; mib [3] = GPOINTER_TO_UINT (pid); mib [4] = sizeof(struct kinfo_proc2); mib [5] = 400; /* XXX */ res = sysctl (mib, 6, &processi, &data_len, NULL, 0); if (res < 0 || data_len != sizeof (struct kinfo_proc2)) { return buf; } #else mib [0] = CTL_KERN; mib [1] = KERN_PROC; mib [2] = KERN_PROC_PID; mib [3] = GPOINTER_TO_UINT (pid); res = sysctl (mib, 4, &processi, &data_len, NULL, 0); if (res < 0 || data_len != sizeof (struct kinfo_proc)) { return buf; } #endif /* KERN_PROC2 */ strncpy (buf, processi.kinfo_name_member, len - 1); return buf; #else char fname [128]; FILE *file; char *p; int r; sprintf (fname, "/proc/%d/cmdline", GPOINTER_TO_INT (pid)); buf [0] = 0; file = fopen (fname, "r"); if (!file) return buf; r = fread (buf, 1, len - 1, file); fclose (file); buf [r] = 0; p = strrchr (buf, '/'); if (p) return p + 1; if (r == 0) { return get_pid_status_item_buf (GPOINTER_TO_INT (pid), "Name", buf, len, NULL); } return buf; #endif }
static void cg_cell_renderer_flags_selected (CgComboFlags *combo, GtkTreeIter *iter, CgComboFlagsSelectionType type, gpointer user_data) { CgCellRendererFlags *cell_flags; CgCellRendererFlagsPrivate *priv; gpointer result; gchar *name; gchar *abbr; cell_flags = CG_CELL_RENDERER_FLAGS (user_data); priv = CG_CELL_RENDERER_FLAGS_PRIVATE (cell_flags); gtk_tree_model_get (priv->model, iter, priv->text_column, &name, priv->abbr_column, &abbr, -1); g_assert (priv->edit_status != NULL); result = g_hash_table_lookup (priv->edit_status, abbr); /* abbr needs not to be freed if it gets inserted into the hash table * because the hash table then takes ownership of it. */ switch (type) { case CG_COMBO_FLAGS_SELECTION_NONE: g_free (abbr); break; case CG_COMBO_FLAGS_SELECTION_SELECT: if (GPOINTER_TO_INT(result) != 1) g_hash_table_insert (priv->edit_status, abbr, GINT_TO_POINTER (1)); else g_free (abbr); break; case CG_COMBO_FLAGS_SELECTION_UNSELECT: if (GPOINTER_TO_INT (result) == 1) g_hash_table_remove(priv->edit_status, abbr); g_free (abbr); break; case CG_COMBO_FLAGS_SELECTION_TOGGLE: if (GPOINTER_TO_INT (result) == 1) { g_hash_table_remove (priv->edit_status, abbr); g_free(abbr); } else { g_hash_table_insert (priv->edit_status, abbr, GINT_TO_POINTER (1)); } break; default: g_assert_not_reached (); break; } /* This is done to get GTK+ to re-render this row with the changed flag * status that is set via the cell data func, but GTK+ does not call it * again because it does not know that the hash table changed. There are * probably better means to achieve this, but I am not aware of those. */ gtk_list_store_set (GTK_LIST_STORE (priv->model), iter, priv->text_column, name, -1); g_free (name); }
static void on_menu_item_activate(G_GNUC_UNUSED GtkMenuItem *item, gpointer user_data) { on_key_binding(GPOINTER_TO_INT(user_data)); }
void jabber_presence_parse(JabberStream *js, xmlnode *packet) { const char *type; JabberBuddyResource *jbr = NULL; gboolean signal_return, ret; JabberPresence presence; xmlnode *child; memset(&presence, 0, sizeof(presence)); /* defaults */ presence.state = JABBER_BUDDY_STATE_UNKNOWN; presence.sent = time(NULL); /* interesting values */ presence.from = xmlnode_get_attrib(packet, "from"); presence.to = xmlnode_get_attrib(packet, "to"); type = xmlnode_get_attrib(packet, "type"); presence.type = str_to_presence_type(type); presence.jb = jabber_buddy_find(js, presence.from, TRUE); g_return_if_fail(presence.jb != NULL); presence.jid_from = jabber_id_new(presence.from); if (presence.jid_from == NULL) { purple_debug_error("jabber", "Ignoring presence with malformed 'from' " "JID: %s\n", presence.from); return; } signal_return = GPOINTER_TO_INT(purple_signal_emit_return_1(purple_connection_get_prpl(js->gc), "jabber-receiving-presence", js->gc, type, presence.from, packet)); if (signal_return) { goto out; } if (presence.jid_from->node) presence.chat = jabber_chat_find(js, presence.jid_from->node, presence.jid_from->domain); if(presence.jb->error_msg) { g_free(presence.jb->error_msg); presence.jb->error_msg = NULL; } if (presence.type == JABBER_PRESENCE_AVAILABLE) { presence.state = JABBER_BUDDY_STATE_ONLINE; } else if (presence.type == JABBER_PRESENCE_ERROR) { /* TODO: Is this handled properly? Should it be treated as per-jbr? */ char *msg = jabber_parse_error(js, packet, NULL); presence.state = JABBER_BUDDY_STATE_ERROR; presence.jb->error_msg = msg ? msg : g_strdup(_("Unknown Error in presence")); } else if (presence.type == JABBER_PRESENCE_SUBSCRIBE) { /* TODO: Move to handle_subscribe() (so nick is extracted by the * PresenceHandler */ struct _jabber_add_permit *jap = g_new0(struct _jabber_add_permit, 1); gboolean onlist = FALSE; PurpleAccount *account; PurpleBuddy *buddy; xmlnode *nick; account = purple_connection_get_account(js->gc); buddy = purple_find_buddy(account, presence.from); nick = xmlnode_get_child_with_namespace(packet, "nick", "http://jabber.org/protocol/nick"); if (nick) presence.nickname = xmlnode_get_data(nick); if (buddy) { if ((presence.jb->subscription & (JABBER_SUB_TO | JABBER_SUB_PENDING))) onlist = TRUE; } jap->gc = js->gc; jap->who = g_strdup(presence.from); jap->js = js; purple_account_request_authorization(account, presence.from, NULL, presence.nickname, NULL, onlist, authorize_add_cb, deny_add_cb, jap); goto out; } else if (presence.type == JABBER_PRESENCE_SUBSCRIBED) {
/** * gimp_session_info_read_geometry: * @info: A #GimpSessionInfo * @cevent A #GdkEventConfigure. If set, use the size from here * instead of from the window allocation. * * Read geometry related information from the associated widget. **/ void gimp_session_info_read_geometry (GimpSessionInfo *info, GdkEventConfigure *cevent) { GdkWindow *window; g_return_if_fail (GIMP_IS_SESSION_INFO (info)); g_return_if_fail (GTK_IS_WINDOW (info->p->widget)); window = gtk_widget_get_window (info->p->widget); if (window) { gint x, y; gdk_window_get_root_origin (window, &x, &y); /* Don't write negative values to the sessionrc, they are * interpreted as relative to the right, respective bottom edge * of the screen. */ info->p->x = MAX (0, x); info->p->y = MAX (0, y); if (gimp_session_info_get_remember_size (info)) { int width; int height; if (cevent) { width = cevent->width; height = cevent->height; } else { GtkAllocation allocation; gtk_widget_get_allocation (info->p->widget, &allocation); width = allocation.width; height = allocation.height; } info->p->width = width; info->p->height = height; } else { info->p->width = 0; info->p->height = 0; } } info->p->open = FALSE; if (gimp_session_info_get_remember_if_open (info)) { GimpDialogVisibilityState visibility; visibility = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->p->widget), GIMP_DIALOG_VISIBILITY_KEY)); switch (visibility) { case GIMP_DIALOG_VISIBILITY_UNKNOWN: info->p->open = gtk_widget_get_visible (info->p->widget); break; case GIMP_DIALOG_VISIBILITY_INVISIBLE: info->p->open = FALSE; break; case GIMP_DIALOG_VISIBILITY_HIDDEN: case GIMP_DIALOG_VISIBILITY_VISIBLE: /* Even if a dialog is hidden (with Windows->Hide docks) it * is still considered open. It will be restored the next * time GIMP starts */ info->p->open = TRUE; break; } } info->p->screen = DEFAULT_SCREEN; if (info->p->open) { GdkDisplay *display = gtk_widget_get_display (info->p->widget); GdkScreen *screen = gtk_widget_get_screen (info->p->widget); if (screen != gdk_display_get_default_screen (display)) info->p->screen = gdk_screen_get_number (screen); } }
static gint dissect_adb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) { proto_item *main_item; proto_tree *main_tree; proto_item *arg0_item; proto_tree *arg0_tree; proto_item *arg1_item; proto_tree *arg1_tree; proto_item *magic_item; proto_item *crc_item; proto_tree *crc_tree = NULL; proto_item *sub_item; gint offset = 0; guint32 command; guint32 arg0; guint32 arg1; guint32 data_length = 0; guint32 crc32 = 0; usb_conv_info_t *usb_conv_info = NULL; wmem_tree_key_t key[5]; guint32 interface_id; guint32 bus_id; guint32 device_address; guint32 side_id; guint32 frame_number; gboolean is_command = TRUE; gboolean is_next_fragment = FALSE; gboolean is_service = FALSE; gint proto; gint direction = P2P_DIR_UNKNOWN; wmem_tree_t *wmem_tree; command_data_t *command_data = NULL; service_data_t *service_data = NULL; col_set_str(pinfo->cinfo, COL_PROTOCOL, "ADB"); col_clear(pinfo->cinfo, COL_INFO); main_item = proto_tree_add_item(tree, proto_adb, tvb, offset, -1, ENC_NA); main_tree = proto_item_add_subtree(main_item, ett_adb); frame_number = pinfo->num; /* XXX: Why? If interface is USB only first try is correct * (and seems strange...), in other cases standard check for * previous protocol is correct */ proto = (gint) GPOINTER_TO_INT(wmem_list_frame_data(/*wmem_list_frame_prev*/(wmem_list_tail(pinfo->layers)))); if (proto != proto_usb) { proto = (gint) GPOINTER_TO_INT(wmem_list_frame_data(wmem_list_frame_prev(wmem_list_tail(pinfo->layers)))); } if (proto == proto_usb) { usb_conv_info = (usb_conv_info_t *) data; DISSECTOR_ASSERT(usb_conv_info); direction = usb_conv_info->direction; } else if (proto == proto_tcp) { if (pinfo->destport == ADB_TCP_PORT) direction = P2P_DIR_SENT; else direction = P2P_DIR_RECV; } else { return offset; } if (pinfo->phdr->presence_flags & WTAP_HAS_INTERFACE_ID) interface_id = pinfo->phdr->interface_id; else interface_id = 0; if (proto == proto_usb) { bus_id = usb_conv_info->bus_id; device_address = usb_conv_info->device_address; key[0].length = 1; key[0].key = &interface_id; key[1].length = 1; key[1].key = &bus_id; key[2].length = 1; key[2].key = &device_address; key[3].length = 0; key[3].key = NULL; } else { /* tcp */ key[0].length = 1; key[0].key = &interface_id; key[1].length = 1; key[2].length = 1; if (direction == P2P_DIR_SENT) { key[1].key = &pinfo->srcport; key[2].key = &pinfo->destport; } else { key[1].key = &pinfo->destport; key[2].key = &pinfo->srcport; } key[3].length = 0; key[3].key = NULL; } wmem_tree = (wmem_tree_t *) wmem_tree_lookup32_array(command_info, key); if (wmem_tree) { command_data = (command_data_t *) wmem_tree_lookup32_le(wmem_tree, frame_number); if (command_data && command_data->completed_in_frame >= frame_number && command_data->command_in_frame <= frame_number) { if (command_data->command_in_frame != frame_number) { is_command = FALSE; is_next_fragment = TRUE; } data_length = command_data->data_length; crc32 = command_data->crc32; if (direction == P2P_DIR_SENT) if (command_data->command == A_CLSE) side_id = command_data->arg1; /* OUT: local id */ else side_id = command_data->arg0; /* OUT: local id */ else if (command_data->command == A_OKAY) { side_id = command_data->arg1; /* IN: remote id */ } else side_id = command_data->arg1; /* IN: remote id */ key[3].length = 1; key[3].key = &side_id; key[4].length = 0; key[4].key = NULL; wmem_tree = (wmem_tree_t *) wmem_tree_lookup32_array(service_info, key); if (wmem_tree) { service_data = (service_data_t *) wmem_tree_lookup32_le(wmem_tree, frame_number); if (service_data && command_data->command == A_OPEN) { is_service = TRUE; } } } } /* Simple heuristics to check if packet is command or data */ if ((command_data && command_data->completed_in_frame <= frame_number) || !command_data) { if (tvb_reported_length(tvb) < 24) { is_command = FALSE; } else if (tvb_reported_length(tvb) >= 24) { command = tvb_get_letohl(tvb, offset); if (command != A_SYNC && command != A_CLSE && command != A_WRTE && command != A_AUTH && command != A_CNXN && command != A_OPEN && command != A_OKAY) is_command = FALSE; else if (command != (0xFFFFFFFF ^ tvb_get_letohl(tvb, offset + 20))) is_command = FALSE; if (is_command) { data_length = tvb_get_letohl(tvb, offset + 12); crc32 = tvb_get_letohl(tvb, offset + 16); } if (command == A_OPEN) is_service = TRUE; } } if (service_data && !(command_data->command == A_OPEN && is_next_fragment)) { sub_item = proto_tree_add_string(main_tree, hf_service, tvb, offset, 0, service_data->service); PROTO_ITEM_SET_GENERATED(sub_item); } if (service_data) { sub_item = proto_tree_add_uint(main_tree, hf_service_start_in_frame, tvb, offset, 0, service_data->start_in_frame); PROTO_ITEM_SET_GENERATED(sub_item); if (service_data->close_local_in_frame < max_in_frame) { sub_item = proto_tree_add_uint(main_tree, hf_close_local_in_frame, tvb, offset, 0, service_data->close_local_in_frame); PROTO_ITEM_SET_GENERATED(sub_item); } if (service_data->close_remote_in_frame < max_in_frame) { sub_item = proto_tree_add_uint(main_tree, hf_close_remote_in_frame, tvb, offset, 0, service_data->close_remote_in_frame); PROTO_ITEM_SET_GENERATED(sub_item); } } if (is_command) { proto_tree_add_item(main_tree, hf_command, tvb, offset, 4, ENC_LITTLE_ENDIAN); command = tvb_get_letohl(tvb, offset); offset += 4; col_append_str(pinfo->cinfo, COL_INFO, val_to_str_const(command, command_vals, "Unknown command")); arg0_item = proto_tree_add_item(main_tree, hf_argument_0, tvb, offset, 4, ENC_LITTLE_ENDIAN); arg0_tree = proto_item_add_subtree(arg0_item, ett_adb_arg0); arg0 = tvb_get_letohl(tvb, offset); offset += 4; arg1_item = proto_tree_add_item(main_tree, hf_argument_1, tvb, offset, 4, ENC_LITTLE_ENDIAN); arg1_tree = proto_item_add_subtree(arg1_item, ett_adb_arg1); arg1 = tvb_get_letohl(tvb, offset); offset += 4; switch (command) { case A_CNXN: proto_tree_add_item(arg0_tree, hf_version, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(arg1_tree, hf_max_data, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "(version=%u.%u.%u, max_data=%u)", tvb_get_guint8(tvb, offset - 5), tvb_get_guint8(tvb, offset - 6), tvb_get_letohs(tvb, offset - 7), tvb_get_letohl(tvb, offset - 4)); break; case A_AUTH: proto_tree_add_item(arg0_tree, hf_auth_type, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(arg1_tree, hf_zero, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "(type=%s, 0)", val_to_str_const(tvb_get_letohl(tvb, offset - 8), auth_type_vals, "Unknown")); break; case A_OPEN: proto_tree_add_item(arg0_tree, hf_local_id, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(arg1_tree, hf_zero, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "(local=%u, 0)", tvb_get_letohl(tvb, offset - 8)); break; case A_WRTE: proto_tree_add_item(arg0_tree, hf_zero, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(arg1_tree, hf_remote_id, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "(0, remote=%u)", tvb_get_letohl(tvb, offset - 4)); break; case A_CLSE: case A_OKAY: proto_tree_add_item(arg0_tree, hf_local_id, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(arg1_tree, hf_remote_id, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "(local=%u, remote=%u)", tvb_get_letohl(tvb, offset - 8), tvb_get_letohl(tvb, offset - 4)); break; case A_SYNC: proto_tree_add_item(arg0_tree, hf_online, tvb, offset - 8, 4, ENC_LITTLE_ENDIAN); proto_tree_add_item(arg1_tree, hf_sequence, tvb, offset - 4, 4, ENC_LITTLE_ENDIAN); col_append_fstr(pinfo->cinfo, COL_INFO, "(online=%s, sequence=%u)", tvb_get_letohl(tvb, offset - 8) ? "Yes": "No", tvb_get_letohl(tvb, offset - 4)); break; } proto_tree_add_item(main_tree, hf_data_length, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; if (data_length > 0) col_append_fstr(pinfo->cinfo, COL_INFO, " length=%u ", data_length); crc_item = proto_tree_add_item(main_tree, hf_data_crc32, tvb, offset, 4, ENC_LITTLE_ENDIAN); crc_tree = proto_item_add_subtree(crc_item, ett_adb_crc); crc32 = tvb_get_letohl(tvb, offset); offset += 4; magic_item = proto_tree_add_item(main_tree, hf_magic, tvb, offset, 4, ENC_LITTLE_ENDIAN); if ((tvb_get_letohl(tvb, offset) ^ 0xFFFFFFFF) != command) { proto_tree *expert_tree; expert_tree = proto_item_add_subtree(magic_item, ett_adb_magic); proto_tree_add_expert(expert_tree, pinfo, &ei_invalid_magic, tvb, offset, 4); } if (!pinfo->fd->flags.visited) save_command(command, arg0, arg1, data_length, crc32, service_data, proto, data, pinfo, &service_data, &command_data); offset += 4; } if (!pinfo->fd->flags.visited && command_data) { if (command_data->command_in_frame != frame_number) { is_command = FALSE; is_next_fragment = TRUE; } data_length = command_data->data_length; crc32 = command_data->crc32; if ((command_data->command_in_frame != frame_number && tvb_captured_length(tvb) == data_length) || (command_data->command_in_frame == frame_number && tvb_captured_length(tvb) == data_length + 24) ) { command_data->reassemble_data_length = command_data->data_length; command_data->completed_in_frame = frame_number; } } if (is_next_fragment && command_data) { sub_item = proto_tree_add_uint(main_tree, hf_command_in_frame, tvb, offset, 0, command_data->command_in_frame); PROTO_ITEM_SET_GENERATED(sub_item); sub_item = proto_tree_add_uint(main_tree, hf_command, tvb, offset, 0, command_data->command); PROTO_ITEM_SET_GENERATED(sub_item); sub_item = proto_tree_add_uint(main_tree, hf_data_length, tvb, offset, 0, command_data->data_length); PROTO_ITEM_SET_GENERATED(sub_item); crc_item = proto_tree_add_uint(main_tree, hf_data_crc32, tvb, offset, 0, command_data->crc32); crc_tree = proto_item_add_subtree(crc_item, ett_adb_crc); PROTO_ITEM_SET_GENERATED(crc_item); } if (command_data && command_data->completed_in_frame != frame_number) { sub_item = proto_tree_add_uint(main_tree, hf_completed_in_frame, tvb, offset, 0, command_data->completed_in_frame); PROTO_ITEM_SET_GENERATED(sub_item); } if (tvb_captured_length_remaining(tvb, offset) > 0 && (!is_command || data_length > 0)) { guint32 crc = 0; guint32 i_offset; if ((!pinfo->fd->flags.visited && command_data && command_data->reassemble_data_length < command_data->data_length) || data_length > (guint32) tvb_captured_length_remaining(tvb, offset)) { /* need reassemble */ if (!pinfo->fd->flags.visited && command_data && command_data->reassemble_data_length < command_data->data_length) { tvb_memcpy(tvb, command_data->reassemble_data + command_data->reassemble_data_length, offset, tvb_captured_length_remaining(tvb, offset)); command_data->reassemble_data_length += tvb_captured_length_remaining(tvb, offset); if (command_data->reassemble_data_length >= command_data->data_length) command_data->completed_in_frame = frame_number; } proto_tree_add_item(main_tree, hf_data_fragment, tvb, offset, -1, ENC_NA); col_append_str(pinfo->cinfo, COL_INFO, "Data Fragment"); offset = tvb_captured_length(tvb); if (service_data && command_data && command_data->reassemble_data_length >= command_data->data_length && frame_number == command_data->completed_in_frame) { tvbuff_t *next_tvb; adb_service_data_t adb_service_data; next_tvb = tvb_new_child_real_data(tvb, command_data->reassemble_data, command_data->reassemble_data_length, command_data->reassemble_data_length); add_new_data_source(pinfo, next_tvb, "ADB Reassembled Data"); adb_service_data.service = service_data->service; adb_service_data.direction = direction; adb_service_data.session_key_length = 3; adb_service_data.session_key = (guint32 *) wmem_alloc(wmem_packet_scope(), adb_service_data.session_key_length * sizeof(guint32)); adb_service_data.session_key[0] = interface_id; if (proto == proto_usb) { adb_service_data.session_key[1] = usb_conv_info->bus_id; adb_service_data.session_key[2] = usb_conv_info->device_address; } else { /* tcp */ if (direction == P2P_DIR_SENT) { adb_service_data.session_key[1] = pinfo->srcport; adb_service_data.session_key[2] = pinfo->destport; } else { adb_service_data.session_key[1] = pinfo->destport; adb_service_data.session_key[2] = pinfo->srcport; } } call_dissector_with_data(adb_service_handle, next_tvb, pinfo, tree, &adb_service_data); } } else { /* full message */ for (i_offset = 0; i_offset < data_length; ++i_offset) crc += tvb_get_guint8(tvb, offset + i_offset); if (crc32 > 0 && crc32 != crc) proto_tree_add_expert(crc_tree, pinfo, &ei_invalid_crc, tvb, offset, -1); if (is_service) { proto_tree_add_item(main_tree, hf_service, tvb, offset, -1, ENC_ASCII | ENC_NA); if (!pinfo->fd->flags.visited && service_data) { service_data->service = tvb_get_stringz_enc(wmem_file_scope(), tvb, offset, NULL, ENC_ASCII); } col_append_fstr(pinfo->cinfo, COL_INFO, "Service: %s", tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, NULL, ENC_ASCII)); offset = tvb_captured_length(tvb); } else if (command_data && command_data->command == A_CNXN) { gchar *info; gint len; info = tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, &len, ENC_ASCII); col_append_fstr(pinfo->cinfo, COL_INFO, "Connection Info: %s", info); proto_tree_add_item(main_tree, hf_connection_info, tvb, offset, len, ENC_ASCII | ENC_NA); offset += len; } else { col_append_str(pinfo->cinfo, COL_INFO, "Data"); /* Decode service payload */ if (service_data) { tvbuff_t *next_tvb; adb_service_data_t adb_service_data; adb_service_data.service = service_data->service; adb_service_data.direction = direction; adb_service_data.session_key_length = 3; adb_service_data.session_key = (guint32 *) wmem_alloc(wmem_packet_scope(), adb_service_data.session_key_length * sizeof(guint32)); adb_service_data.session_key[0] = interface_id; if (proto == proto_usb) { adb_service_data.session_key[1] = usb_conv_info->bus_id; adb_service_data.session_key[2] = usb_conv_info->device_address; } else { /* tcp */ if (direction == P2P_DIR_SENT) { adb_service_data.session_key[1] = pinfo->srcport; adb_service_data.session_key[2] = pinfo->destport; } else { adb_service_data.session_key[1] = pinfo->destport; adb_service_data.session_key[2] = pinfo->srcport; } } next_tvb = tvb_new_subset(tvb, offset, tvb_captured_length_remaining(tvb, offset), tvb_captured_length_remaining(tvb, offset)); call_dissector_with_data(adb_service_handle, next_tvb, pinfo, tree, &adb_service_data); } else { proto_item *data_item; gchar *data_str; data_item = proto_tree_add_item(main_tree, hf_data, tvb, offset, data_length, ENC_NA); data_str = tvb_format_text(tvb, offset, data_length); proto_item_append_text(data_item, ": %s", data_str); col_append_fstr(pinfo->cinfo, COL_INFO, " Raw: %s", data_str); } offset = tvb_captured_length(tvb); } } } return offset; }
void gtkui_state_quicksave(GtkWidget *widget, gpointer userdata) { // Wrapper function to quicksave states nst_state_quicksave(GPOINTER_TO_INT(userdata)); }
static GTokenType plug_in_icon_deserialize (GScanner *scanner, GimpPlugInProcedure *proc) { GEnumClass *enum_class; GEnumValue *enum_value; GimpIconType icon_type; gint icon_data_length; gchar *icon_name; guint8 *icon_data; if (! gimp_scanner_parse_token (scanner, G_TOKEN_LEFT_PAREN)) return G_TOKEN_LEFT_PAREN; if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL) || GPOINTER_TO_INT (scanner->value.v_symbol) != ICON) return G_TOKEN_SYMBOL; enum_class = g_type_class_peek (GIMP_TYPE_ICON_TYPE); switch (g_scanner_peek_next_token (scanner)) { case G_TOKEN_IDENTIFIER: g_scanner_get_next_token (scanner); enum_value = g_enum_get_value_by_nick (G_ENUM_CLASS (enum_class), scanner->value.v_identifier); if (!enum_value) enum_value = g_enum_get_value_by_name (G_ENUM_CLASS (enum_class), scanner->value.v_identifier); if (!enum_value) { g_scanner_error (scanner, _("invalid value '%s' for icon type"), scanner->value.v_identifier); return G_TOKEN_NONE; } break; case G_TOKEN_INT: g_scanner_get_next_token (scanner); enum_value = g_enum_get_value (enum_class, (gint) scanner->value.v_int64); if (!enum_value) { g_scanner_error (scanner, _("invalid value '%ld' for icon type"), (glong) scanner->value.v_int64); return G_TOKEN_NONE; } break; default: return G_TOKEN_IDENTIFIER; } icon_type = enum_value->value; if (! gimp_scanner_parse_int (scanner, &icon_data_length)) return G_TOKEN_INT; switch (icon_type) { case GIMP_ICON_TYPE_STOCK_ID: case GIMP_ICON_TYPE_IMAGE_FILE: icon_data_length = -1; if (! gimp_scanner_parse_string_no_validate (scanner, &icon_name)) return G_TOKEN_STRING; icon_data = (guint8 *) icon_name; break; case GIMP_ICON_TYPE_INLINE_PIXBUF: if (icon_data_length < 0) return G_TOKEN_STRING; if (! gimp_scanner_parse_data (scanner, icon_data_length, &icon_data)) return G_TOKEN_STRING; break; } proc->icon_type = icon_type; proc->icon_data_length = icon_data_length; proc->icon_data = icon_data; if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) return G_TOKEN_RIGHT_PAREN; return G_TOKEN_LEFT_PAREN; }
/** Utility functions used for various comparisons/cleanups in tree **/ static gint rrc_key_cmp(gconstpointer b_ptr, gconstpointer a_ptr, gpointer ignore _U_){ if( GPOINTER_TO_INT(a_ptr) > GPOINTER_TO_INT(b_ptr) ){ return -1; } return GPOINTER_TO_INT(a_ptr) < GPOINTER_TO_INT(b_ptr); }
static GTokenType plug_in_file_proc_deserialize (GScanner *scanner, GimpPlugInProcedure *proc) { GTokenType token; gint symbol; gchar *value; if (! gimp_scanner_parse_token (scanner, G_TOKEN_LEFT_PAREN)) return G_TOKEN_LEFT_PAREN; if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL)) return G_TOKEN_SYMBOL; symbol = GPOINTER_TO_INT (scanner->value.v_symbol); if (symbol != LOAD_PROC && symbol != SAVE_PROC) return G_TOKEN_SYMBOL; proc->file_proc = TRUE; g_scanner_set_scope (scanner, symbol); while (g_scanner_peek_next_token (scanner) == G_TOKEN_LEFT_PAREN) { token = g_scanner_get_next_token (scanner); if (token != G_TOKEN_LEFT_PAREN) return token; if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL)) return G_TOKEN_SYMBOL; symbol = GPOINTER_TO_INT (scanner->value.v_symbol); if (symbol == MAGIC) { if (! gimp_scanner_parse_string_no_validate (scanner, &value)) return G_TOKEN_STRING; } else { if (! gimp_scanner_parse_string (scanner, &value)) return G_TOKEN_STRING; } switch (symbol) { case EXTENSION: g_free (proc->extensions); proc->extensions = value; break; case PREFIX: g_free (proc->prefixes); proc->prefixes = value; break; case MAGIC: g_free (proc->magics); proc->magics = value; break; case MIME_TYPE: gimp_plug_in_procedure_set_mime_type (proc, value); g_free (value); break; case THUMB_LOADER: gimp_plug_in_procedure_set_thumb_loader (proc, value); g_free (value); break; default: return G_TOKEN_SYMBOL; } if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) return G_TOKEN_RIGHT_PAREN; } if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) return G_TOKEN_RIGHT_PAREN; g_scanner_set_scope (scanner, PLUG_IN_DEF); return G_TOKEN_LEFT_PAREN; }
static void add_filter_clicked(GtkMenuItem* menuitem, CamoramaFilterChain* chain) { GType filter_type = GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(menuitem), menu_item_filter_type)); camorama_filter_chain_append(chain, filter_type); }
GSList * plug_in_rc_parse (Gimp *gimp, const gchar *filename, GError **error) { GScanner *scanner; GEnumClass *enum_class; GSList *plug_in_defs = NULL; gint version = GIMP_PROTOCOL_VERSION; GTokenType token; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (filename != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); scanner = gimp_scanner_new_file (filename, error); if (! scanner) return NULL; enum_class = g_type_class_ref (GIMP_TYPE_ICON_TYPE); g_scanner_scope_add_symbol (scanner, 0, "protocol-version", GINT_TO_POINTER (PROTOCOL_VERSION)); g_scanner_scope_add_symbol (scanner, 0, "plug-in-def", GINT_TO_POINTER (PLUG_IN_DEF)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "proc-def", GINT_TO_POINTER (PROC_DEF)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "locale-def", GINT_TO_POINTER (LOCALE_DEF)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "help-def", GINT_TO_POINTER (HELP_DEF)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "has-init", GINT_TO_POINTER (HAS_INIT)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "proc-arg", GINT_TO_POINTER (PROC_ARG)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "menu-path", GINT_TO_POINTER (MENU_PATH)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "icon", GINT_TO_POINTER (ICON)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "load-proc", GINT_TO_POINTER (LOAD_PROC)); g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, "save-proc", GINT_TO_POINTER (SAVE_PROC)); g_scanner_scope_add_symbol (scanner, LOAD_PROC, "extension", GINT_TO_POINTER (EXTENSION)); g_scanner_scope_add_symbol (scanner, LOAD_PROC, "prefix", GINT_TO_POINTER (PREFIX)); g_scanner_scope_add_symbol (scanner, LOAD_PROC, "magic", GINT_TO_POINTER (MAGIC)); g_scanner_scope_add_symbol (scanner, LOAD_PROC, "mime-type", GINT_TO_POINTER (MIME_TYPE)); g_scanner_scope_add_symbol (scanner, LOAD_PROC, "thumb-loader", GINT_TO_POINTER (THUMB_LOADER)); g_scanner_scope_add_symbol (scanner, SAVE_PROC, "extension", GINT_TO_POINTER (EXTENSION)); g_scanner_scope_add_symbol (scanner, SAVE_PROC, "prefix", GINT_TO_POINTER (PREFIX)); g_scanner_scope_add_symbol (scanner, SAVE_PROC, "mime-type", GINT_TO_POINTER (MIME_TYPE)); token = G_TOKEN_LEFT_PAREN; while (version == GIMP_PROTOCOL_VERSION && g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: switch (GPOINTER_TO_INT (scanner->value.v_symbol)) { case PROTOCOL_VERSION: token = G_TOKEN_INT; if (gimp_scanner_parse_int (scanner, &version)) token = G_TOKEN_RIGHT_PAREN; break; case PLUG_IN_DEF: g_scanner_set_scope (scanner, PLUG_IN_DEF); token = plug_in_def_deserialize (gimp, scanner, &plug_in_defs); g_scanner_set_scope (scanner, 0); break; default: break; } break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: /* do nothing */ break; } } if (version != GIMP_PROTOCOL_VERSION || token != G_TOKEN_LEFT_PAREN) { if (version != GIMP_PROTOCOL_VERSION) { g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_VERSION, _("Skipping '%s': wrong GIMP protocol version."), gimp_filename_to_utf8 (filename)); } else { g_scanner_get_next_token (scanner); g_scanner_unexp_token (scanner, token, NULL, NULL, NULL, _("fatal parse error"), TRUE); } g_slist_free_full (plug_in_defs, (GDestroyNotify) g_object_unref); plug_in_defs = NULL; } g_type_class_unref (enum_class); gimp_scanner_destroy (scanner); return g_slist_reverse (plug_in_defs); }
static gboolean gimp_session_info_deserialize (GimpConfig *config, GScanner *scanner, gint nest_level, gpointer data) { GimpSessionInfo *info = GIMP_SESSION_INFO (config); GTokenType token; guint scope_id; guint old_scope_id; scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config)); old_scope_id = g_scanner_set_scope (scanner, scope_id); g_scanner_scope_add_symbol (scanner, scope_id, "factory-entry", GINT_TO_POINTER (SESSION_INFO_FACTORY_ENTRY)); g_scanner_scope_add_symbol (scanner, scope_id, "position", GINT_TO_POINTER (SESSION_INFO_POSITION)); g_scanner_scope_add_symbol (scanner, scope_id, "size", GINT_TO_POINTER (SESSION_INFO_SIZE)); g_scanner_scope_add_symbol (scanner, scope_id, "monitor", GINT_TO_POINTER (SESSION_INFO_MONITOR)); g_scanner_scope_add_symbol (scanner, scope_id, "open-on-exit", GINT_TO_POINTER (SESSION_INFO_OPEN)); g_scanner_scope_add_symbol (scanner, scope_id, "aux-info", GINT_TO_POINTER (SESSION_INFO_AUX)); g_scanner_scope_add_symbol (scanner, scope_id, "gimp-dock", GINT_TO_POINTER (SESSION_INFO_GIMP_DOCK)); g_scanner_scope_add_symbol (scanner, scope_id, "gimp-toolbox", GINT_TO_POINTER (SESSION_INFO_GIMP_TOOLBOX)); /* For sessionrc files from version <= GIMP 2.6 */ g_scanner_scope_add_symbol (scanner, scope_id, "dock", GINT_TO_POINTER (SESSION_INFO_DOCK)); token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { gint dummy; case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: switch (GPOINTER_TO_INT (scanner->value.v_symbol)) { case SESSION_INFO_FACTORY_ENTRY: { gchar *identifier = NULL; GimpDialogFactoryEntry *entry = NULL; token = G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &identifier)) goto error; entry = gimp_dialog_factory_find_entry (gimp_dialog_factory_get_singleton (), identifier); if (! entry) goto error; gimp_session_info_set_factory_entry (info, entry); g_free (identifier); } break; case SESSION_INFO_POSITION: token = G_TOKEN_INT; if (! gimp_session_info_parse_offset (scanner, &info->p->x, &info->p->right_align)) goto error; if (! gimp_session_info_parse_offset (scanner, &info->p->y, &info->p->bottom_align)) goto error; break; case SESSION_INFO_SIZE: token = G_TOKEN_INT; if (! gimp_scanner_parse_int (scanner, &info->p->width)) goto error; if (! gimp_scanner_parse_int (scanner, &info->p->height)) goto error; break; case SESSION_INFO_MONITOR: token = G_TOKEN_INT; if (gimp_scanner_parse_int (scanner, &dummy)) { info->p->monitor = gdk_display_get_monitor (gdk_display_get_default (), dummy); } else goto error; break; case SESSION_INFO_OPEN: info->p->open = TRUE; /* the screen number is optional, and obsolete */ if (g_scanner_peek_next_token (scanner) == G_TOKEN_RIGHT_PAREN) break; token = G_TOKEN_INT; if (! gimp_scanner_parse_int (scanner, &dummy)) goto error; break; case SESSION_INFO_AUX: token = gimp_session_info_aux_deserialize (scanner, &info->p->aux_info); if (token != G_TOKEN_LEFT_PAREN) goto error; break; case SESSION_INFO_GIMP_TOOLBOX: case SESSION_INFO_GIMP_DOCK: case SESSION_INFO_DOCK: { GimpSessionInfoDock *dock_info = NULL; const gchar *dock_type = NULL; /* Handle old sessionrc:s from versions <= GIMP 2.6 */ if (GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_DOCK && info->p->factory_entry && info->p->factory_entry->identifier && strcmp ("gimp-toolbox-window", info->p->factory_entry->identifier) == 0) { dock_type = "gimp-toolbox"; } else { dock_type = ((GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_GIMP_TOOLBOX) ? "gimp-toolbox" : "gimp-dock"); } g_scanner_set_scope (scanner, scope_id + 1); token = gimp_session_info_dock_deserialize (scanner, scope_id + 1, &dock_info, dock_type); if (token == G_TOKEN_LEFT_PAREN) { g_scanner_set_scope (scanner, scope_id); info->p->docks = g_list_append (info->p->docks, dock_info); } else goto error; } break; default: break; } token = G_TOKEN_RIGHT_PAREN; break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: break; } } error: /* If we don't have docks, assume it is a toolbox dock window from a * sessionrc file from GIMP <= 2.6 and add a toolbox dock manually */ if (! info->p->docks && info->p->factory_entry && strcmp ("gimp-toolbox-window", info->p->factory_entry->identifier) == 0) { info->p->docks = g_list_append (info->p->docks, gimp_session_info_dock_new ("gimp-toolbox")); } g_scanner_scope_remove_symbol (scanner, scope_id, "factory-entry"); g_scanner_scope_remove_symbol (scanner, scope_id, "position"); g_scanner_scope_remove_symbol (scanner, scope_id, "size"); g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit"); g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info"); g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-dock"); g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-toolbox"); g_scanner_scope_remove_symbol (scanner, scope_id, "dock"); g_scanner_set_scope (scanner, old_scope_id); return gimp_config_deserialize_return (scanner, token, nest_level); }
static void delete_button_clicked (GtkButton *button, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data; int res = GTK_RESPONSE_YES; guint tagid; GtkTreeIter iter; GtkTreeModel *model = NULL; GtkTreeView *view = d->related; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); if(!gtk_tree_selection_get_selected(selection, &model, &iter)) return; gtk_tree_model_get (model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1); // First check how many images are affected by the remove int count = dt_tag_remove(tagid,FALSE); if( count > 0 && dt_conf_get_bool("plugins/lighttable/tagging/ask_before_delete_tag") ) { GtkWidget *dialog; GtkWidget *win = dt_ui_main_window(darktable.gui->ui); const gchar *tagname=dt_tag_get_name(tagid); dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, ngettext("do you really want to delete the tag `%s'?\n%d image is assigned this tag!", "do you really want to delete the tag `%s'?\n%d images are assigned this tag!", count), tagname,count); gtk_window_set_title(GTK_WINDOW(dialog), _("delete tag?")); res = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } if(res != GTK_RESPONSE_YES) return; GList *tagged_images = NULL; sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid from tagged_images where tagid=?1", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, tagid); while(sqlite3_step(stmt) == SQLITE_ROW) { tagged_images = g_list_append(tagged_images, GINT_TO_POINTER(sqlite3_column_int(stmt, 0))); } sqlite3_finalize(stmt); dt_tag_remove(tagid,TRUE); GList *list_iter; if((list_iter = g_list_first(tagged_images)) != NULL) { do { dt_image_synch_xmp(GPOINTER_TO_INT(list_iter->data)); } while((list_iter=g_list_next(list_iter)) != NULL); } g_list_free(g_list_first(tagged_images)); update(self, 0); update(self, 1); }
/** * gimp_session_info_read_geometry: * @info: A #GimpSessionInfo * @cevent A #GdkEventConfigure. If set, use the size from here * instead of from the window allocation. * * Read geometry related information from the associated widget. **/ void gimp_session_info_read_geometry (GimpSessionInfo *info, GdkEventConfigure *cevent) { GdkWindow *window; GdkDisplay *display; g_return_if_fail (GIMP_IS_SESSION_INFO (info)); g_return_if_fail (GTK_IS_WINDOW (info->p->widget)); window = gtk_widget_get_window (info->p->widget); display = gtk_widget_get_display (info->p->widget); if (window) { gint x, y; GdkMonitor *monitor; GdkRectangle geometry; gtk_window_get_position (GTK_WINDOW (info->p->widget), &x, &y); /* Don't write negative values to the sessionrc, they are * interpreted as relative to the right, respective bottom edge * of the display. */ info->p->x = MAX (0, x); info->p->y = MAX (0, y); monitor = gdk_display_get_monitor_at_point (display, info->p->x, info->p->y); gdk_monitor_get_geometry (monitor, &geometry); /* Always store window coordinates relative to the monitor */ info->p->x -= geometry.x; info->p->y -= geometry.y; if (gimp_session_info_get_remember_size (info)) { gtk_window_get_size (GTK_WINDOW (info->p->widget), &info->p->width, &info->p->height); } else { info->p->width = 0; info->p->height = 0; } info->p->monitor = DEFAULT_MONITOR; if (monitor != gdk_display_get_primary_monitor (display)) info->p->monitor = monitor; } info->p->open = FALSE; if (gimp_session_info_get_remember_if_open (info)) { GimpDialogVisibilityState visibility; visibility = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->p->widget), GIMP_DIALOG_VISIBILITY_KEY)); switch (visibility) { case GIMP_DIALOG_VISIBILITY_UNKNOWN: info->p->open = gtk_widget_get_visible (info->p->widget); break; case GIMP_DIALOG_VISIBILITY_INVISIBLE: info->p->open = FALSE; break; case GIMP_DIALOG_VISIBILITY_HIDDEN: case GIMP_DIALOG_VISIBILITY_VISIBLE: /* Even if a dialog is hidden (with Windows->Hide docks) it * is still considered open. It will be restored the next * time GIMP starts */ info->p->open = TRUE; break; } } }
static void wnck_selector_make_menu_consistent (WnckSelector *selector) { GList *l, *children; int workspace_n; GtkWidget *workspace_item; GtkWidget *separator; gboolean separator_is_first; gboolean separator_is_last; gboolean visible_window; workspace_n = -1; workspace_item = NULL; separator = NULL; separator_is_first = FALSE; separator_is_last = FALSE; visible_window = FALSE; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { int i; i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data), "wnck-selector-workspace-n")); if (i > 0) { workspace_n = i - 1; /* we have two consecutive workspace items => hide the first */ if (workspace_item) gtk_widget_hide (workspace_item); workspace_item = GTK_WIDGET (l->data); } else if (GTK_IS_SEPARATOR_MENU_ITEM (l->data)) { if (!visible_window) separator_is_first = TRUE; separator_is_last = TRUE; separator = GTK_WIDGET (l->data); } else if (gtk_widget_get_visible (l->data) && l->data != selector->priv->no_windows_item) { separator_is_last = FALSE; visible_window = TRUE; /* if we know of a workspace item that was not shown */ if (workspace_item) { WnckWindow *window; WnckWorkspace *workspace; window = g_object_get_data (G_OBJECT (l->data), "wnck-selector-window"); if (window) { workspace = wnck_window_get_workspace (window); if (workspace && workspace_n == wnck_workspace_get_number (workspace)) { gtk_widget_show (workspace_item); workspace_n = -1; workspace_item = NULL; } } } } /* end if (normal item) */ } g_list_free (children); /* do we have a trailing workspace item to be hidden? */ if (workspace_item) gtk_widget_hide (workspace_item); if (separator) { if (separator_is_first || separator_is_last) gtk_widget_hide (separator); else gtk_widget_show (separator); } if (visible_window) gtk_widget_hide (selector->priv->no_windows_item); else gtk_widget_show (selector->priv->no_windows_item); }
static int client_ev_init_errors_func() { return GPOINTER_TO_INT(pthread_getspecific(client_ev_init_errors_key)); }
void show_pd_detail(void) { GSList *l, *ll, *ol; struct srd_decoder *dec; struct srd_decoder_option *o; char **pdtokens, **pdtok, *optsep, **ann, *val, *doc; struct srd_channel *pdch; struct srd_decoder_annotation_row *r; pdtokens = g_strsplit(opt_pds, ",", -1); for (pdtok = pdtokens; *pdtok; pdtok++) { /* Strip options. */ if ((optsep = strchr(*pdtok, ':'))) *optsep = '\0'; if (!(dec = srd_decoder_get_by_id(*pdtok))) { g_critical("Protocol decoder %s not found.", *pdtok); return; } printf("ID: %s\nName: %s\nLong name: %s\nDescription: %s\n", dec->id, dec->name, dec->longname, dec->desc); printf("License: %s\n", dec->license); printf("Annotation classes:\n"); if (dec->annotations) { for (l = dec->annotations; l; l = l->next) { ann = l->data; printf("- %s: %s\n", ann[0], ann[1]); } } else { printf("None.\n"); } printf("Annotation rows:\n"); if (dec->annotation_rows) { for (l = dec->annotation_rows; l; l = l->next) { r = l->data; printf("- %s (%s): ", r->id, r->desc); for (ll = r->ann_classes; ll; ll = ll->next) printf("%d ", GPOINTER_TO_INT(ll->data)); printf("\n"); } } else { printf("None.\n"); } printf("Required channels:\n"); if (dec->channels) { for (l = dec->channels; l; l = l->next) { pdch = l->data; printf("- %s (%s): %s\n", pdch->id, pdch->name, pdch->desc); } } else { printf("None.\n"); } printf("Optional channels:\n"); if (dec->opt_channels) { for (l = dec->opt_channels; l; l = l->next) { pdch = l->data; printf("- %s (%s): %s\n", pdch->id, pdch->name, pdch->desc); } } else { printf("None.\n"); } printf("Options:\n"); if (dec->options) { for (l = dec->options; l; l = l->next) { o = l->data; printf("- %s: %s (", o->id, o->desc); for (ol = o->values; ol; ol = ol->next) { val = g_variant_print(ol->data, FALSE); printf("%s, ", val); g_free(val); } val = g_variant_print(o->def, FALSE); printf("default %s)\n", val); g_free(val); } } else { printf("None.\n"); } if ((doc = srd_decoder_doc_get(dec))) { printf("Documentation:\n%s\n", doc[0] == '\n' ? doc + 1 : doc); g_free(doc); } } g_strfreev(pdtokens); }
static void _tracker_logSocket(Tracker* tracker, GLogLevelFlags level, SimulationTime interval) { if(!tracker->didLogSocketHeader) { tracker->didLogSocketHeader = TRUE; logging_log(G_LOG_DOMAIN, level, __FILE__, __FUNCTION__, __LINE__, "[shadow-heartbeat] [socket-header] descriptor-number,protocol-string,hostname:port-peer;" "inbuflen-bytes,inbufsize-bytes,outbuflen-bytes,outbufsize-bytes;recv-bytes,send-bytes;" "inbound-localhost-counters;outbound-localhost-counters;" "inbound-remote-counters;outbound-remote-counters|..." // for each socket "where counters are: %s", _tracker_getCounterHeaderString()); } /* construct the log message from all sockets we have in the hash table */ GString* msg = g_string_new("[shadow-heartbeat] [socket] "); SocketStats* ss = NULL; GHashTableIter socketIterator; g_hash_table_iter_init(&socketIterator, tracker->socketStats); /* as we iterate, keep track of sockets that we should remove. we cant remove them * during the iteration because it will invalidate the iterator */ GQueue* handlesToRemove = g_queue_new(); gint socketLogCount = 0; while(g_hash_table_iter_next(&socketIterator, NULL, (gpointer*)&ss)) { /* don't log tcp sockets that don't have peer IP/port set */ if(!ss || (ss->type == PTCP && !ss->peerIP)) { continue; } gsize totalRecvBytes = _tracker_sumBytes(&ss->local.inCounters.bytes) + _tracker_sumBytes(&ss->remote.inCounters.bytes); gsize totalSendBytes = _tracker_sumBytes(&ss->local.outCounters.bytes) + _tracker_sumBytes(&ss->remote.outCounters.bytes); gchar* inLocal = _tracker_getCounterString(&ss->local.inCounters); gchar* outLocal = _tracker_getCounterString(&ss->local.outCounters); gchar* inRemote = _tracker_getCounterString(&ss->remote.inCounters); gchar* outRemote = _tracker_getCounterString(&ss->remote.outCounters); /* print the node separator between node logs */ if(socketLogCount > 0) { g_string_append_printf(msg, "|"); } socketLogCount++; g_string_append_printf(msg, "%d,%s,%s:%u;" "%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT";" "%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT";" "%s;%s;%s;%s", ss->handle, /*inet_ntoa((struct in_addr){socket->peerIP})*/ ss->type == PTCP ? "TCP" : ss->type == PUDP ? "UDP" : ss->type == PLOCAL ? "LOCAL" : "UNKNOWN", ss->peerHostname, ss->peerPort, ss->inputBufferLength, ss->inputBufferSize, ss->outputBufferLength, ss->outputBufferSize, totalRecvBytes, totalSendBytes, inLocal, outLocal, inRemote, outRemote); g_free(inLocal); g_free(outLocal); g_free(inRemote); g_free(outRemote); /* check if we should remove the socket after iterating */ if(ss->removeAfterNextLog) { g_queue_push_tail(handlesToRemove, GINT_TO_POINTER(ss->handle)); } } if(socketLogCount > 0) { logging_log(G_LOG_DOMAIN, level, __FILE__, __FUNCTION__, __LINE__, "%s", msg->str); } /* free all the tracker instances of the sockets that were closed, now that we logged the info */ while(!g_queue_is_empty(handlesToRemove)) { gint handle = GPOINTER_TO_INT(g_queue_pop_head(handlesToRemove)); g_hash_table_remove(tracker->socketStats, &handle); } g_queue_free(handlesToRemove); g_string_free(msg, TRUE); }
extern void admin_edit_resv(GtkCellRendererText *cell, const char *path_string, const char *new_text, gpointer data) { GtkTreeStore *treestore = GTK_TREE_STORE(data); GtkTreePath *path = gtk_tree_path_new_from_string(path_string); GtkTreeIter iter; resv_desc_msg_t *resv_msg = xmalloc(sizeof(resv_desc_msg_t)); char *temp = NULL; char *old_text = NULL; const char *type = NULL; int column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell), "column")); if (!new_text || !strcmp(new_text, "")) goto no_input; gtk_tree_model_get_iter(GTK_TREE_MODEL(treestore), &iter, path); slurm_init_resv_desc_msg(resv_msg); gtk_tree_model_get(GTK_TREE_MODEL(treestore), &iter, SORTID_NAME, &temp, column, &old_text, -1); resv_msg->name = xstrdup(temp); g_free(temp); type = _set_resv_msg(resv_msg, new_text, column); if (global_edit_error) goto print_error; if (got_edit_signal) { temp = got_edit_signal; got_edit_signal = NULL; _admin_resv(GTK_TREE_MODEL(treestore), &iter, temp); xfree(temp); goto no_input; } if (old_text && !strcmp(old_text, new_text)) { temp = g_strdup_printf("No change in value."); } else if (slurm_update_reservation(resv_msg) == SLURM_SUCCESS) { gtk_tree_store_set(treestore, &iter, column, new_text, -1); temp = g_strdup_printf("Reservation %s %s changed to %s", resv_msg->name, type, new_text); } else if (errno == ESLURM_DISABLED) { temp = g_strdup_printf( "Can only edit %s on reservations not yet started.", type); } else { print_error: temp = g_strdup_printf("Reservation %s %s can't be " "set to %s", resv_msg->name, type, new_text); } display_edit_note(temp); g_free(temp); no_input: slurm_free_resv_desc_msg(resv_msg); gtk_tree_path_free (path); g_free(old_text); g_static_mutex_unlock(&sview_mutex); }
static GTokenType plug_in_def_deserialize (Gimp *gimp, GScanner *scanner, GSList **plug_in_defs) { GimpPlugInDef *plug_in_def; GimpPlugInProcedure *proc = NULL; gchar *name; gchar *path; gint mtime; GTokenType token; if (! gimp_scanner_parse_string (scanner, &name)) return G_TOKEN_STRING; path = gimp_config_path_expand (name, TRUE, NULL); g_free (name); plug_in_def = gimp_plug_in_def_new (path); g_free (path); if (! gimp_scanner_parse_int (scanner, &mtime)) { g_object_unref (plug_in_def); return G_TOKEN_INT; } plug_in_def->mtime = mtime; token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: switch (GPOINTER_TO_INT (scanner->value.v_symbol)) { case PROC_DEF: token = plug_in_procedure_deserialize (scanner, gimp, plug_in_def->prog, &proc); if (token == G_TOKEN_LEFT_PAREN) gimp_plug_in_def_add_procedure (plug_in_def, proc); if (proc) g_object_unref (proc); break; case LOCALE_DEF: token = plug_in_locale_def_deserialize (scanner, plug_in_def); break; case HELP_DEF: token = plug_in_help_def_deserialize (scanner, plug_in_def); break; case HAS_INIT: token = plug_in_has_init_deserialize (scanner, plug_in_def); break; default: break; } break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: break; } } if (token == G_TOKEN_LEFT_PAREN) { token = G_TOKEN_RIGHT_PAREN; if (gimp_scanner_parse_token (scanner, token)) { *plug_in_defs = g_slist_prepend (*plug_in_defs, plug_in_def); return G_TOKEN_LEFT_PAREN; } } g_object_unref (plug_in_def); return token; }
static void time_offset_cb (VisNode * vis_node, void * offset) { vis_node->time += GPOINTER_TO_INT (offset); }
static void signal_query_created(QUERY_REC *query, gpointer automatic) { window_item_create((WI_ITEM_REC *) query, GPOINTER_TO_INT(automatic)); printformat(query->server, query->nick, MSGLEVEL_CLIENTNOTICE, IRCTXT_QUERY_STARTED, query->nick); }