G_MODULE_EXPORT void update_userlist_callback(GtkWidget *wiggy, gpointer data) { GtkWidget *w; GtkListStore *lstore = NULL; int totalusers; int i; GtkTreeIter curr; char str[1024]; free_cfg(&cfg); if(!load_cfg(&cfg, NULL, TRUE, str)) { display_message("Load Error","Cannot load configuration data","gtk-dialog-error"); return; } w=GTK_WIDGET(gtk_builder_get_object(builder, "lUserList")); lstore=GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(w))); gtk_list_store_clear(lstore); totalusers=lastuser(&cfg); for(i=1; i<=totalusers; i++) { gtk_list_store_insert(lstore, &curr, i-1); update_userlist_item(lstore, &curr, i); } }
static void imageheader_refresh( Imageheader *imageheader ) { gtk_list_store_clear( imageheader->store ); if( imageheader->iimage && imageheader->iimage->value.ii ) { Imageinfo *ii = imageheader->iimage->value.ii; IMAGE *im = imageinfo_get( FALSE, ii ); im_header_map( im, (im_header_map_fn) imageheader_add_item, imageheader ); gtk_text_buffer_set_text( gtk_text_view_get_buffer( GTK_TEXT_VIEW( imageheader->history ) ), im_history_get( im ), -1 ); } else { gtk_editable_delete_text( GTK_EDITABLE( imageheader->history ), 0, -1 ); } }
static void debug_logger_clear_clicked(GtkWidget *widget, DebugLogger *logger) { GtkTreeView *view; GtkListStore *store; gint current_page; g_return_if_fail(IS_DEBUG_LOGGER(logger)); if(gtk_notebook_get_n_pages(logger->priv->notebook) == 0) return; current_page = gtk_notebook_get_current_page(logger->priv->notebook); view = GTK_TREE_VIEW(gtk_bin_get_child( GTK_BIN(gtk_notebook_get_nth_page( GTK_NOTEBOOK(logger->priv->notebook), current_page)))); store = GTK_LIST_STORE(gtk_tree_view_get_model(view)); gtk_list_store_clear(store); }
static void pref_to_color_list (void) { gint i; EATreePos ep; if (!get_color_store (&ep)) return; /* clear list */ gtk_list_store_clear (ep.gs); for (i = 0; pref.colors[i]; ++i) { GdkColor gdk_color; gchar **colors_protocols = NULL; gchar *protocol = NULL; GtkTreeIter it; colors_protocols = g_strsplit (pref.colors[i], ";", 0); /* converting color */ gdk_color_parse (colors_protocols[0], &gdk_color); /* converting proto name */ if (!colors_protocols[1]) protocol = ""; else protocol = colors_protocols[1]; /* adds a new row */ gtk_list_store_append (ep.gs, &it); gtk_list_store_set (ep.gs, &it, 0, COLSPACES, 1, &gdk_color, 2, protocol, -1); g_strfreev(colors_protocols); } }
void IRC_Client_GUI_MessageHandler::clearMembers () { RPG_TRACE (ACE_TEXT ("IRC_Client_GUI_MessageHandler::clearMembers")); // sanity check(s) ACE_ASSERT (CBData_.GTKState); ACE_Guard<ACE_Thread_Mutex> aGuard (CBData_.GTKState->lock); Common_UI_GTKBuildersIterator_t iterator = CBData_.GTKState->builders.find (builderLabel_); // sanity check(s) ACE_ASSERT (iterator != CBData_.GTKState->builders.end ()); // retrieve channel liststore handle GtkListStore* list_store_p = GTK_LIST_STORE (gtk_builder_get_object ((*iterator).second.second, ACE_TEXT_ALWAYS_CHAR ("channel_liststore"))); ACE_ASSERT (list_store_p); // clear liststore gtk_list_store_clear (list_store_p); }
static void gnc_simple_combo_generate_liststore (ListStoreData *lsd) { GList *items; GtkListStore *liststore; if (!(lsd->get_list)) return; if (!(lsd->get_name)) return; /* Get the list of items */ items = (lsd->get_list)(lsd->book); /* Reset the combobox' liststore */ liststore = GTK_LIST_STORE (gtk_combo_box_get_model (lsd->cbox)); gtk_list_store_clear (liststore); if (lsd->none_ok || !items) gnc_simple_combo_add_item (liststore, _("None"), NULL); for ( ; items; items = items->next) gnc_simple_combo_add_item (liststore, (lsd->get_name)(items->data), items->data); }
static void change_network (EmpathyIrcNetworkDialog *dialog, EmpathyIrcNetwork *network) { GtkListStore *store; if (dialog->network == network) /* No need to change */ return; if (dialog->network != NULL) { g_object_unref (dialog->network); } dialog->network = network; g_object_ref (network); store = GTK_LIST_STORE (gtk_tree_view_get_model ( GTK_TREE_VIEW (dialog->treeview_servers))); gtk_list_store_clear (store); irc_network_dialog_setup (dialog); }
void clear_search_results(SearchTools* self) { FileResultNode* rs; ResultNode* p; gtk_list_store_clear(self->result_store); while( self->result_list ) { rs = self->result_list; self->result_list = rs->next; while( rs->result_node_list ) { p = rs->result_node_list; rs->result_node_list = p->next; g_free(p->preview); g_free(p); } g_free(rs->owner_filename); g_free(rs); } self->result_list = 0; self->result_list_last = 0; }
static void ignore_clear_cb (GtkDialog *dialog, gint response) { GtkListStore *store = GTK_LIST_STORE (get_store ()); GtkTreeIter iter; gtk_widget_destroy (GTK_WIDGET (dialog)); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter) && response == GTK_RESPONSE_OK) { /* remove from ignore_list */ do { char* mask = nullptr; gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, MASK_COLUMN, &mask, -1); glib_string mask_ptr(mask); ignore_del (mask); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter)); /* remove from GUI */ gtk_list_store_clear (store); } }
// Update the info table and model preview based on the current selection void ModelSelector::updateSelected () { // Prepare to populate the info table gtk_list_store_clear(_infoStore); GtkTreeIter iter; // Get the model name, if this is blank we are looking at a directory, // so leave the table empty std::string mName = getSelectedString(FULLNAME_COLUMN); if (mName.empty()) return; // Get the skin if set std::string skinName = getSelectedString(SKIN_COLUMN); // Pass the model and skin to the preview widget _modelPreview.setModel(mName); _modelPreview.setSkin(skinName); // Update the text in the info table gtk_list_store_append(_infoStore, &iter); gtk_list_store_set(_infoStore, &iter, 0, _("Model name"), 1, mName.c_str(), -1); gtk_list_store_append(_infoStore, &iter); gtk_list_store_set(_infoStore, &iter, 0, _("Skin name"), 1, skinName.c_str(), -1); gtk_list_store_append(_infoStore, &iter); gtk_list_store_set(_infoStore, &iter, 0, _("Material surfaces"), 1, _modelPreview.getModel()->getSurfaceCountStr().c_str(), -1); gtk_list_store_append(_infoStore, &iter); gtk_list_store_set(_infoStore, &iter, 0, _("Total vertices"), 1, _modelPreview.getModel()->getVertexCountStr().c_str(), -1); gtk_list_store_append(_infoStore, &iter); gtk_list_store_set(_infoStore, &iter, 0, _("Total polys"), 1, _modelPreview.getModel()->getPolyCountStr().c_str(), -1); }
/** * update the list of accounts in a combo_box filled * by gsb_account_create_combo_list * * \param combo_box * \param include_closed * * \return FALSE * */ gboolean gsb_account_update_combo_list ( GtkWidget *combo_box, gboolean include_closed ) { GSList *list_tmp; GtkListStore *store; if (!combo_box) return FALSE; store = GTK_LIST_STORE (gtk_combo_box_get_model ( GTK_COMBO_BOX (combo_box))); gtk_list_store_clear (store); list_tmp = gsb_data_account_get_list_accounts (); while ( list_tmp ) { gint account_number; GtkTreeIter iter; account_number = gsb_data_account_get_no_account ( list_tmp -> data ); if ( account_number >= 0 && ( !gsb_data_account_get_closed_account (account_number) || include_closed ) ) { gtk_list_store_append ( GTK_LIST_STORE (store), &iter ); gtk_list_store_set ( store, &iter, 0, gsb_data_account_get_name (account_number), 1, account_number, -1 ); } list_tmp = list_tmp -> next; } return FALSE; }
/* * create the array for the widget. * erase any previously alloc'd array */ static void gtkui_create_plug_array(void) { GtkTreeIter iter; int res; static int blocked = 0; DEBUG_MSG("gtk_create_plug_array"); if(ls_plugins) gtk_list_store_clear(GTK_LIST_STORE (ls_plugins)); else ls_plugins = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); /* go thru the list of plugins */ res = plugin_list_walk(PLP_MIN, PLP_MAX, >kui_add_plugin); if (res == -ENOTFOUND) { blocked = g_signal_handlers_block_by_func (G_OBJECT (treeview), G_CALLBACK (gtkui_select_plugin), NULL); gtk_list_store_append (ls_plugins, &iter); gtk_list_store_set (ls_plugins, &iter, 0, " ", 1, "No Plugins Loaded", -1); } else if(blocked > 0) { g_signal_handlers_unblock_by_func (G_OBJECT (treeview), G_CALLBACK (gtkui_select_plugin), NULL); blocked = 0; } }
static void show_relations(GtkWidget *relation_list, ftenum_t ftype) { GtkTreeIter iter; /* * Clear out the currently displayed list of relations. */ gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(relation_list)))); /* * Add the supported relations. */ add_relation_list(relation_list, "is present", TRUE); add_relation_list(relation_list, "==", ftype_can_eq(ftype) || (ftype_can_slice(ftype) && ftype_can_eq(FT_BYTES))); add_relation_list(relation_list, "!=", ftype_can_ne(ftype) || (ftype_can_slice(ftype) && ftype_can_ne(FT_BYTES))); add_relation_list(relation_list, ">", ftype_can_gt(ftype) || (ftype_can_slice(ftype) && ftype_can_gt(FT_BYTES))); add_relation_list(relation_list, "<", ftype_can_lt(ftype) || (ftype_can_slice(ftype) && ftype_can_lt(FT_BYTES))); add_relation_list(relation_list, ">=", ftype_can_ge(ftype) || (ftype_can_slice(ftype) && ftype_can_ge(FT_BYTES))); add_relation_list(relation_list, "<=", ftype_can_le(ftype) || (ftype_can_slice(ftype) && ftype_can_le(FT_BYTES))); add_relation_list(relation_list, "contains", ftype_can_contains(ftype) || (ftype_can_slice(ftype) && ftype_can_contains(FT_BYTES))); #if defined(HAVE_LIBPCRE) || GLIB_CHECK_VERSION(2,14,0) add_relation_list(relation_list, "matches", ftype_can_matches(ftype) || (ftype_can_slice(ftype) && ftype_can_matches(FT_BYTES))); #endif gtk_tree_model_get_iter_first(gtk_tree_view_get_model(GTK_TREE_VIEW(relation_list)), &iter); gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(relation_list)), &iter); }
static void rejilla_search_entry_set_history (RejillaSearchEntry *entry, const gchar * const *history) { int i; GtkTreeIter row; GtkListStore *store; store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (entry->priv->combo))); gtk_list_store_clear (GTK_LIST_STORE (store)); if (history) { for (i = 0; history [i] && i < REJILLA_SEARCH_ENTRY_MAX_HISTORY_ITEMS; i ++) { gtk_list_store_append (store, &row); gtk_list_store_set (store, &row, REJILLA_SEARCH_ENTRY_DISPLAY_COL, history [i], REJILLA_SEARCH_ENTRY_BACKGRD_COL, NULL, -1); } } /* separator */ gtk_list_store_append (store, &row); gtk_list_store_set (store, &row, REJILLA_SEARCH_ENTRY_DISPLAY_COL, NULL, REJILLA_SEARCH_ENTRY_BACKGRD_COL, NULL, -1); /* all files entry */ gtk_list_store_append (store, &row); gtk_list_store_set (store, &row, REJILLA_SEARCH_ENTRY_DISPLAY_COL, _("All files"), REJILLA_SEARCH_ENTRY_BACKGRD_COL, NULL, //REJILLA_SEARCH_ENTRY_BACKGRD_COL, "grey90", -1); }
static void source_list_changed_cb (ESourceList *source_list, ESourceComboBox *source_combo_box) { ESourceComboBoxPrivate *priv; GtkComboBox *combo_box; GtkTreeModel *model; GtkListStore *store; GtkTreeIter iter; GtkTreePath *path; GSList *groups; GSList *sources, *s; const gchar *name; const gchar *uid; gchar *indented_name; gboolean visible = FALSE; gboolean iter_valid; priv = source_combo_box->priv; g_hash_table_remove_all (priv->uid_index); combo_box = GTK_COMBO_BOX (source_combo_box); gtk_combo_box_set_active (combo_box, -1); model = gtk_combo_box_get_model (combo_box); store = GTK_LIST_STORE (model); gtk_list_store_clear (store); for (groups = e_source_list_peek_groups (source_list); groups != NULL; groups = groups->next) { /* Only show source groups that have sources. */ if (e_source_group_peek_sources (groups->data) == NULL) continue; name = e_source_group_peek_name (groups->data); gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, COLUMN_COLOR, NULL, COLUMN_NAME, name, COLUMN_SENSITIVE, FALSE, COLUMN_SOURCE, groups->data, -1); sources = get_sorted_sources (e_source_group_peek_sources (groups->data)); for (s = sources; s != NULL; s = s->next) { const gchar *color_spec; GdkColor color; name = e_source_peek_name (s->data); indented_name = g_strconcat (" ", name, NULL); color_spec = e_source_peek_color_spec (s->data); if (color_spec != NULL) { gdk_color_parse (color_spec, &color); visible = TRUE; } gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, COLUMN_COLOR, color_spec ? &color : NULL, COLUMN_NAME, indented_name, COLUMN_SENSITIVE, TRUE, COLUMN_SOURCE, s->data, -1); uid = e_source_peek_uid (s->data); path = gtk_tree_model_get_path (model, &iter); g_hash_table_insert ( priv->uid_index, g_strdup (uid), gtk_tree_row_reference_new (model, path)); gtk_tree_path_free (path); g_free (indented_name); } g_slist_free (sources); } /* Set the visible column based on whether we've seen a color. */ iter_valid = gtk_tree_model_get_iter_first (model, &iter); while (iter_valid) { gtk_list_store_set ( store, &iter, COLUMN_VISIBLE, visible, -1); iter_valid = gtk_tree_model_iter_next (model, &iter); } }
void SetTableItemAll(int noAct, int noPat) { if (IsActReady() == false) return; GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table"); GtkListStore *store = (GtkListStore *)gtk_tree_view_get_model(table); char buf[20]; int max = actor->GetNumSprites(noAct, noPat); if (actor->matchRefHead && actor->enableRefHead) max++; int numS = gtk_tree_selection_count_selected_rows(gtk_tree_view_get_selection(table)); int *selArray; if (!autoPlay) { selArray = (int *)malloc(sizeof(int)*max); GetSelectedTableItem(selArray); } gtk_list_store_clear(store); int i; for (i=0; i< actor->GetNumSprites(noAct, noPat); i++) { // colheader = {"SprNo", "SpType", "Xoffs", "Yoffs", "Mir", "AABBGGRR", "Xmag", "Ymag", "Rot"}; //spr no SNPRINTF(buf, sizeof(buf), "%d", actor->GetSprNoValue(noAct, noPat, i)); SetTableItem(buf, i, 0); //sp type SNPRINTF(buf, sizeof(buf), "%d", actor->GetSpTypeValue(noAct, noPat, i)); SetTableItem(buf, i, 1); int xo, yo; actor->GetOffsPoint(&xo, &yo, noAct, noPat, i); // xoffs SNPRINTF(buf, sizeof(buf), "%d", xo); SetTableItem(buf, i, 2); // yoffs SNPRINTF(buf, sizeof(buf), "%d", yo); SetTableItem(buf, i, 3); // mirror SNPRINTF(buf, sizeof(buf), "%d", actor->GetMirrorValue(noAct, noPat, i)); SetTableItem(buf, i, 4); // saturation SNPRINTF(buf, sizeof(buf), "%08X", actor->GetABGRValue(noAct, noPat, i)); SetTableItem(buf, i, 5); // xmag SNPRINTF(buf, sizeof(buf), "%f", actor->GetXMagValue(noAct, noPat, i)); SetTableItem(buf, i, 6); // ymag SNPRINTF(buf, sizeof(buf), "%f", actor->GetYMagValue(noAct, noPat, i)); SetTableItem(buf, i, 7); // rot SNPRINTF(buf, sizeof(buf), "%d", actor->GetRotValue(noAct, noPat, i)); SetTableItem(buf, i, 8); } if (actor->matchRefHead && actor->enableRefHead) { SetTableItem("EXT(ref head)", i, 0); int extX, extY; actor->GetExtOffsPoint(&extX, &extY, actor->curAct, actor->curPat); SNPRINTF(buf, sizeof(buf), "%d", extX); SetTableItem(buf, i, 2); SNPRINTF(buf, sizeof(buf), "%d", extY); SetTableItem(buf, i, 3); } if (!autoPlay) { GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; model = gtk_tree_view_get_model(GTK_TREE_VIEW(table)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(table)); gtk_tree_model_get_iter_first(model, &iter); int j=0; if (numS) { for (int i=0; i<max; i++, gtk_tree_model_iter_next(model, &iter)) { if (i == *(selArray+j)) { gtk_tree_selection_select_iter(selection, &iter); j++; } } } free(selArray); } }
static void pevent_dialog_unselect (void) { gtk_entry_set_text (GTK_ENTRY (pevent_dialog_entry), ""); gtk_list_store_clear ((GtkListStore *)gtk_tree_view_get_model (GTK_TREE_VIEW (pevent_dialog_hlist))); }
void AP_UnixDialog_Spell::_updateWindow (void) { GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_txWrong)); GtkTextIter iter2; // Empty buffer gtk_text_buffer_set_text(buffer, "", -1); const UT_UCSChar *p; UT_sint32 iLength; // insert start of sentence p = m_pWordIterator->getPreWord(iLength); if (0 < iLength) { gchar * preword = (gchar*) _convertToMB(p, iLength); gtk_text_buffer_set_text(buffer, preword, -1); FREEP(preword); } // insert misspelled word (in highlight color) p = m_pWordIterator->getCurrentWord(iLength); gchar * word = (gchar*) _convertToMB(p, iLength); GtkTextTag * txt_tag = gtk_text_buffer_create_tag(buffer, NULL, "foreground-gdk", &m_highlight, NULL); gtk_text_buffer_get_end_iter(buffer, &iter2); gtk_text_buffer_insert_with_tags(buffer, &iter2, word, -1, txt_tag, NULL); // word is freed at the end of the method... // insert end of sentence p = m_pWordIterator->getPostWord(iLength); if (0 < iLength) { gchar * postword = (gchar*) _convertToMB(p, iLength); gtk_text_buffer_get_end_iter(buffer, &iter2); gtk_text_buffer_insert(buffer, &iter2, postword, -1); FREEP(postword); } else { // Insert space to make gtk_text_buffer understand that it // really should highlight the selected word. This is a // workaround for bug 5459. It really should be fixed in GTK. gtk_text_buffer_get_end_iter(buffer, &iter2); gtk_text_buffer_insert(buffer, &iter2, " ", -1); } // TODO: set scroll position so misspelled word is centered GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvSuggestions)); // Detach model for faster updates g_object_ref (G_OBJECT (model)); gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), NULL); gtk_list_store_clear (GTK_LIST_STORE (model)); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions)); UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::_updateWindow() itemcount=%d\n", m_Suggestions->getItemCount ())); if (m_Suggestions->getItemCount () == 0) { GtkTreeIter iter; gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE); const XAP_StringSet * pSS = m_pApp->getStringSet(); UT_UTF8String s; pSS->getValueUTF8(AP_STRING_ID_DLG_Spell_NoSuggestions,s); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_SUGGESTION, s.utf8_str (), COLUMN_NUMBER, -1, -1); g_signal_handler_block(G_OBJECT(m_eChange), m_replaceHandlerID); gtk_entry_set_text(GTK_ENTRY(m_eChange), word); g_signal_handler_unblock(G_OBJECT(m_eChange), m_replaceHandlerID); } else { GtkTreeIter iter; gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); gchar * suggest = NULL; for (UT_sint32 i = 0; i < m_Suggestions->getItemCount(); i++) { suggest = (gchar*) _convertToMB((UT_UCSChar*)m_Suggestions->getNthItem(i)); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_SUGGESTION, suggest, COLUMN_NUMBER, i, -1); } // put the first suggestion in the entry suggest = (gchar*) _convertToMB((UT_UCSChar*)m_Suggestions->getNthItem(0)); g_signal_handler_block(G_OBJECT(m_eChange), m_replaceHandlerID); gtk_entry_set_text(GTK_ENTRY(m_eChange), suggest); g_signal_handler_unblock(G_OBJECT(m_eChange), m_replaceHandlerID); } gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), model); g_object_unref (G_OBJECT (model)); // select first if (m_Suggestions->getItemCount () > 0) { GtkTreePath *path = gtk_tree_path_new_first (); gtk_tree_selection_select_path (selection, path); gtk_tree_path_free (path); } FREEP (word); }
void generate_username_choices (const gchar *name, GtkListStore *store) { gboolean in_use, same_as_initial; char *lc_name, *ascii_name, *stripped_name; char *default_username; char **words1; char **words2 = NULL; char **w1, **w2; char *c; char *unicode_fallback = "?"; GString *first_word, *last_word; GString *item0, *item1, *item2, *item3, *item4; int len; int nwords1, nwords2, i; GHashTable *items = NULL; GtkTreeIter iter; gtk_list_store_clear (store); ascii_name = g_convert_with_fallback (name, -1, "ASCII//TRANSLIT", "UTF-8", unicode_fallback, NULL, NULL, NULL); lc_name = g_ascii_strdown (ascii_name, -1); /* Remove all non ASCII alphanumeric chars from the name, * apart from the few allowed symbols. * * We do remove '.', even though it is usually allowed, * since it often comes in via an abbreviated middle name, * and the dot looks just wrong in the proposals then. */ stripped_name = g_strnfill (strlen (lc_name) + 1, '\0'); i = 0; for (c = lc_name; *c; c++) { if (!(g_ascii_isdigit (*c) || g_ascii_islower (*c) || *c == ' ' || *c == '-' || *c == '_' || /* used to track invalid words, removed below */ *c == '?') ) continue; stripped_name[i] = *c; i++; } if (strlen (stripped_name) == 0) { g_free (ascii_name); g_free (lc_name); g_free (stripped_name); goto bailout; } /* we split name on spaces, and then on dashes, so that we can treat * words linked with dashes the same way, i.e. both fully shown, or * both abbreviated */ words1 = g_strsplit_set (stripped_name, " ", -1); len = g_strv_length (words1); item0 = g_string_sized_new (strlen (stripped_name)); g_free (ascii_name); g_free (lc_name); g_free (stripped_name); /* Concatenate the whole first word with the first letter of each * word (item1), and the last word with the first letter of each * word (item2). item3 and item4 are symmetrical respectively to * item1 and item2. * * Constant 5 is the max reasonable number of words we may get when * splitting on dashes, since we can't guess it at this point, * and reallocating would be too bad. */ item1 = g_string_sized_new (strlen (words1[0]) + len - 1 + 5); item3 = g_string_sized_new (strlen (words1[0]) + len - 1 + 5); item2 = g_string_sized_new (strlen (words1[len - 1]) + len - 1 + 5); item4 = g_string_sized_new (strlen (words1[len - 1]) + len - 1 + 5); /* again, guess at the max size of names */ first_word = g_string_sized_new (20); last_word = g_string_sized_new (20); nwords1 = 0; nwords2 = 0; for (w1 = words1; *w1; w1++) { if (strlen (*w1) == 0) continue; /* skip words with string '?', most likely resulting * from failed transliteration to ASCII */ if (strstr (*w1, unicode_fallback) != NULL) continue; nwords1++; /* count real words, excluding empty string */ item0 = g_string_append (item0, *w1); words2 = g_strsplit_set (*w1, "-", -1); /* reset last word if a new non-empty word has been found */ if (strlen (*words2) > 0) last_word = g_string_set_size (last_word, 0); for (w2 = words2; *w2; w2++) { if (strlen (*w2) == 0) continue; nwords2++; /* part of the first "toplevel" real word */ if (nwords1 == 1) { item1 = g_string_append (item1, *w2); first_word = g_string_append (first_word, *w2); } else { item1 = g_string_append_unichar (item1, g_utf8_get_char (*w2)); item3 = g_string_append_unichar (item3, g_utf8_get_char (*w2)); } /* not part of the last "toplevel" word */ if (w1 != words1 + len - 1) { item2 = g_string_append_unichar (item2, g_utf8_get_char (*w2)); item4 = g_string_append_unichar (item4, g_utf8_get_char (*w2)); } /* always save current word so that we have it if last one reveals empty */ last_word = g_string_append (last_word, *w2); } g_strfreev (words2); } g_string_truncate (first_word, MAXNAMELEN); g_string_truncate (last_word, MAXNAMELEN); item2 = g_string_append (item2, last_word->str); item3 = g_string_append (item3, first_word->str); item4 = g_string_prepend (item4, last_word->str); g_string_truncate (item0, MAXNAMELEN); g_string_truncate (item1, MAXNAMELEN); g_string_truncate (item2, MAXNAMELEN); g_string_truncate (item3, MAXNAMELEN); g_string_truncate (item4, MAXNAMELEN); items = g_hash_table_new (g_str_hash, g_str_equal); /* add the first word */ in_use = is_username_used (first_word->str); if (*first_word->str && !in_use && !g_ascii_isdigit (first_word->str[0]) && !g_hash_table_lookup (items, first_word->str)) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, first_word->str, -1); g_hash_table_insert (items, first_word->str, first_word->str); } /* add the last word */ in_use = is_username_used (last_word->str); if (*last_word->str && !in_use && !g_ascii_isdigit (last_word->str[0]) && !g_hash_table_lookup (items, last_word->str)) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, last_word->str, -1); g_hash_table_insert (items, last_word->str, last_word->str); } /* if there's only one word, would be the same as item1 */ if (nwords2 > 1) { /* add other items */ in_use = is_username_used (item0->str); if (*item0->str && !in_use && !g_ascii_isdigit (item0->str[0])) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, item0->str, -1); g_hash_table_insert (items, item0->str, item0->str); } in_use = is_username_used (item1->str); same_as_initial = (g_strcmp0 (item0->str, item1->str) == 0); if (*item1->str && !same_as_initial && nwords2 > 0 && !in_use && !g_ascii_isdigit (item1->str[0])) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, item1->str, -1); g_hash_table_insert (items, item1->str, item1->str); } in_use = is_username_used (item2->str); if (*item2->str && !in_use && !g_ascii_isdigit (item2->str[0]) && !g_hash_table_lookup (items, item2->str)) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, item2->str, -1); g_hash_table_insert (items, item2->str, item2->str); } in_use = is_username_used (item3->str); if (*item3->str && !in_use && !g_ascii_isdigit (item3->str[0]) && !g_hash_table_lookup (items, item3->str)) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, item3->str, -1); g_hash_table_insert (items, item3->str, item3->str); } in_use = is_username_used (item4->str); if (*item4->str && !in_use && !g_ascii_isdigit (item4->str[0]) && !g_hash_table_lookup (items, item4->str)) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, item4->str, -1); g_hash_table_insert (items, item4->str, item4->str); } } g_strfreev (words1); g_string_free (first_word, TRUE); g_string_free (last_word, TRUE); g_string_free (item0, TRUE); g_string_free (item1, TRUE); g_string_free (item2, TRUE); g_string_free (item3, TRUE); g_string_free (item4, TRUE); bailout: if (items == NULL || g_hash_table_size (items) == 0) { gtk_list_store_append (store, &iter); default_username = g_strdup (DEFAULT_USERNAME); i = 0; while (is_username_used (default_username)) { g_free (default_username); default_username = g_strdup_printf (DEFAULT_USERNAME "%d", ++i); } gtk_list_store_set (store, &iter, 0, default_username, -1); g_free (default_username); } if (items != NULL) { g_hash_table_destroy (items); } }
/* check for udev events for v4l2 devices*/ gboolean check_v4l2_udev_events(gpointer data) { struct ALL_DATA * all_data = (struct ALL_DATA *) data; struct vdIn *videoIn = all_data->videoIn; struct GLOBAL *global = all_data->global; struct GWIDGET *gwidget = all_data->gwidget; fd_set fds; struct timeval tv; int ret; FD_ZERO(&fds); FD_SET(videoIn->udev_fd, &fds); tv.tv_sec = 0; tv.tv_usec = 0; ret = select(videoIn->udev_fd+1, &fds, NULL, NULL, &tv); /* Check if our file descriptor has received data. */ if (ret > 0 && FD_ISSET(videoIn->udev_fd, &fds)) { /* Make the call to receive the device. select() ensured that this will not block. */ struct udev_device *dev = udev_monitor_receive_device(videoIn->udev_mon); if (dev) { if (global->debug) { g_print("Got Device event\n"); g_print(" Node: %s\n", udev_device_get_devnode(dev)); g_print(" Subsystem: %s\n", udev_device_get_subsystem(dev)); g_print(" Devtype: %s\n", udev_device_get_devtype(dev)); g_print(" Action: %s\n",udev_device_get_action(dev)); } /*update device list*/ g_signal_handlers_block_by_func(GTK_COMBO_BOX_TEXT(gwidget->Devices), G_CALLBACK (Devices_changed), all_data); /* clear out the old device list... */ if(videoIn->listDevices != NULL) freeDevices(videoIn->listDevices); GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model (GTK_COMBO_BOX(gwidget->Devices))); gtk_list_store_clear(store); /*create new device list*/ videoIn->listDevices = enum_devices( videoIn->videodevice, videoIn->udev, global->debug ); if (videoIn->listDevices->num_devices < 1) { //use current gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Devices), videoIn->videodevice); gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Devices),0); } else { int i=0; for(i=0;i<(videoIn->listDevices->num_devices);i++) { gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Devices), videoIn->listDevices->listVidDevices[i].name); if(videoIn->listDevices->listVidDevices[i].current) gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Devices),i); } } g_signal_handlers_unblock_by_func(GTK_COMBO_BOX_TEXT(gwidget->Devices), G_CALLBACK (Devices_changed), all_data); udev_device_unref(dev); } else g_printerr("No Device from receive_device(). An error occured.\n"); } return(TRUE); }
/* * Note that this is called every time the user clicks on an item, * whether it is already selected or not. */ static void field_select_row_cb(GtkTreeSelection *sel, gpointer tree) { GtkWidget *window = (GtkWidget *)gtk_widget_get_toplevel((GtkWidget *)tree); GtkWidget *relation_list = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RELATION_LIST_KEY); GtkWidget *range_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_LABEL_KEY); GtkWidget *range_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_ENTRY_KEY); GtkWidget *value_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LABEL_KEY); GtkWidget *value_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_ENTRY_KEY); GtkWidget *value_list_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_LABEL_KEY); GtkWidget *value_list = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_KEY); GtkWidget *value_list_scrolled_win = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_SW_KEY); GtkWidget *ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_OK_BT_KEY); header_field_info *hfinfo, *cur_hfinfo; const char *value_type; char value_label_string[1024+1]; /* XXX - should be large enough */ GtkTreeModel *model; GtkTreeIter iter; if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return; gtk_tree_model_get(model, &iter, 0, &hfinfo, -1); /* * What was the item that was last selected? */ cur_hfinfo = (header_field_info *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY); if (cur_hfinfo == hfinfo) { /* * It's still selected; no need to change anything. */ return; } /* * Mark it as currently selected. */ g_object_set_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY, hfinfo); show_relations(relation_list, hfinfo->type); /* * Set the label for the value to indicate what type of value * it is. */ value_type = ftype_pretty_name(hfinfo->type); if (value_type != NULL) { /* * Indicate what type of value it is. */ g_snprintf(value_label_string, sizeof value_label_string, "Value (%s)", value_type); gtk_label_set_text(GTK_LABEL(value_label), value_label_string); } /* * Clear the entry widget for the value, as whatever * was there before doesn't apply. */ gtk_entry_set_text(GTK_ENTRY(value_entry), ""); switch (hfinfo->type) { case FT_BOOLEAN: /* * The list of values should be the strings for "true" * and "false"; show them in the value list. */ build_boolean_values(value_list_scrolled_win, value_list, (const true_false_string *)hfinfo->strings); break; case FT_UINT8: case FT_UINT16: case FT_UINT24: case FT_UINT32: case FT_INT8: case FT_INT16: case FT_INT24: case FT_INT32: /* * If this has a value_string table (not a range_string table) associated with it, * fill up the list of values, otherwise clear the list of values. */ /* XXX: ToDo: Implement "range-string" filter ? */ if ((hfinfo->strings != NULL) && ! (hfinfo->display & BASE_RANGE_STRING) && ! (hfinfo->display & BASE_VAL64_STRING) && ! ((hfinfo->display & FIELD_DISPLAY_E_MASK) == BASE_CUSTOM)) { const value_string *vals = (const value_string *)hfinfo->strings; if (hfinfo->display & BASE_EXT_STRING) vals = VALUE_STRING_EXT_VS_P((const value_string_ext *)vals); build_enum_values(value_list_scrolled_win, value_list, vals); } else gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list)))); break; default: /* * Clear the list of values. */ gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list)))); break; } /* * Display various items for the value, as appropriate. * The relation we start out with is never a comparison. */ display_value_fields(hfinfo, FALSE, value_label, value_entry, value_list_label, value_list, value_list_scrolled_win, range_label, range_entry); /* * XXX - in browse mode, there always has to be something * selected, so this should always be sensitive. */ gtk_widget_set_sensitive(ok_bt, TRUE); }
static void muine_update(EinaMuine *self) { g_return_if_fail(EINA_IS_MUINE(self)); EinaMuinePrivate *priv = self->priv; typedef struct { guint count; // How many items have been folded gchar *artist, *album; // Metadata from DB LomoStream *stream; // Fake stream } data_set_t; EinaMuineMode mode = eina_muine_get_mode(self); gchar *markup_fmt = NULL; // Build master query gchar *q = NULL; switch (mode) { case EINA_MUINE_MODE_ALBUM: // q = "select count(*) as count,artist,album from fast_meta group by(lower(album)) order by artist ASC"; q = "select count(*) as count,artist,album from fast_meta group by(album) order by lower(artist) ASC"; markup_fmt = "<big><b>%s</b></big>\n%s <span size=\"small\" weight=\"light\">(%d streams)</span>"; break; case EINA_MUINE_MODE_ARTIST: // q = "select count(*) as count,artist,NULL from fast_meta group by(lower(artist)) order by artist ASC"; q = "select count(*) as count,artist,NULL from fast_meta group by(artist) order by lower(artist) ASC"; markup_fmt = "<big><b>%s</b></big>\n<span size=\"small\" weight=\"light\">(%d streams)</span>"; break; default: g_warning(N_("Unknow mode: %d"), mode); return; } // Now fill the data_store; EinaAdbResult *r = eina_adb_query(eina_muine_get_adb(self), q, NULL); GList *db_data = NULL; data_set_t *ds = NULL; while (eina_adb_result_step(r)) { if (ds == NULL) ds = g_new0(data_set_t, 1); eina_adb_result_get(r, 0, G_TYPE_UINT, &(ds->count), 1, G_TYPE_STRING, &(ds->artist), 2, G_TYPE_STRING, &(ds->album), -1); db_data = g_list_prepend(db_data, ds); ds = NULL; } g_object_unref(r); // Try to get a sample for each item // q = "select uri from streams where sid = (select sid from fast_meta where lower(%s)=lower('%q') limit 1 offset %d)"; q = "select uri from streams where sid = (select sid from fast_meta where %s='%q' limit 1 offset %d)"; EinaAdb *adb = eina_muine_get_adb(self); gchar *sample_uri = NULL; gchar *field = (mode == EINA_MUINE_MODE_ALBUM) ? "album" : "artist"; gchar *key = NULL; GList *ds_p = db_data; while (ds_p) { data_set_t *ds = (data_set_t *) ds_p->data; char *q2 = sqlite3_mprintf(q, field, key = ((mode == EINA_MUINE_MODE_ALBUM) ? ds->album : ds->artist), g_random_int_range(0, ds->count)); EinaAdbResult *sr = eina_adb_query_raw(adb, q2); if (!sr || !eina_adb_result_step(sr)) { g_warning(N_("Unable to fetch sample URI for %s '%s', query was %s"), field, key, q2); sample_uri = g_strdup("file:///nonexistent"); } else eina_adb_result_get(sr, 0, G_TYPE_STRING, &sample_uri, -1); gel_free_and_invalidate(sr, NULL, g_object_unref); gel_free_and_invalidate(q2, NULL, sqlite3_free); ds->stream = lomo_stream_new(sample_uri); g_free(sample_uri); ds_p = ds_p->next; } // All data (and all I/O) from DB has been fetched, insert into interface gtk_list_store_clear(muine_get_model(self)); g_hash_table_remove_all(priv->stream_iter_map); ds_p = db_data; GtkListStore *model = muine_get_model(self); gchar *artist = NULL, *album = NULL; gchar *markup = NULL; GValue v = { 0 }; g_value_init(&v, G_TYPE_STRING); while (ds_p) { data_set_t *ds = (data_set_t *) ds_p->data; if (ds->artist) { artist = g_markup_escape_text(ds->artist, -1); g_value_set_static_string(&v, artist); lomo_stream_set_tag(ds->stream, LOMO_TAG_ARTIST, &v); } if (ds->album) { album = g_markup_escape_text(ds->album, -1); g_value_set_static_string(&v, album); lomo_stream_set_tag(ds->stream, LOMO_TAG_ALBUM, &v); } switch (mode) { case EINA_MUINE_MODE_INVALID: case EINA_MUINE_MODE_ALBUM: markup = g_strdup_printf(markup_fmt, album, artist, ds->count); break; case EINA_MUINE_MODE_ARTIST: markup = g_strdup_printf(markup_fmt, artist, ds->count); break; } static GdkPixbuf *default_pb = NULL; if (!default_pb) { GError *e = NULL; GInputStream *stream = gel_io_open(lomo_em_art_provider_get_default_cover(), &e); if (stream == NULL) g_error(_("Can't open `%s': %s"), lomo_em_art_provider_get_default_cover(), e->message); default_pb = gdk_pixbuf_new_from_stream_at_scale(stream, DEFAULT_SIZE, DEFAULT_SIZE, TRUE, NULL, NULL); g_input_stream_close(stream, NULL, NULL); } GtkTreeIter iter; gtk_list_store_insert_with_values(model, &iter, 0, COMBO_COLUMN_MARKUP, markup, COMBO_COLUMN_ID, (mode == EINA_MUINE_MODE_ALBUM) ? ds->album : ds->artist, COMBO_COLUMN_STREAM, ds->stream, COMBO_COLUMN_ICON, default_pb, -1); g_hash_table_insert(priv->stream_iter_map, ds->stream, gtk_tree_iter_copy(&iter)); lomo_stream_set_all_tags_flag(ds->stream, TRUE); g_signal_connect(ds->stream, "extended-metadata-updated", (GCallback) stream_em_updated_cb, self); lomo_em_art_provider_init_stream(priv->art, ds->stream); g_free(ds->artist); g_free(ds->album); g_free(ds); g_free(markup); gel_free_and_invalidate(artist, NULL, g_free); gel_free_and_invalidate(album, NULL, g_free); ds_p = ds_p->next; } g_value_reset(&v); g_list_free(db_data); }
void display_command_disconnect(void) { display_command_sock = -1; gtk_widget_set_sensitive(display_command_box, 0); gtk_list_store_clear(display_command_list); }
void display_command_connect(int sock) { display_command_sock = sock; gtk_widget_set_sensitive(display_command_box, 1); gtk_list_store_clear(display_command_list); }
static gboolean changed_callback (GtkEntry *entry, dt_lib_collect_rule_t *dr) { // update related list dt_lib_collect_t *d = get_collect(dr); sqlite3_stmt *stmt; GtkTreeIter iter; GtkTreeView *view = d->view; GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(view)); g_object_ref(model); gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL); gtk_list_store_clear(GTK_LIST_STORE(model)); char query[1024]; int property = gtk_combo_box_get_active(dr->combo); const gchar *text = gtk_entry_get_text(GTK_ENTRY(dr->text)); gchar *escaped_text = dt_util_str_replace(text, "'", "''"); char confname[200]; snprintf(confname, 200, "plugins/lighttable/collect/string%1ld", dr->num); dt_conf_set_string (confname, text); snprintf(confname, 200, "plugins/lighttable/collect/item%1ld", dr->num); dt_conf_set_int (confname, property); switch(property) { case 0: // film roll snprintf(query, 1024, "select distinct folder, id from film_rolls where folder like '%%%s%%' order by id DESC", escaped_text); break; case 1: // camera snprintf(query, 1024, "select distinct maker || ' ' || model as model, 1 from images where maker || ' ' || model like '%%%s%%' order by model", escaped_text); break; case 2: // tag snprintf(query, 1024, "SELECT distinct name, id FROM tags WHERE name LIKE '%%%s%%' ORDER BY UPPER(name)", escaped_text); break; case 4: // History, 2 hardcoded alternatives gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("altered"), DT_LIB_COLLECT_COL_ID, 0, DT_LIB_COLLECT_COL_TOOLTIP,_("altered"), -1); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("not altered"), DT_LIB_COLLECT_COL_ID, 1, DT_LIB_COLLECT_COL_TOOLTIP,_("not altered"), -1); goto entry_key_press_exit; break; case 5: // colorlabels gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("red"), DT_LIB_COLLECT_COL_ID, 0, DT_LIB_COLLECT_COL_TOOLTIP, _("red"), -1); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("yellow"), DT_LIB_COLLECT_COL_ID, 1, DT_LIB_COLLECT_COL_TOOLTIP, _("yellow"), -1); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("green"), DT_LIB_COLLECT_COL_ID, 2, DT_LIB_COLLECT_COL_TOOLTIP, _("green"), -1); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("blue"), DT_LIB_COLLECT_COL_ID, 3, DT_LIB_COLLECT_COL_TOOLTIP, _("blue"), -1); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT,_("purple"), DT_LIB_COLLECT_COL_ID, 4, DT_LIB_COLLECT_COL_TOOLTIP, _("purple"), -1); goto entry_key_press_exit; break; // TODO: Add empty string for metadata? // TODO: Autogenerate this code? case 6: // title snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value", DT_METADATA_XMP_DC_TITLE, escaped_text); break; case 7: // description snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value", DT_METADATA_XMP_DC_DESCRIPTION, escaped_text); break; case 8: // creator snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value", DT_METADATA_XMP_DC_CREATOR, escaped_text); break; case 9: // publisher snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value", DT_METADATA_XMP_DC_PUBLISHER, escaped_text); break; case 10: // rights snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%'order by value ", DT_METADATA_XMP_DC_RIGHTS, escaped_text); break; case 11: // lens snprintf(query, 1024, "select distinct lens, 1 from images where lens like '%%%s%%' order by lens", escaped_text); break; case 12: // iso snprintf(query, 1024, "select distinct cast(iso as integer) as iso, 1 from images where iso like '%%%s%%' order by iso", escaped_text); break; case 13: // aperature snprintf(query, 1024, "select distinct round(aperture,1) as aperture, 1 from images where aperture like '%%%s%%' order by aperture", escaped_text); break; case 14: // filename snprintf(query, 1024, "select distinct filename, 1 from images where filename like '%%%s%%' order by filename", escaped_text); break; default: // case 3: // day snprintf(query, 1024, "SELECT DISTINCT datetime_taken, 1 FROM images WHERE datetime_taken LIKE '%%%s%%' ORDER BY datetime_taken DESC", escaped_text); break; } g_free(escaped_text); DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL); while(sqlite3_step(stmt) == SQLITE_ROW) { gtk_list_store_append(GTK_LIST_STORE(model), &iter); const char *folder = (const char*)sqlite3_column_text(stmt, 0); if(property == 0) // film roll { folder = dt_image_film_roll_name(folder); } gchar *value = (gchar *)sqlite3_column_text(stmt, 0); gchar *escaped_text = g_markup_escape_text(value, strlen(value)); gtk_list_store_set (GTK_LIST_STORE(model), &iter, DT_LIB_COLLECT_COL_TEXT, folder, DT_LIB_COLLECT_COL_ID, sqlite3_column_int(stmt, 1), DT_LIB_COLLECT_COL_TOOLTIP, escaped_text, DT_LIB_COLLECT_COL_PATH, value, -1); } sqlite3_finalize(stmt); entry_key_press_exit: gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(view), DT_LIB_COLLECT_COL_TOOLTIP); gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); g_object_unref(model); return FALSE; }
static void build_channel_list(void) { GtkTreeIter iter, iter2, iter3; unsigned int enabled; char *device, *device2; gboolean first = FALSE, iter3_valid = FALSE, loop, loop2, all = FALSE; char dev_ch[256]; loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (device_list_store), &iter); gtk_list_store_clear(channel_list_store); while (loop) { gtk_tree_model_get(GTK_TREE_MODEL (device_list_store), &iter, 0, &device, 1, &enabled, -1); if (enabled) { struct iio_device *dev; unsigned int i, nb_channels; all = true; /* is it already in the list? */ loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2); if (loop2) { first = TRUE; iter3 = iter2; iter3_valid = TRUE; } while (loop2) { gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1); if (!strcmp(device, device2)) break; if (strcmp(device, device2) >= 0) { first = FALSE; iter3 = iter2; } g_free(device2); loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2); } /* it is, so skip the rest */ if (loop2) { loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter); continue; } dev = get_device(device); if (!dev) continue; nb_channels = iio_device_get_channels_count(dev); for (i = 0; i < nb_channels; i++) { struct iio_channel *chn = iio_device_get_channel(dev, i); const char *name, *id, *devid; /* Must be input */ if (!is_valid_dmm_channel(chn)) continue; /* find the name */ devid = iio_device_get_id(dev); name = iio_channel_get_name(chn); id = iio_channel_get_id(chn); if (!name) name = id; if (iter3_valid) { if (first) { gtk_list_store_insert_before(channel_list_store, &iter2, &iter3); first = FALSE; } else if(gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter3)) gtk_list_store_insert_before(channel_list_store, &iter2, &iter3); else gtk_list_store_append(channel_list_store, &iter2); } else { gtk_list_store_append(channel_list_store, &iter2); iter3_valid = TRUE; } snprintf(dev_ch, sizeof(dev_ch), "%s:%s", device, name); gtk_list_store_set(channel_list_store, &iter2, 0, dev_ch, /* device & channel name */ 1, 0, /* On/Off */ 2, devid, /* device ID */ 3, id, /* channel ID */ -1); iter3 = iter2; } } else { loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2); while (loop2) { gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1); if (!strcmp(device, device2)) { loop2 = gtk_list_store_remove(channel_list_store, &iter2); continue; } loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2); } } loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter); } gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(GTK_TREE_MODEL(channel_list_store)), 0, GTK_SORT_ASCENDING); if (all) gtk_widget_show(select_all_channels); else gtk_widget_hide(select_all_channels); }
void discard_begin(void) { gtk_list_store_clear(GTK_LIST_STORE(discard_store)); gui_discard_show(); }
/* Apply filter manually by copying iters from romFullList model to romDisplay model * if they match filter criteria. Optimized to just do a sort on romDisplaymodel if * filter is empty twice in a row. */ static void apply_filter() { int g_iNumRoms; static short resort = 0; GtkTreeModel* destination; const gchar* filter; filter = gtk_entry_get_text(GTK_ENTRY(g_MainWindow.filter)); if(filter[0]!='\0'||resort==1) { if(filter[0]!='\0') resort=1; else resort=0; GtkTreeModel *model, *source; GtkTreeIter sourceiter, destinationiter; gboolean validiter; char *country, *goodname, *usercomments, *filename, *md5hash, *crc1, *crc2, *internalname, *savetype, *players, *size, *compressiontype, *imagetype, *cicchip, *rumble; GdkPixbuf *status[5]; GdkPixbuf *flag; cache_entry* entry; short int counter; /* Clear the display model. */ GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romDisplay)); gtk_tree_selection_select_all(selection); model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_MainWindow.romDisplay)); gtk_list_store_clear(GTK_LIST_STORE(model)); source = gtk_tree_view_get_model(GTK_TREE_VIEW(g_MainWindow.romFullList)); g_iNumRoms = gtk_tree_model_iter_n_children(source, NULL); validiter = gtk_tree_model_get_iter_first(source, &sourceiter); destination = gtk_tree_view_get_model(GTK_TREE_VIEW(g_MainWindow.romDisplay)); gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(destination), g_MainWindow.romSortColumn, return_zero, (gpointer)NULL, (gpointer)NULL); if(validiter) { for(counter = 0; counter < g_iNumRoms; ++counter) { if(filter_function(source, &sourceiter, (gpointer)NULL)) { gtk_tree_model_get(GTK_TREE_MODEL(source), &sourceiter, 0, &country, 1, &goodname, 3, &usercomments, 4, &filename, 5, &md5hash, 6, &crc1, 7, &crc2, 8, &internalname, 9, &savetype, 10, &players, 11, &size, 12, &compressiontype, 13, &imagetype, 14, &cicchip, 15, &rumble, 16, &status[0], 17, &status[1], 18, &status[2], 19, &status[3], 20, &status[4], 21, &flag, 22, &entry, -1); gtk_list_store_append(GTK_LIST_STORE(destination), &destinationiter); gtk_list_store_set(GTK_LIST_STORE(destination), &destinationiter, 0, country, 1, goodname, 2, NULL, 3, usercomments, 4, filename, 5, md5hash, 6, crc1, 7, crc2, 8, internalname, 9, savetype, 10, players, 11, size, 12, compressiontype, 13, imagetype, 14, cicchip, 15, rumble, 16, status[0], 17, status[1], 18, status[2], 19, status[3], 20, status[4], 21, flag, 22, entry, -1); } if(!gtk_tree_model_iter_next(source, &sourceiter)) break; } } } else destination = gtk_tree_view_get_model(GTK_TREE_VIEW(g_MainWindow.romDisplay)); /* Always sort romDisplay, otherwise regular column sorting won't work. */ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(destination), g_MainWindow.romSortColumn, rombrowser_compare, (gpointer)NULL, (gpointer)NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(destination), g_MainWindow.romSortColumn, g_MainWindow.romSortType); }
static void wckbuttons_load_themes (GtkWidget *view, WBPlugin *wb) { GtkTreeModel *model; GHashTable *themes; GDir *dir; const gchar *file; gchar **theme_dirs; gchar *themedir; gint i; themes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); model = gtk_tree_view_get_model (GTK_TREE_VIEW (view)); /* clear any previous row */ gtk_list_store_clear (GTK_LIST_STORE (model)); xfce_resource_push_path (XFCE_RESOURCE_THEMES, DATADIR G_DIR_SEPARATOR_S "themes"); theme_dirs = xfce_resource_dirs (XFCE_RESOURCE_THEMES); xfce_resource_pop_path (XFCE_RESOURCE_THEMES); for (i = 0; theme_dirs[i] != NULL; ++i) { dir = g_dir_open (theme_dirs[i], 0, NULL); if (G_UNLIKELY (dir == NULL)) continue; while ((file = g_dir_read_name (dir)) != NULL) { /* check if there is not already a theme with the * same name in the database */ if (g_hash_table_lookup (themes, file) == NULL) { if (wb->prefs->sync_wm_theme) { if (!test_theme_dir(file, "xfwm4", THEMERC)) continue; } themedir = get_theme_dir (file, NULL); if (!themedir) continue; GtkTreeIter iter; g_hash_table_insert (themes, g_strdup (file), GINT_TO_POINTER (1)); /* insert in the list store */ gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COL_THEME_NAME, file, COL_THEME_RC, g_path_get_basename (themedir), -1); if (G_UNLIKELY (g_str_equal (wb->prefs->theme, file))) { GtkTreePath *path = gtk_tree_model_get_path (model, &iter); gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (view)), &iter); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (view), path, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free (path); } g_free (themedir); } } g_dir_close (dir); } g_strfreev (theme_dirs); g_hash_table_destroy (themes); }
static void clist_refresh(GtkListStore *store) { gtk_list_store_clear(store); clist_populate(store); }