自学教程：C++ GPOINTER_TO_INT函数代码示例

voidgtr_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);//.........这里部分代码省略.........

static voidmex_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 **/gbooleangimp_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 *///.........这里部分代码省略.........

/** * 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 voidwnck_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 GTokenTypeplug_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);//.........这里部分代码省略.........

/** * 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 voidcg_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. **/voidgimp_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);//.........这里部分代码省略.........

static gintdissect_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) {//.........这里部分代码省略.........

void gtkui_state_quicksave(GtkWidget *widget, gpointer userdata) {	// Wrapper function to quicksave states	nst_state_quicksave(GPOINTER_TO_INT(userdata));}

static GTokenTypeplug_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 GTokenTypeplug_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 voidadd_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;//.........这里部分代码省略.........

static gbooleangimp_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//.........这里部分代码省略.........

static voiddelete_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. **/voidgimp_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 voidwnck_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 GTokenTypeplug_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);}