static void
codec_moved_cb (GtkWidget *widget,
gpointer data)
{
CodecsBox *self = NULL;
GtkTreeIter iter;
GtkTreeIter *iter2 = NULL;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection = NULL;
GtkTreePath *tree_path = NULL;
std::list<std::string> list;
gchar *path_str = NULL;
self = CODECS_BOX (data);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list));
if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection),
NULL, &iter))
return;
/* Update the tree view */
iter2 = gtk_tree_iter_copy (&iter);
path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model),
&iter);
tree_path = gtk_tree_path_new_from_string (path_str);
if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"),
"up"))
gtk_tree_path_prev (tree_path);
else
gtk_tree_path_next (tree_path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path);
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)
&& gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2))
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2);
/* Scroll to the new position */
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list),
tree_path, NULL, FALSE, 0, 0);
gtk_tree_path_free (tree_path);
gtk_tree_iter_free (iter2);
g_free (path_str);
/* Update the key */
list = codecs_box_to_list (self);
if (self->priv->type == Ekiga::Call::Audio)
self->priv->audio_settings->set_string_list ("media-list", list);
else if (self->priv->type == Ekiga::Call::Video)
self->priv->video_settings->set_string_list ("media-list", list);
}
unsigned int wxComboBox::GetCount() const
{
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid combobox") );
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
GtkTreeModel* model = gtk_combo_box_get_model( combobox );
GtkTreeIter iter;
gtk_tree_model_get_iter_first( model, &iter );
if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
return 0;
unsigned int ret = 1;
while (gtk_tree_model_iter_next( model, &iter ))
ret++;
return ret;
}
else
#endif
{
GtkWidget *list = GTK_COMBO(m_widget)->list;
GList *child = GTK_LIST(list)->children;
unsigned int count = 0;
while (child)
{
count++;
child = child->next;
}
return count;
}
return 0;
}
static void
clue_check_isempty (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
UIData *ui)
{
GtkTreeSelection *selection;
gchar *keyword = NULL;
gboolean valid;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ui->treeview));
/* move to the previous node */
valid = gtk_tree_path_prev (path);
gtk_tree_model_get (model, iter, CLUE_KEYWORD_COLUMN, &keyword, -1);
if ((keyword) && !(g_utf8_strlen (g_strstrip (keyword), -1) > 0))
gtk_list_store_remove (ui->store, iter);
/* Check if we have a valid row to select. If not, then select
* the previous row */
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter)) {
gtk_tree_selection_select_iter (selection, iter);
} else {
if (path && valid) {
gtk_tree_model_get_iter (model, iter, path);
gtk_tree_selection_select_iter (selection, iter);
}
}
gtk_widget_grab_focus (ui->treeview);
g_free (keyword);
}
int wxChoice::FindString( const wxString &item, bool bCase ) const
{
wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid control") );
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
GtkTreeModel* model = gtk_combo_box_get_model( combobox );
GtkTreeIter iter;
gtk_tree_model_get_iter_first( model, &iter );
if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
return -1;
int count = 0;
do
{
GValue value = G_VALUE_INIT;
gtk_tree_model_get_value( model, &iter, m_stringCellIndex, &value );
wxString str = wxGTK_CONV_BACK( g_value_get_string( &value ) );
g_value_unset( &value );
if (item.IsSameAs( str, bCase ) )
return count;
count++;
}
while ( gtk_tree_model_iter_next(model, &iter) );
return wxNOT_FOUND;
}
gboolean
gnc_tree_model_budget_get_iter_for_budget(GtkTreeModel *tm, GtkTreeIter *iter,
GncBudget *bgt)
{
GValue gv = { 0 };
const GncGUID *guid1;
GncGUID *guid2;
g_return_val_if_fail(GNC_BUDGET(bgt), FALSE);
guid1 = gnc_budget_get_guid(bgt);
if (!gtk_tree_model_get_iter_first(tm, iter))
return FALSE;
while (gtk_list_store_iter_is_valid(GTK_LIST_STORE(tm), iter))
{
gtk_tree_model_get_value(tm, iter, BUDGET_GUID_COLUMN, &gv);
guid2 = (GncGUID *) g_value_get_pointer(&gv);
g_value_unset(&gv);
if (guid_equal(guid1, guid2))
return TRUE;
if (!gtk_tree_model_iter_next(tm, iter))
return FALSE;
}
return FALSE;
}
/* Update combo if property in channel changes */
static void
power_manager_plugin_panel_label_changed (XfconfChannel *channel,
const gchar *property,
const GValue *value,
gpointer user_data)
{
GtkWidget *combo = user_data;
GtkListStore *list_store;
GtkTreeIter iter;
int show_panel_label, current_setting;
list_store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo)));
current_setting = g_value_get_int (value);
/* If the value set in xfconf is invalid, treat it like 0 aka "None" */
if (current_setting < 0 ||
current_setting > 3)
current_setting = 0;
for (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
gtk_list_store_iter_is_valid (list_store, &iter);
gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter))
{
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, 0, &show_panel_label, -1);
if (show_panel_label == current_setting)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo),
&iter);
}
}
static void
_code_assist_tree_selection_changed (GtkTreeSelection *selection, gpointer data)
{
CodeAssistWidget *code_assist_widget = (CodeAssistWidget *)data;
GtkTreeIter tree_iter;
gtk_tree_selection_get_selected (selection, NULL, &tree_iter);
if (!gtk_list_store_iter_is_valid (code_assist_widget->list_store,
&tree_iter))
return;
gpointer value;
gtk_tree_model_get (GTK_TREE_MODEL (code_assist_widget->list_store), &tree_iter, ASSIST_COL_POINTER, &value, -1);
PyVariable *py_var = PY_VARIABLE (value);
if (!py_var)
return;
if (py_var->doc_string)
{
if (!gtk_widget_get_parent (code_assist_widget->text_scroll_win))
gtk_box_pack_start (GTK_BOX (code_assist_widget->parent),
code_assist_widget->text_scroll_win, FALSE, FALSE, 0);
gtk_widget_show_all (code_assist_widget->text_scroll_win);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (code_assist_widget->text_view));
gtk_text_buffer_set_text (buffer, py_var->doc_string, -1);
}
else
{
if (gtk_widget_get_parent (code_assist_widget->text_scroll_win))
gtk_container_remove (GTK_CONTAINER (code_assist_widget->parent),
code_assist_widget->text_scroll_win);
}
}
gboolean
code_assist_show_matches (CodeAssistWidget *code_assist, gchar *string)
{
GtkTreeIter tree_iter;
gtk_list_store_clear (code_assist->list_store);
gboolean found = FALSE;
int i;
for (i = 0; i < code_assist->py_var_array_size; i++)
{
if (g_strstr_len (code_assist->py_var_array [i]->name, -1, string))
{
_code_assist_show_py_var (code_assist, code_assist->py_var_array [i]);
found = TRUE;
}
}
if (!found)
return FALSE;
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (code_assist->list_view));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (code_assist->list_store), &tree_iter);
if (!gtk_list_store_iter_is_valid (code_assist->list_store, &tree_iter))
return FALSE;
//gtk_widget_grab_focus (codewidget->code_assist_widget->list_view);
gtk_tree_selection_select_iter (selection, &tree_iter);
return TRUE;
}
void on_show_system_colors_activate (GtkMenuItem *menuitem, gpointer user_data)
{
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)))
{
/* re-add the system colors */
add_rgb_file (get_system_file (), SYSTEM_COLOR);
}
else
{
/* hide the system colors. unfortunately we have to remove them
since there's no way to simply hide them. */
gchar *type;
GtkTreeIter iterator;
GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (gcolor2, "treeview"));
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
gtk_tree_model_get_iter_first (model, &iterator);
while (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iterator))
{
gtk_tree_model_get (model, &iterator, COLOR_TYPE, &type, -1);
if (!strcmp (type, SYSTEM_COLOR))
{
gtk_list_store_remove (GTK_LIST_STORE (model), &iterator);
}
else
{
gtk_tree_model_iter_next (model, &iterator);
}
}
}
}
/**
* Move account in list depending on direction and selected account
*/
static void
account_move(gboolean move_up, gpointer data)
{
// Get view, model and selection of account
GtkTreeView *tree_view = GTK_TREE_VIEW(data);
GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view);
// Find selected iteration and create a copy
GtkTreeIter iter;
gtk_tree_selection_get_selected(selection, &model, &iter);
GtkTreeIter *iter_copy;
iter_copy = gtk_tree_iter_copy(&iter);
// Find path of iteration
gchar *path = gtk_tree_model_get_string_from_iter(model, &iter);
// The first real account in the list can't move up because of the IP2IP account
// It can still move down though
if (g_strcmp0(path, "1") == 0 && move_up)
return;
GtkTreePath *tree_path = gtk_tree_path_new_from_string(path);
gint *indices = gtk_tree_path_get_indices(tree_path);
const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */
// Depending on button direction get new path
if (move_up)
gtk_tree_path_prev(tree_path);
else
gtk_tree_path_next(tree_path);
gtk_tree_model_get_iter(model, &iter, tree_path);
// Swap iterations if valid
if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter))
gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy);
// Scroll to new position
gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0);
// Free resources
gtk_tree_path_free(tree_path);
gtk_tree_iter_free(iter_copy);
g_free(path);
// Perpetuate changes in account queue
if (move_up)
account_list_move_up(pos);
else
account_list_move_down(pos);
// Set the order in the configuration file
gchar *ordered_account_list = account_list_get_ordered_list();
dbus_set_accounts_order(ordered_account_list);
g_free(ordered_account_list);
}
static void tb_editor_drag_data_rcvd_cb(GtkWidget *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *data, guint info,
guint ltime, TBEditorWidget *tbw)
{
GtkTreeView *tree = GTK_TREE_VIEW(widget);
gboolean del = FALSE;
if (gtk_selection_data_get_target (data) != GDK_NONE )
{
gboolean is_sep;
const guchar *text = gtk_selection_data_get_data (data);
is_sep = (g_strcmp0(text, "Separator") == 0);
/* If the source of the action is equal to the target, we do just re-order and
** so need to delete the separator to get it moved, not just copied. */
if (is_sep && widget == tbw->drag_source)
is_sep = FALSE;
if (tree != tbw->tree_available || ! is_sep)
{
GtkTreeIter iter, iter_before, *iter_before_ptr;
GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(tree));
if (tbw->last_drag_path != NULL)
{
gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter_before, tbw->last_drag_path);
if (gtk_list_store_iter_is_valid(store, &iter_before))
iter_before_ptr = &iter_before;
else
iter_before_ptr = NULL;
if (tbw->last_drag_pos == GTK_TREE_VIEW_DROP_BEFORE ||
tbw->last_drag_pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)
gtk_list_store_insert_before(store, &iter, iter_before_ptr);
else
gtk_list_store_insert_after(store, &iter, iter_before_ptr);
tb_editor_set_item_values(tbw, text, store, &iter);
}
else
{
gtk_list_store_append(store, &iter);
tb_editor_set_item_values(tbw, text, store, &iter);
}
tb_editor_scroll_to_iter(tree, &iter);
}
if (tree != tbw->tree_used || ! is_sep)
del = TRUE;
}
tbw->drag_source = NULL; /* reset the value just to be sure */
tb_editor_free_path(tbw);
gtk_drag_finish(context, TRUE, del, ltime);
}
/* Eine Telefonliste soll gespeichert werden */
void saveButtonClicked(GtkWidget *widget, GdkEvent *event, gpointer data){
GtkTreeIter iter;
char* name;
if(gtk_tree_selection_get_selected (listsListSel, NULL, &iter)){
if(gtk_list_store_iter_is_valid(listsListStore, &iter)){
gtk_tree_model_get((GtkTreeModel*)listsListStore, &iter, NAME_LISTS_COLUMN, &name, -1);
savePhoneList(name);
}
}
}
static void
eds_ok_button_clicked (GtkButton *button,
PlannerPlugin *plugin)
{
GtkTreeIter iter;
PlannerPluginPriv *priv = plugin->priv;
GList *resources_orig;
/* We are going to modify the resources. Work with a copy */
resources_orig = mrp_project_get_resources (plugin->priv->project);
if (!priv->resources_model) {
eds_dialog_close (plugin);
return;
}
gtk_tree_model_get_iter_first (priv->resources_model, &iter);
if (!gtk_list_store_iter_is_valid (GTK_LIST_STORE (priv->resources_model),
&iter)) {
eds_dialog_close (plugin);
return;
}
/* Custom property for e-d-s resource UID */
if (!mrp_project_has_property (plugin->priv->project,
MRP_TYPE_RESOURCE, "eds-uid")) {
eds_create_uid_property (plugin);
}
do {
EContact *contact;
gboolean selected;
gtk_tree_model_get (priv->resources_model, &iter,
COL_RESOURCE_SELECTED, &selected,
COL_RESOURCE_OBJECT, &contact,
-1);
if (selected) {
gchar *name = e_contact_get (contact, E_CONTACT_FULL_NAME);
gchar *email = e_contact_get (contact, E_CONTACT_EMAIL_1);
gchar *eds_uid = e_contact_get (contact, E_CONTACT_UID);
eds_import_resource (name, email, eds_uid, plugin, resources_orig);
g_free (name);
g_free (email);
g_free (eds_uid);
}
} while (gtk_tree_model_iter_next (priv->resources_model, &iter));
eds_dialog_close (plugin);
}
int wxComboBox::FindString( const wxString &item, bool bCase ) const
{
wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid combobox") );
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
GtkTreeModel* model = gtk_combo_box_get_model( combobox );
GtkTreeIter iter;
gtk_tree_model_get_iter_first( model, &iter );
if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
return -1;
int count = 0;
do
{
GValue value = { 0, };
gtk_tree_model_get_value( model, &iter, 0, &value );
wxString str = wxGTK_CONV_BACK( g_value_get_string( &value ) );
g_value_unset( &value );
if (item.IsSameAs( str, bCase ) )
return count;
count++;
} while (gtk_tree_model_iter_next( model, &iter ));
}
else
#endif
{
GtkWidget *list = GTK_COMBO(m_widget)->list;
GList *child = GTK_LIST(list)->children;
int count = 0;
while (child)
{
GtkBin *bin = GTK_BIN( child->data );
GtkLabel *label = GTK_LABEL( bin->child );
wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );
if (item.IsSameAs( str , bCase ) )
return count;
count++;
child = child->next;
}
}
return wxNOT_FOUND;
}
unsigned int wxChoice::GetCount() const
{
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid control") );
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
GtkTreeModel* model = gtk_combo_box_get_model( combobox );
GtkTreeIter iter;
gtk_tree_model_get_iter_first( model, &iter );
if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
return 0;
unsigned int ret = 1;
while (gtk_tree_model_iter_next( model, &iter ))
ret++;
return ret;
}
/* Eine Telefonliste soll geschlossen werden */
void closeButtonClicked(GtkWidget *widget, GdkEvent *event, gpointer data){
GtkTreeIter iter;
char* name;
if(gtk_tree_selection_get_selected (listsListSel, NULL, &iter)){
if(gtk_list_store_iter_is_valid(listsListStore, &iter)){
gtk_tree_model_get((GtkTreeModel*)listsListStore, &iter, NAME_LISTS_COLUMN, &name, -1);
closeListByName(name, &iter);
if(gtk_tree_model_get_iter_first ((GtkTreeModel*)listsListStore, &iter)){
gtk_tree_selection_select_iter(listsListSel, &iter);
} else {
gtk_tree_view_set_model(GTK_TREE_VIEW(phoneView), GTK_TREE_MODEL(phoneDefaultStore));
}
}
}
}
gboolean play(void *data)
{
PlayData *p = (PlayData *) data;
if (ok_to_play && p != NULL) {
if (!gtk_list_store_iter_is_valid(playliststore, &iter)) {
// printf("iter is not valid, getting first one\n");
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(playliststore), &iter);
}
gtk_list_store_set(playliststore, &iter, PLAYLIST_COLUMN, p->playlist, ITEM_COLUMN, p->uri, -1);
play_iter(&iter, 0);
}
g_free(p);
return FALSE;
}
int
clip_GTK_LISTSTOREITERISVALID(ClipMachine * cm)
{
C_object *cslist = _fetch_co_arg(cm);
C_object *citer = _fetch_cobject(cm, _clip_spar(cm, 2));
CHECKARG2(1, MAP_t, NUMERIC_t); CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object));
CHECKCOBJ(citer, GTK_IS_TREE_ITER(citer->object));
_clip_retl(cm, gtk_list_store_iter_is_valid(GTK_LIST_STORE(cslist->object),
GTK_TREE_ITER(citer->object)));
return 0;
err:
return 1;
}
static void
clue_remove_clicked (GtkButton *button,
UIData *ui)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
gboolean valid;
gint len;
valid = FALSE;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ui->treeview));
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return;
/* Get the path and move to the previous node :) */
path = gtk_tree_model_get_path (model, &iter);
if (path)
valid = gtk_tree_path_prev (path);
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
len = gtk_tree_model_iter_n_children (model, NULL);
if (len > 0) {
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)) {
gtk_tree_selection_select_iter (selection, &iter);
} else {
if (path && valid) {
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_selection_select_iter (selection, &iter);
}
}
} else {
gtk_widget_set_sensitive (ui->clue_edit, FALSE);
gtk_widget_set_sensitive (ui->clue_remove, FALSE);
}
gtk_widget_grab_focus (ui->treeview);
gtk_tree_path_free (path);
commit_changes (ui);
}
void play_next()
{
gchar *filename;
gint count;
PlayData *p = NULL;
if (next_item_in_playlist(&iter)) {
if (gtk_list_store_iter_is_valid(playliststore, &iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(playliststore), &iter, ITEM_COLUMN, &filename,
COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, -1);
g_strlcpy(idledata->info, filename, 4096);
g_idle_add(set_media_info, idledata);
p = (PlayData *) g_malloc(sizeof(PlayData));
g_strlcpy(p->uri, filename, 4096);
p->playlist = playlist;
g_idle_add(play, p);
g_free(filename);
}
} else {
// printf("end of thread playlist is empty\n");
if (loop) {
if (first_item_in_playlist(&iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(playliststore), &iter, ITEM_COLUMN,
&filename, COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, -1);
g_strlcpy(idledata->info, filename, 4096);
g_idle_add(set_media_info, idledata);
p = (PlayData *) g_malloc(sizeof(PlayData));
g_strlcpy(p->uri, filename, 4096);
p->playlist = playlist;
g_idle_add(play, p);
g_free(filename);
}
} else {
idledata->fullscreen = 0;
g_idle_add(set_fullscreen, idledata);
g_idle_add(set_stop, idledata);
}
if (quit_on_complete) {
g_idle_add(set_quit, idledata);
}
}
}
static gboolean
clue_foreach_check_isempty (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, UIData *ui)
{
gboolean valid;
valid = gtk_tree_model_get_iter_first (model, iter);
while (valid && gtk_list_store_iter_is_valid (ui->store, iter)) {
char *keyword = NULL;
gtk_tree_model_get (model, iter, CLUE_KEYWORD_COLUMN, &keyword, -1);
/* Check if the keyword is not empty and then emit the row-changed
signal (if we delete the row, then the iter gets corrupted) */
if ((keyword) && !(g_utf8_strlen (g_strstrip (keyword), -1) > 0))
gtk_tree_model_row_changed (model, path, iter);
g_free (keyword);
valid = gtk_tree_model_iter_next (model, iter);
}
return FALSE;
}
static void
eds_import_change_all (PlannerPlugin *plugin,
gboolean state)
{
GtkTreeIter iter;
PlannerPluginPriv *priv = plugin->priv;
gtk_tree_model_get_iter_first (priv->resources_model, &iter);
if (!gtk_list_store_iter_is_valid (GTK_LIST_STORE (priv->resources_model),
&iter)) {
return;
}
do {
gtk_list_store_set (GTK_LIST_STORE (priv->resources_model),
&iter,
COL_RESOURCE_SELECTED, state,
-1);
} while (gtk_tree_model_iter_next (priv->resources_model, &iter));
}
/* Laed ein neues Listenfile bzw. erzeugt
* eine neue Liste.
* Dazu wird ein Dateiauswahl-Dialog angezeigt,
* dessen Ergebnis der Listenname ist.
* Es wird auch ueberprueft ob die Datei bereits
* geladen ist.
* Args:
* selectorTitle .. Der Titel der Dateiauswahl
* existMsg .. Der Text der in dem Dialog
* Angezeigt wird, der mitteilt,
* das die Datei bereits geladen
* ist und fragt ob sie neu geladen
* werden soll.
* type .. Legt Fest ob es ein "Oeffnen" Dialog
* (zum oeffnen existierender Listen)
* oder ein "Speichern" Dialog (zum
* anlegen neuer Listen) sein soll.
* Ret:
* Nichts
* */
void fetchNewListFile(char *selectorTitle, char *existMsg, int type){
GtkWidget *fileSel;
char *filename;
fileSel = gtk_file_chooser_dialog_new (selectorTitle,
(GtkWindow*)main_app_window,
type,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if (gtk_dialog_run (GTK_DIALOG (fileSel)) == GTK_RESPONSE_ACCEPT){
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileSel));
if (getPhoneList(filename) == NULL){
if (type == GTK_FILE_CHOOSER_ACTION_SAVE){
newPhoneFile(filename);
}
if(pushPhoneList(readPhoneFile(filename), filename) == OK){
addPhoneModelList(filename);
addListsListElm(filename);
}
} else {
if(askYesNo(existMsg)){
closeListByName(filename, NULL);
if(pushPhoneList(readPhoneFile(filename), filename) == OK){
addPhoneModelList(filename);
addListsListElm(filename);
}
}
}
GtkTreeIter iter = getIterByFilename(filename);
if(gtk_list_store_iter_is_valid(listsListStore, &iter)){
gtk_tree_selection_select_iter(listsListSel, &iter);
}
g_free (filename);
}
gtk_widget_destroy (fileSel);
}
static void
window_active_tab_changed (PlumaWindow *window,
PlumaTab *tab,
PlumaDocumentsPanel *panel)
{
g_return_if_fail (tab != NULL);
if (!_pluma_window_is_removing_tabs (window))
{
GtkTreeIter iter;
GtkTreeSelection *selection;
get_iter_from_tab (panel, tab, &iter);
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (panel->priv->model),
&iter))
{
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (panel->priv->treeview));
gtk_tree_selection_select_iter (selection, &iter);
}
}
}
gboolean del_line(IMAGE *ima){
GtkTreeIter iter;
GtkTreeModel *model = GTK_TREE_MODEL(ima->store);
gboolean ret = FALSE;
FNAME();
GtkTreeSelection *selection = gtk_tree_view_get_selection(Tree);
GtkTreePath *path;
if(gtk_tree_selection_get_selected(selection, NULL, &iter)){
path = gtk_tree_model_get_path(model, &iter);
ret = gtk_list_store_remove(ima->store, &iter);
// check wherher &cur_items was last
if(gtk_list_store_iter_is_valid(ima->store, &iter)){
gtk_tree_path_free(path);
path = gtk_tree_model_get_path(model, &iter);
}
else gtk_tree_path_prev(path); // goto previous
if(path && gtk_tree_model_get_iter_first(model, &iter))
gtk_tree_view_set_cursor(Tree, path, NULL, FALSE);
else DBG("No entries");
gtk_tree_path_free(path);
}
DBG("ret");
return ret;
}
void
on_trkproperties_crop_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
if (!gtk_widget_is_focus(GTK_WIDGET (treeview))) {
return; // do not remove field if Metadata tab is not focused
}
GtkTreePath *path;
gtk_tree_view_get_cursor (treeview, &path, NULL);
if (!path) {
return;
}
GtkTreeIter iter_curr;
gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter_curr, path);
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreeIter iter;
GtkTreeIter next;
gboolean res = gtk_tree_model_get_iter_first (model, &iter);
while (res) {
int getnext = 1;
GtkTreePath *iter_path = gtk_tree_model_get_path (model, &iter);
if (gtk_tree_path_compare (path, iter_path)) {
GValue key = {0,};
gtk_tree_model_get_value (model, &iter, 2, &key);
const char *skey = g_value_get_string (&key);
GValue value = {0,};
gtk_tree_model_get_value (GTK_TREE_MODEL (store), &iter, 2, &value);
const char *svalue = g_value_get_string (&value);
// delete unknown fields completely; otherwise just clear
int i = 0;
for (; trkproperties_types[i]; i += 2) {
if (!strcasecmp (svalue, trkproperties_types[i])) {
break;
}
}
if (trkproperties_types[i]) { // known val, clear
gtk_list_store_set (store, &iter, 1, "", 3, 0, 4, "", -1);
}
else {
gtk_list_store_remove (store, &iter);
getnext = 0;
if (!gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)) {
res = 0;
}
}
}
gtk_tree_path_free (iter_path);
if (getnext) {
res = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
}
}
gtk_tree_view_set_cursor (treeview, path, NULL, FALSE); // restore cursor after deletion
gtk_tree_path_free (path);
trkproperties_modified = 1;
}
/* Sets up the charsets to choose from in the "combo". It presets the
charset stored in cfg->charset (or "System Charset" if none is set
there */
void charset_init_combo_box (GtkComboBox *combo)
{
gchar *current_charset;
gchar *description;
const CharsetInfo *ci;
GtkCellRenderer *renderer;
GtkTreeIter use_iter;
static GtkListStore *charsets = NULL; /* list with choices -- takes a while to
* initialize, so we only do it once */
current_charset = prefs_get_string("charset");
if ((current_charset == NULL) || (strlen (current_charset) == 0))
{
description = g_strdup (_("System Charset"));
}
else
{
description = charset_to_description (current_charset);
}
if (charsets == NULL)
{ /* set up list with charsets */
FILE *fp;
GtkTreeIter iter;
charsets = gtk_list_store_new (1, G_TYPE_STRING);
/* now add all the charset descriptions in the list above */
gtk_list_store_append (charsets, &iter);
gtk_list_store_set (charsets, &iter, 0, _("System Charset"), -1);
for (ci = charset_info; ci->descr; ci++)
{
gtk_list_store_append (charsets, &iter);
gtk_list_store_set (charsets, &iter, 0, _(ci->descr), -1);
}
/* let's add all available charsets returned by "iconv -l" */
/* The code assumes that "iconv -l" returns a list with the
name of one charset in each line, each valid line being
terminated by "//". */
fp = popen ("iconv -l", "r");
if (fp)
{
gchar buf[PATH_MAX];
/* read one line of output at a time */
while (fgets (buf, PATH_MAX, fp))
{
/* only consider lines ending on "//" */
gchar *bufp = g_strrstr (buf, "//\n");
if (bufp)
{
/* add everything before "//" to our charset list */
gchar *bufpp = buf;
*bufp = 0; /* shorten string */
while ((*bufpp == ' ') || (*bufpp == 0x09))
bufpp++; /* skip whitespace */
if (*bufpp)
{
gtk_list_store_append (charsets, &iter);
gtk_list_store_set (charsets, &iter, 0, bufpp, -1);
}
}
}
pclose (fp);
}
}
/* set pull down items */
renderer = gtk_cell_renderer_text_new ();
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (charsets));
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 0);
for (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (charsets), &use_iter);
gtk_list_store_iter_is_valid (charsets, &use_iter);
gtk_tree_model_iter_next (GTK_TREE_MODEL (charsets), &use_iter))
{
gchar *cur_desc;
gtk_tree_model_get (GTK_TREE_MODEL (charsets), &use_iter, 0, &cur_desc, -1);
if(!g_utf8_collate(description, cur_desc))
{
g_free (cur_desc);
break;
}
g_free (cur_desc);
}
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &use_iter);
g_free (description);
g_free (current_charset);
}
static VALUE
rg_iter_is_valid_p(VALUE self, VALUE iter)
{
return (NIL_P(iter)) ? Qfalse :
CBOOL2RVAL(gtk_list_store_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
}
gint play_iter(GtkTreeIter * playiter, gint restart_second)
{
gchar *subtitle = NULL;
gchar *audiofile = NULL;
GtkTreePath *path;
gchar *uri = NULL;
gint count;
gint playlist;
gchar *title = NULL;
gchar *artist = NULL;
gchar *album = NULL;
gchar *audio_codec;
gchar *video_codec = NULL;
GtkAllocation alloc;
gchar *demuxer = NULL;
gboolean playable = TRUE;
gint width;
gint height;
gfloat length_value;
gint i;
gpointer pixbuf;
gchar *buffer = NULL;
gchar *message = NULL;
MetaData *metadata;
#ifdef GTK2_12_ENABLED
GtkRecentData *recent_data;
#ifdef GIO_ENABLED
GFile *file;
GFileInfo *file_info;
#endif
#endif
/*
if (!(gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_UNKNOWN ||
gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_QUIT)) {
while (gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) != MEDIA_STATE_UNKNOWN) {
gtk_main_iteration();
}
}
*/
if (gtk_list_store_iter_is_valid(playliststore, playiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, ITEM_COLUMN, &uri,
DESCRIPTION_COLUMN, &title, LENGTH_VALUE_COLUMN, &length_value,
ARTIST_COLUMN, &artist,
ALBUM_COLUMN, &album,
AUDIO_CODEC_COLUMN, &audio_codec,
VIDEO_CODEC_COLUMN, &video_codec,
VIDEO_WIDTH_COLUMN, &width,
VIDEO_HEIGHT_COLUMN, &height,
DEMUXER_COLUMN, &demuxer,
COVERART_COLUMN, &pixbuf,
SUBTITLE_COLUMN, &subtitle,
AUDIOFILE_COLUMN, &audiofile,
COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, PLAYABLE_COLUMN, &playable, -1);
if (GTK_IS_TREE_SELECTION(selection)) {
path = gtk_tree_model_get_path(GTK_TREE_MODEL(playliststore), playiter);
if (path) {
gtk_tree_selection_select_path(selection, path);
if (GTK_IS_WIDGET(list))
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list), path, NULL, FALSE, 0, 0);
buffer = gtk_tree_path_to_string(path);
g_free(buffer);
gtk_tree_path_free(path);
}
}
gtk_list_store_set(playliststore, playiter, COUNT_COLUMN, count + 1, -1);
} else {
if (verbose > 1)
printf("iter is invalid, nothing to play\n");
return 0;
}
if (verbose) {
printf("playing - %s\n", uri);
printf("is playlist %i\n", playlist);
}
gmtk_get_allocation(GTK_WIDGET(media), &alloc);
if (width == 0 || height == 0) {
alloc.width = 16;
alloc.height = 16;
} else {
alloc.width = width;
alloc.height = height;
}
//printf("setting window size to %i x %i\n", alloc.width, alloc.height);
gtk_widget_size_allocate(GTK_WIDGET(media), &alloc);
while (gtk_events_pending())
gtk_main_iteration();
/*
// wait for metadata to be available on this item
if (!streaming_media(uri) && !device_name(uri)) {
i = 0;
if (playable) {
while (demuxer == NULL && i < 50) {
g_free(title);
g_free(artist);
g_free(album);
g_free(audio_codec);
g_free(video_codec);
g_free(demuxer);
g_free(subtitle);
g_free(audiofile);
if (gtk_list_store_iter_is_valid(playliststore, playiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, LENGTH_VALUE_COLUMN,
&length_value, DESCRIPTION_COLUMN, &title, ARTIST_COLUMN,
&artist, ALBUM_COLUMN, &album, AUDIO_CODEC_COLUMN,
&audio_codec, VIDEO_CODEC_COLUMN, &video_codec,
VIDEO_WIDTH_COLUMN, &width, VIDEO_HEIGHT_COLUMN, &height,
DEMUXER_COLUMN, &demuxer, COVERART_COLUMN, &pixbuf,
SUBTITLE_COLUMN, &subtitle, AUDIOFILE_COLUMN, &audiofile,
COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist,
PLAYABLE_COLUMN, &playable, -1);
if (!playable) {
if (verbose)
printf("%s is not marked as playable (%i)\n", uri, i);
play_next();
return 0;
}
} else {
if (verbose)
printf("Current iter is not valid\n");
return 1; // error condition
}
gtk_main_iteration();
i++;
if (demuxer == NULL)
g_usleep(10000);
}
} else {
if (verbose)
printf("%s is not marked as playable\n", uri);
play_next();
return 0;
}
}
*/
// reset audio meter
for (i = 0; i < METER_BARS; i++) {
buckets[i] = 0;
max_buckets[i] = 0;
}
gmtk_media_tracker_set_text(tracker, _("Playing"));
gmtk_media_tracker_set_position(tracker, (gfloat) restart_second);
gmtk_media_tracker_set_length(tracker, length_value);
message = g_strdup_printf("<small>\n");
if (title == NULL) {
title = g_filename_display_basename(uri);
}
buffer = g_markup_printf_escaped("\t<big><b>%s</b></big>\n", title);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
if (artist != NULL) {
buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
if (album != NULL) {
buffer = g_markup_printf_escaped("\t%s\n", album);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
//buffer = g_markup_printf_escaped("\n\t%s\n", uri);
//message = g_strconcat(message, buffer, NULL);
//g_free(buffer);
message = g_strconcat(message, "</small>", NULL);
// probably not much cover art for random video files
if (pixbuf == NULL && video_codec == NULL && !streaming_media(uri) && control_id == 0 && !playlist) {
metadata = (MetaData *) g_new0(MetaData, 1);
metadata->uri = g_strdup(uri);
if (title != NULL)
metadata->title = g_strstrip(g_strdup(title));
if (artist != NULL)
metadata->artist = g_strstrip(g_strdup(artist));
if (album != NULL)
metadata->album = g_strstrip(g_strdup(album));
g_thread_create(get_cover_art, metadata, FALSE, NULL);
} else {
gtk_image_clear(GTK_IMAGE(cover_art));
}
g_strlcpy(idledata->media_info, message, 1024);
g_strlcpy(idledata->display_name, title, 1024);
g_free(message);
message = gm_tempname(NULL, "mplayer-af_exportXXXXXX");
g_strlcpy(idledata->af_export, message, 1024);
g_free(message);
message = g_strdup("");
if (title == NULL) {
title = g_filename_display_basename(uri);
}
//buffer = g_markup_printf_escaped("\t<b>%s</b>\n", title);
//message = g_strconcat(message, buffer, NULL);
//g_free(buffer);
if (artist != NULL) {
buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
if (album != NULL) {
buffer = g_markup_printf_escaped("\t%s\n", album);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
g_strlcpy(idledata->media_notification, message, 1024);
g_free(message);
if (control_id == 0) {
set_media_label(idledata);
} else {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_info), FALSE);
}
if (subtitles)
gtk_container_forall(GTK_CONTAINER(subtitles), remove_langs, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_sub_lang), FALSE);
if (tracks)
gtk_container_forall(GTK_CONTAINER(tracks), remove_langs, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_audio_lang), FALSE);
lang_group = NULL;
audio_group = NULL;
if (subtitle != NULL) {
gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_SUBTITLE_FILE, subtitle);
g_free(subtitle);
subtitle = NULL;
}
if (audiofile != NULL) {
gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_AUDIO_TRACK_FILE, audiofile);
g_free(audiofile);
audiofile = NULL;
}
/*
if (g_ascii_strcasecmp(thread_data->filename, "") != 0) {
if (!device_name(thread_data->filename) && !streaming_media(thread_data->filename)) {
if (!g_file_test(thread_data->filename, G_FILE_TEST_EXISTS)) {
error_msg = g_strdup_printf("%s not found\n", thread_data->filename);
dialog =
gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", error_msg);
gtk_window_set_title(GTK_WINDOW(dialog), "GNOME MPlayer Error");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return 1;
}
}
}
*/
#ifdef GTK2_12_ENABLED
#ifdef GIO_ENABLED
// don't put it on the recent list, if it is running in plugin mode
if (control_id == 0 && !streaming_media(uri)) {
recent_data = (GtkRecentData *) g_new0(GtkRecentData, 1);
if (artist != NULL && strlen(artist) > 0) {
recent_data->display_name = g_strdup_printf("%s - %s", artist, title);
} else {
recent_data->display_name = g_strdup(title);
}
g_strlcpy(idledata->display_name, recent_data->display_name, 1024);
file = g_file_new_for_uri(uri);
file_info = g_file_query_info(file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (file_info) {
recent_data->mime_type = g_strdup(g_file_info_get_content_type(file_info));
g_object_unref(file_info);
}
g_object_unref(file);
recent_data->app_name = g_strdup("gnome-mplayer");
recent_data->app_exec = g_strdup("gnome-mplayer %u");
if (recent_data->mime_type != NULL) {
gtk_recent_manager_add_full(recent_manager, uri, recent_data);
g_free(recent_data->mime_type);
}
g_free(recent_data->app_name);
g_free(recent_data->app_exec);
g_free(recent_data);
}
#endif
#endif
g_free(title);
g_free(artist);
g_free(album);
if (demuxer != NULL) {
g_strlcpy(idledata->demuxer, demuxer, 64);
g_free(demuxer);
} else {
g_strlcpy(idledata->demuxer, "", 64);
}
last_x = 0;
last_y = 0;
idledata->width = width;
idledata->height = height;
idledata->retry_on_full_cache = FALSE;
idledata->cachepercent = -1.0;
g_strlcpy(idledata->info, uri, 1024);
set_media_info(idledata);
streaming = 0;
gm_store = gm_pref_store_new("gnome-mplayer");
forcecache = gm_pref_store_get_boolean(gm_store, FORCECACHE);
gm_pref_store_free(gm_store);
if (g_ascii_strcasecmp(uri, "dvdnav://") == 0) {
gtk_widget_show(menu_event_box);
} else {
gtk_widget_hide(menu_event_box);
}
if (autostart) {
g_idle_add(hide_buttons, idledata);
js_state = STATE_PLAYING;
if (g_str_has_prefix(uri, "mmshttp") || g_str_has_prefix(uri, "http") || g_str_has_prefix(uri, "mms")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK);
} else if (g_str_has_prefix(uri, "dvd") || g_str_has_prefix(uri, "dvdnav")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD);
} else if (g_str_has_prefix(uri, "cdda")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD);
} else if (g_str_has_prefix(uri, "cddb")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD);
} else if (g_str_has_prefix(uri, "vcd")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_VCD);
} else if (g_str_has_prefix(uri, "tv")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_TV);
} else if (g_str_has_prefix(uri, "dvb")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVB);
} else if (g_str_has_prefix(uri, "file")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_FILE);
} else {
// if all else fails it must be a network type
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK);
}
gmtk_media_player_set_attribute_boolean(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_PLAYLIST, playlist);
gmtk_media_player_set_uri(GMTK_MEDIA_PLAYER(media), uri);
gmtk_media_player_set_state(GMTK_MEDIA_PLAYER(media), MEDIA_STATE_PLAY);
}
return 0;
}
static void
window_tab_added (PlumaWindow *window,
PlumaTab *tab,
PlumaDocumentsPanel *panel)
{
GtkTreeIter iter;
GtkTreeIter sibling;
GdkPixbuf *pixbuf;
gchar *name;
g_signal_connect (tab,
"notify::name",
G_CALLBACK (sync_name_and_icon),
panel);
g_signal_connect (tab,
"notify::state",
G_CALLBACK (sync_name_and_icon),
panel);
get_iter_from_tab (panel, tab, &sibling);
panel->priv->adding_tab = TRUE;
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (panel->priv->model),
&sibling))
{
gtk_list_store_insert_after (GTK_LIST_STORE (panel->priv->model),
&iter,
&sibling);
}
else
{
PlumaTab *active_tab;
gtk_list_store_append (GTK_LIST_STORE (panel->priv->model),
&iter);
active_tab = pluma_window_get_active_tab (panel->priv->window);
if (tab == active_tab)
{
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (panel->priv->treeview));
gtk_tree_selection_select_iter (selection, &iter);
}
}
name = tab_get_name (tab);
pixbuf = _pluma_tab_get_icon (tab);
gtk_list_store_set (GTK_LIST_STORE (panel->priv->model),
&iter,
PIXBUF_COLUMN, pixbuf,
NAME_COLUMN, name,
TAB_COLUMN, tab,
-1);
g_free (name);
if (pixbuf != NULL)
g_object_unref (pixbuf);
panel->priv->adding_tab = FALSE;
}
