Example #1
0
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);
	}
}
Example #2
0
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 );
	}
}
Example #3
0
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);
}
Example #4
0
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);
}
Example #6
0
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);
}
Example #8
0
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;
}
Example #9
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);
	}
}
Example #10
0
	// 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);
	}
Example #11
0
/**
 * 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;
}
Example #12
0
/*
 * 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, &gtkui_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;
   }
}
Example #13
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);
}
Example #15
0
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);
	}
}
Example #16
0
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);
  }
}
Example #17
0
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);
}
Example #19
0
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);
        }
}
Example #20
0
/* 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);
}
Example #21
0
/*
 * 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);
}
Example #22
0
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);
}
Example #23
0
void display_command_disconnect(void)
{
	display_command_sock = -1;
	gtk_widget_set_sensitive(display_command_box, 0);
	gtk_list_store_clear(display_command_list);
}
Example #24
0
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);
}
Example #25
0
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;
}
Example #26
0
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);
}
Example #27
0
void discard_begin(void)
{
	gtk_list_store_clear(GTK_LIST_STORE(discard_store));
	gui_discard_show();
}
Example #28
0
/* 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);
}
Example #30
0
static void clist_refresh(GtkListStore *store)
{
	gtk_list_store_clear(store);
	clist_populate(store);
}