static GdaColumn * gda_data_access_wrapper_describe_column (GdaDataModel *model, gint col) { GdaDataAccessWrapper *imodel; g_return_val_if_fail (GDA_IS_DATA_ACCESS_WRAPPER (model), NULL); imodel = (GdaDataAccessWrapper*) model; g_return_val_if_fail (imodel->priv, NULL); if (imodel->priv->model) { if (imodel->priv->columns) return g_slist_nth_data (imodel->priv->columns, col); else return gda_data_model_describe_column (imodel->priv->model, col); } else return NULL; }
void vik_viewport_draw_logo ( VikViewport *vvp ) { g_return_if_fail ( vvp != NULL ); guint len = g_slist_length ( vvp->logos ); gint x = vvp->width - PAD; gint y = PAD; int i; for (i = 0 ; i < len ; i++) { GdkPixbuf *logo = g_slist_nth_data ( vvp->logos, i ); gint width = gdk_pixbuf_get_width ( logo ); gint height = gdk_pixbuf_get_height ( logo ); vik_viewport_draw_pixbuf ( vvp, logo, 0, 0, x - width, y, width, height ); x = x - width - PAD; } }
gint riglist_get_index_from_id(gint id) { gint i, len; g_return_val_if_fail(riglist != NULL, 0); len = g_slist_length(riglist); for (i = 0; i < len; i++) { struct rig_caps *rig = g_slist_nth_data(riglist, i); if (rig->rig_model == id) return i; } return 0; }
static void do_ruletype_changed (struct changeRequest *changeRequest) { ruleInfoPtr ruleInfo; rulePtr rule; rule = g_object_get_data (G_OBJECT (changeRequest->paramHBox), "rule"); if (rule) { changeRequest->editor->priv->newRules = g_slist_remove (changeRequest->editor->priv->newRules, rule); rule_free (rule); } ruleInfo = g_slist_nth_data (rule_get_available_rules (), changeRequest->rule); rule = rule_new (ruleInfo->ruleId, "", TRUE); changeRequest->editor->priv->newRules = g_slist_append (changeRequest->editor->priv->newRules, rule); rule_editor_setup_widgets (changeRequest, rule); }
static void cleanup_waiting_operations() { GSList *clean_list = NULL; char *key; if (wait_table == NULL) return; g_hash_table_foreach(wait_table, cleanup_list_waiting_list, &clean_list); for (int i = 0; i < g_slist_length(clean_list); i++) { key = g_slist_nth_data(clean_list, i); g_hash_table_remove(wait_table, key); } g_slist_free(clean_list); }
/** * nm_setting_vlan_remove_priority: * @map: the type of priority map * @setting: the #NMSettingVlan * @idx: the zero-based index of the priority map to remove * * Removes the priority map at index @idx from the * #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map * properties. */ void nm_setting_vlan_remove_priority (NMSettingVlan *setting, NMVlanPriorityMap map, guint32 idx) { GSList *list = NULL, *item = NULL; g_return_if_fail (NM_IS_SETTING_VLAN (setting)); g_return_if_fail (map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP); list = get_map (setting, map); g_return_if_fail (idx < g_slist_length (list)); item = g_slist_nth_data (list, idx); priority_map_free ((PriorityMap *) item); set_map (setting, map, g_slist_delete_link (list, item)); }
static void browsing_response(struct avctp_channel *browsing, struct avctp_header *avctp, uint8_t *operands, size_t operand_count) { struct avctp_pending_req *p; struct avctp_browsing_req *req; struct avctp_queue *queue; GSList *l; queue = g_slist_nth_data(browsing->queues, 0); p = queue->p; if (p && p->transaction == avctp->transaction) { browsing->processed = g_slist_prepend(browsing->processed, p); if (p->timeout > 0) { g_source_remove(p->timeout); p->timeout = 0; } queue->p = NULL; if (queue->process_id == 0) queue->process_id = g_idle_add(process_queue, queue); } for (l = browsing->processed; l; l = l->next) { p = l->data; req = p->data; if (p->transaction != avctp->transaction) continue; if (req->func && req->func(browsing->session, operands, operand_count, req->user_data)) return; browsing->processed = g_slist_remove(browsing->processed, p); pending_destroy(p, NULL); return; } }
static void check_deadlocks() { int key1, key2; char *sk1, *sk2; if (lock_waiting_list == NULL) return; GList *trans_waiting = g_hash_table_get_keys(wait_table); for (int i = 0; i < g_list_length(trans_waiting); i++) { sk1 = g_list_nth_data(trans_waiting, i); if (sk1 == NULL) continue; for (int j = 0; j < g_list_length(trans_waiting); j++) { sk2 = g_list_nth_data(trans_waiting, j); if (sk2 == NULL) continue; key1 = atoi(sk1); key2 = atoi(sk2); if (key1 == key2) continue; if (is_locking(key1, key2) && is_locking(key2, key1)) { printf("* DEADLOCK DETECTED *\n"); // Selecionando pela operação mais velha sk1 = g_strdup_printf("%d", key1); GSList *op_list = g_hash_table_lookup(wait_table, sk1); g_free(sk1); if (g_slist_length(op_list) == 0) continue; struct operation *op = g_slist_nth_data(op_list, 0); if (op == NULL) continue; abort_transaction(op); return; } } } }
/* Get the respective driver's current samplerate. */ uint64_t srtest_get_samplerate(struct sr_dev_driver *driver) { int ret; uint64_t samplerate; struct sr_dev_inst *sdi; GVariant *gvar; sdi = g_slist_nth_data(driver->priv, 0); ret = driver->config_get(SR_CONF_SAMPLERATE, &gvar, sdi, NULL); samplerate = g_variant_get_uint64(gvar); g_variant_unref(gvar); fail_unless(ret == SR_OK, "%s: Failed to get SR_CONF_SAMPLERATE: %d.", driver->name, ret); return samplerate; }
const gchar * gdict_sidebar_current_page (GdictSidebar *sidebar) { GdictSidebarPrivate *priv; gint index; SidebarPage *page; g_return_val_if_fail (GDICT_IS_SIDEBAR (sidebar), NULL); priv = sidebar->priv; index = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook)); page = g_slist_nth_data (priv->pages, index); if (page == NULL) return NULL; return page->id; }
static void insert_box_data (GogPlot *plot) { GSList *list; GogSeries *series; GOData *data; GError *error; /* Create a series for the plot and populate it with some simple data */ list = (GSList *)gog_plot_get_series (plot); if (g_slist_length (list) == 1) series = g_slist_nth_data (list, 0); else series = gog_plot_new_series (plot); data = go_data_vector_val_new (values, 6, NULL); gog_series_set_dim (series, 0, data, &error); }
int viewer_list_item_enable_all(void) { __COMMON_FUNC_ENTER__; assertm_if(NULL == container, "NULL!!"); int count = g_slist_length(container); int i = 1; for(;i<count;i++){ Elm_Object_Item* det = NULL; det = (Elm_Object_Item*) g_slist_nth_data(container, i); assertm_if(NULL == det, "NULL!!"); elm_object_item_disabled_set(det, EINA_FALSE); } __COMMON_FUNC_EXIT__; return TRUE; }
void curlapi_http_cb(gchar *inputurl, gchar *inputparams, GSList *args, gboolean oauth) { gchar *url = g_strdup(inputurl); gchar *params = g_strdup(inputparams); struct curl_slist *oauthheader = NULL; CURL *curlapi = curl_easy_init(); GString *buffer = g_string_new(NULL); GSList *threadargs = g_slist_copy(args); CURLcode returncode; threadargs = g_slist_prepend(threadargs, buffer); curl_easy_setopt(curlapi, CURLOPT_WRITEFUNCTION, curlapi_http_write_cb); curl_easy_setopt(curlapi, CURLOPT_WRITEDATA, threadargs); oauthheader = curlapi_get_oauthheader(&url, ¶ms, oauth); curl_easy_setopt(curlapi, CURLOPT_URL, url); curl_easy_setopt(curlapi, CURLOPT_HTTPHEADER, oauthheader); if(params) curl_easy_setopt(curlapi, CURLOPT_POSTFIELDS, params); //curl_easy_setopt(curlapi, CURLOPT_VERBOSE, 1); curl_easy_setopt(curlapi, CURLOPT_FAILONERROR, 1); returncode = curl_easy_perform(curlapi); if(returncode != CURLE_OK && returncode != CURLE_WRITE_ERROR) { gchar *httperror = NULL; void (*write_cb)(GSList *args) = NULL; httperror = curlapi_http(url, params, oauth); threadargs = g_slist_remove(threadargs, buffer); write_cb = g_slist_nth_data(threadargs, 0); threadargs = g_slist_append(threadargs, g_strdup(httperror)); write_cb(g_slist_nth(threadargs, 1)); g_free(httperror); } g_free(url); g_free(params); g_string_free(buffer, TRUE); if(oauthheader) curl_slist_free_all(oauthheader); curl_easy_cleanup(curlapi); }
void media_player_set_setting(struct media_player *mp, const char *key, const char *value) { char *curval; struct pending_req *p; DBG("%s: %s", key, value); if (strcasecmp(key, "Error") == 0) { p = g_slist_nth_data(mp->pending, 0); if (p == NULL) return; g_dbus_pending_property_error(p->id, ERROR_INTERFACE ".Failed", value); goto send; } curval = g_hash_table_lookup(mp->settings, key); if (g_strcmp0(curval, value) == 0) goto done; g_hash_table_replace(mp->settings, g_strdup(key), g_strdup(value)); g_dbus_emit_property_changed(btd_get_dbus_connection(), mp->path, MEDIA_PLAYER_INTERFACE, key); done: p = find_pending(mp, key); if (p == NULL) return; if (strcasecmp(value, p->value) == 0) g_dbus_pending_property_success(p->id); else g_dbus_pending_property_error(p->id, ERROR_INTERFACE ".NotSupported", "Operation is not supported"); send: mp->pending = g_slist_remove(mp->pending, p); g_free(p); return; }
static void command_set_ban(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item, int set) { IRC_CHANNEL_REC *chanrec; char *channel, *nicks; void *free_arg; g_return_if_fail(data != NULL); if (server == NULL || !server->connected || !IS_IRC_SERVER(server)) cmd_return_error(CMDERR_NOT_CONNECTED); if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_OPTCHAN | PARAM_FLAG_GETREST, item, &channel, &nicks)) return; if (!ischannel(*channel)) cmd_param_error(CMDERR_NOT_JOINED); if (*nicks == '\0') { if (strcmp(data, "*") != 0) cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS); /* /BAN * or /UNBAN * - ban/unban everyone */ nicks = (char *) data; } chanrec = irc_channel_find(server, channel); if (chanrec == NULL) cmd_param_error(CMDERR_CHAN_NOT_FOUND); if (!chanrec->wholist) cmd_param_error(CMDERR_CHAN_NOT_SYNCED); if (set) ban_set(chanrec, nicks); else { if (is_numeric(nicks, '\0')) { /* unban with ban number */ BAN_REC *ban = g_slist_nth_data(chanrec->banlist, atoi(nicks)-1); if (ban != NULL) nicks = ban->ban; } ban_remove(chanrec, nicks); } cmd_params_free(free_arg); }
/* * Print a GSList as char strings to a file. */ void printlist(FILE *outfile, GSList *slist) { guint i, j; guint len = g_slist_length(slist); char prev, cur; char* text; gboolean comment = FALSE; for(i = 0; i < len; i++) { prev = '\0'; text = (char *)g_slist_nth_data(slist, i); for(j=0; (cur=text[j])!='\0'; j++, prev=cur) { if(comment) { if(prev == '*') { fputc('*', outfile); if(cur == '/') { fputc(')', outfile); comment = FALSE; cur = '\0'; continue; } } if(cur!='*') fputc(cur, outfile); } else { if(prev == '/') { if(cur == '*') { fputs("(*", outfile); comment = TRUE; prev = '\0'; continue; } else fputc('/', outfile); } if(cur!='/') fputc(cur, outfile); } } fputc('\n', outfile); } }
static int is_transaction_waiting(struct operation *op) { char *strtrans = g_strdup_printf("%d", op->transaction); struct operation *tmp_op; if (op == NULL) return 0; GSList *op_list = g_hash_table_lookup(wait_table, strtrans); if (op_list != NULL) { for (int i = 0; i < g_slist_length(op_list); i++) { tmp_op = g_slist_nth_data(op_list, i); if (((tmp_op->cmd == CMD_LOCK_S) || (tmp_op->cmd == CMD_LOCK_X))) return 1; } } return 0; }
void game_update_with_mod_proportional_imitate(game_t *game) { int n = game->graph->n; int i; for(i = 0; i < n; ++i) { int n_i = graph_number_of_neighbours_of(game->graph, i); mpq_t *p; p = (mpq_t *)g_malloc(sizeof(mpq_t) * n_i); int j; for(j = 0; j < n_i; ++j) { mpq_init(p[j]); } gboolean zero_sum = game_compute_p_ij(game, i, p); if(zero_sum) { game->next_config[i] = game->current_config[i]; } else { j = random_integer_with_probability(p, n_i); int k = GPOINTER_TO_INT(g_slist_nth_data(game->graph->edges[i], j)); game->next_config[i] = game->current_config[k]; } for(j = 0; j < n_i; ++j) { mpq_clear(p[j]); } g_free(p); } for(i = 0; i < n; ++i) { game->current_config[i] = game->next_config[i]; } }
void cal_replace_note_color (gchar *old_color, gchar *new_color, GUI *appGUI) { GSList *lnode; struct note *a; gint i; g_return_if_fail (appGUI->cal->notes_list != NULL); for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) { a = g_slist_nth_data (appGUI->cal->notes_list, i); if (a->color != NULL) if (!strncmp (a->color, old_color, MAXCOLORNAME)) { g_free (a->color); a->color = g_strdup (new_color); } } }
static DBusMessage *default_connection(DBusConnection *conn, DBusMessage *msg, void *data) { const char *path; if (connection_paths == NULL || g_slist_length (connection_paths) == 0) return does_not_exist(msg); path = g_slist_nth_data (connection_paths, default_index); if (path == NULL) { path = last_connection_used(conn); connection_store(path, TRUE); } return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID); }
int ssds_send_repo(ParamOptsCl* params, char *arch, char *release, int socket, int action) { ssds_log(logDEBUG, "Client repo info JSON creating.\n"); SsdsJsonCreate *json_gen = ssds_js_cr_init(action); SsdsLocalRepoInfo* local_repo = ssds_repo_parse_init(); ssds_log(logDEBUG, "Local repo info initialized.\n"); // parsing local repo if(!ssds_parse_default_repo(local_repo)) { return REPO_ERROR; } ssds_log(logDEBUG, "Local repo is parsed.\n"); ssds_get_repo_urls(local_repo, json_gen, arch, release); ssds_log(logDEBUG, "Getting repo urls.\n"); ssds_log(logDEBUG, "Loop thrue required packages.\n"); for(int i = 0; i < params->pkg_count; i++) { char* pkg = (char*)g_slist_nth_data(params->pkgs, i); ssds_js_cr_add_package(json_gen, pkg); ssds_log(logDEBUG, "Added %s package as %d in order.\n", pkg, i+1); } ssds_log(logDEBUG, "Loop is done.\n"); char* repo_output; ssds_log(logDEBUG, "Generating output message with repo info to server.\n"); repo_output = ssds_js_cr_to_string(json_gen); ssds_log(logDEBUG, "Message generated.\n\n%s\n\n", repo_output); /***********************************************************/ /* Sending repo info to server */ /***********************************************************/ ssds_log(logMESSAGE, "Sending message with repo info to server.\n"); secure_write(socket, repo_output, strlen(repo_output)); ssds_log(logDEBUG, "Message sent.\n"); return OK; }
static HRESULT STDMETHODCALLTYPE ifiledialogevents_OnTypeChange (IFileDialogEvents * self, IFileDialog *pfd) { FileDialogEvents *events = (FileDialogEvents *) self; UINT fileType; HRESULT hr = IFileDialog_GetFileTypeIndex (pfd, &fileType); if (FAILED (hr)) { g_warning_hr ("Can't get current file type", hr); return S_OK; } fileType--; // fileTypeIndex starts at 1 GSList *filters = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (events->data->self)); events->data->self->current_filter = g_slist_nth_data (filters, fileType); g_slist_free (filters); g_object_notify (G_OBJECT (events->data->self), "filter"); return S_OK; }
void wxGtkFileChooser::SetFilterIndex( int filterIndex ) { gpointer filter; GtkFileChooser *chooser = m_widget; GSList *filters = gtk_file_chooser_list_filters( chooser ); filter = g_slist_nth_data( filters, filterIndex ); if ( filter != NULL ) { gtk_file_chooser_set_filter( chooser, GTK_FILE_FILTER( filter ) ); } else { wxFAIL_MSG( wxT( "wxGtkFileChooser::SetFilterIndex - bad filter index" ) ); } g_slist_free( filters ); }
gint gtk_clist_set_text(GtkCList *clist, gint row, gint col, gchar *text) { GtkCListRow *list_row; if (row < 0 || row >= clist->rows || col < 0 || col >= clist->cols) return -1; list_row = (GtkCListRow *)g_slist_nth_data(clist->rowdata, row); g_free(list_row->text[col]); list_row->text[col] = g_strdup(text); if (GTK_WIDGET_REALIZED(GTK_WIDGET(clist))) { HWND hWnd = GTK_WIDGET(clist)->hWnd; InvalidateRect(hWnd, NULL, FALSE); UpdateWindow(hWnd); } return row; }
void source_ctree_delete_master (GtkWidget *ctree, struct master *m) { GtkCTreeNode *node; struct master *group; node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m); if (!node) return; gtk_ctree_remove_node (GTK_CTREE (ctree), node); /* Remove empty master group from the tree */ if (m->type != UNKNOWN_SERVER) { group = (struct master *) g_slist_nth_data (master_groups, m->type); if (group && (group->masters == NULL || (g_slist_length (group->masters) == 1 && group->masters->data == m))) { source_ctree_remove_master_group (ctree, group); } } }
static void cell_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer user_data) { GtkBuilder *builder = GTK_BUILDER (user_data); GtkWidget *widget, *dialog; GtkListStore *store; GtkTreePath *path; GtkTreeIter iter; guint32 column; GtkTreeViewColumn *next_col; GtkCellRenderer *next_cell; /* Free auxiliary stuff */ g_free (last_edited); last_edited = NULL; g_free (last_path); last_path = NULL; last_column = -1; widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip6_routes")); store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (widget))); path = gtk_tree_path_new_from_string (path_string); column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column")); gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path); gtk_list_store_set (store, &iter, column, new_text, -1); /* Move focus to the next column */ column = (column >= COL_LAST) ? 0 : column + 1; next_col = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), column); dialog = GTK_WIDGET (gtk_builder_get_object (builder, "ip6_routes_dialog")); next_cell = g_slist_nth_data (g_object_get_data (G_OBJECT (dialog), "renderers"), column); gtk_tree_view_set_cursor_on_cell (GTK_TREE_VIEW (widget), path, next_col, next_cell, TRUE); gtk_tree_path_free (path); validate (dialog); }
/* Send an email. */ void send_email (gchar *to, gchar *subject, gchar *body, GSList *attachment_list) { #ifdef _WIN32 windows_send_email (to, subject, body, attachment_list); #else guint attach_lenght = g_slist_length (attachment_list); guint i = 0; gchar* mailer = "xdg-email"; gchar* subject_param = "--subject"; gchar* body_param = "--body"; gchar* attach_param = "--attach"; gchar* args = g_strdup_printf("%s %s %s %s '%s'", mailer, subject_param, subject, body_param, body); for (i=0; i<attach_lenght; i++) { gchar* attachment = (gchar*) g_slist_nth_data (attachment_list, i); gchar* attachment_str = g_strdup_printf("%s '%s'", attach_param, attachment); gchar* new_args = g_strdup_printf("%s %s", args, attachment_str); g_free(args); args = new_args; g_free(attachment_str); } gchar* new_args = g_strdup_printf("%s %s&", args, to); g_free(args); if (system (new_args)<0) { g_warning("Problem running command: %s", new_args); } g_free(new_args); #endif }
gboolean check_note (guint day, guint month, guint year, GUI *appGUI) { GSList *lnode; struct note *a; gint i; if (appGUI->cal->notes_list != NULL) { for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) { a = g_slist_nth_data (appGUI->cal->notes_list, i); if (a->day == day && a->month == month && a->year == year) return TRUE; } } return FALSE; }
gchar * cal_get_note (GDate *date, GUI *appGUI) { GSList *lnode; struct note *a; gint i; if (appGUI->cal->notes_list != NULL) { for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) { a = g_slist_nth_data (appGUI->cal->notes_list, i); if (a->date == g_date_get_julian (date)) return a->note; } } return NULL; }
void cal_free_notes_list (GUI *appGUI) { GSList *node; struct note *a; gint i = 0; if (appGUI->cal->notes_list != NULL) { for (node = appGUI->cal->notes_list; node != NULL; node = node->next, i++) { a = g_slist_nth_data (appGUI->cal->notes_list, i); if (a->color != NULL) g_free (a->color); if (a->note != NULL) g_free (a->note); } g_slist_free (appGUI->cal->notes_list); appGUI->cal->notes_list = NULL; } }