static void
_gtk_user_list_dialog_append_node(GtkWidget *tree, const gchar *username, GdkPixbuf *pixbuf, gboolean checked)
{
GtkTreeModel *model;
GtkListStore *store;
GtkTreeIter iter;
g_assert(GTK_IS_TREE_VIEW(tree));
model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(gtk_tree_view_get_model(GTK_TREE_VIEW(tree))));
store = GTK_LIST_STORE(model);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store,
&iter,
GTK_USER_LIST_TREEVIEW_COLUMN_CHECKBOX,
checked,
GTK_USER_LIST_TREEVIEW_COLUMN_USERNAME,
username,
GTK_USER_LIST_TREEVIEW_COLUMN_PIXBUF,
pixbuf,
-1);
}
static void
gnc_sx_list_tree_model_adapter_init(GTypeInstance *instance, gpointer klass)
{
GncSxListTreeModelAdapter *adapter = GNC_SX_LIST_TREE_MODEL_ADAPTER(instance);
adapter->orig = gtk_tree_store_new(5, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
adapter->real = GTK_TREE_MODEL_SORT(gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(adapter->orig)));
// setup sorting
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NAME, _name_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_ENABLED, _enabled_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_FREQUENCY, _freq_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_LAST_OCCUR, _last_occur_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NEXT_OCCUR, _next_occur_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NEXT_OCCUR, GTK_SORT_ASCENDING);
g_signal_connect(adapter->real, "row-changed", G_CALLBACK(gsltma_proxy_row_changed), adapter);
g_signal_connect(adapter->real, "row-deleted", G_CALLBACK(gsltma_proxy_row_deleted), adapter);
g_signal_connect(adapter->real, "row-has-child-toggled", G_CALLBACK(gsltma_proxy_row_has_child_toggled), adapter);
g_signal_connect(adapter->real, "row-inserted", G_CALLBACK(gsltma_proxy_row_inserted), adapter);
g_signal_connect(adapter->real, "rows-reordered", G_CALLBACK(gsltma_proxy_rows_reordered), adapter);
g_signal_connect(adapter->real, "sort-column-changed", G_CALLBACK(gsltma_proxy_sort_column_changed), adapter);
}
static void
showed_message_cb (GtrTab * tab, GtrMsg * msg, GtrMessageTable * table)
{
GtkTreePath *path;
GtkTreeSelection *selection;
GtkTreeIter iter, child_iter;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table->priv->treeview));
gtr_message_table_get_message_iter (table->priv->store, msg, &child_iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT
(table->
priv->sort_model),
&iter, &child_iter);
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (table->priv->sort_model, &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (table->priv->treeview),
path, NULL, TRUE, 0.5, 0.0);
gtk_tree_path_free (path);
}
static void
path_toggled (GtkTreeModel *dummy_model, GtkTreePath *path,
GtkTreeIter *dummy, gpointer data)
{
EphyNodeView *view = EPHY_NODE_VIEW (data);
gboolean checked;
EphyNode *node;
GtkTreeIter iter, iter2;
GValue value = {0, };
gtk_tree_model_get_iter (view->priv->sortmodel, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter
(GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter2, &iter);
gtk_tree_model_filter_convert_iter_to_child_iter
(GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter, &iter2);
node = ephy_tree_model_node_node_from_iter (view->priv->nodemodel, &iter);
gtk_tree_model_get_value (GTK_TREE_MODEL (view->priv->nodemodel), &iter,
view->priv->toggle_column, &value);
checked = !g_value_get_boolean (&value);
g_signal_emit (G_OBJECT (view), ephy_node_view_signals[NODE_TOGGLED], 0,
node, checked);
}
static void
theme_delete_cb (GtkWidget *button, AppearanceData *data)
{
GtkIconView *icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list"));
GList *selected = gtk_icon_view_get_selected_items (icon_view);
if (selected) {
GtkTreePath *path = selected->data;
GtkTreeModel *model = gtk_icon_view_get_model (icon_view);
GtkTreeIter iter;
gchar *name = NULL;
if (gtk_tree_model_get_iter (model, &iter, path))
gtk_tree_model_get (model, &iter, COL_NAME, &name, -1);
if (name != NULL &&
strcmp (name, data->theme_custom->name) &&
theme_delete (name, THEME_TYPE_META)) {
/* remove theme from the model, too */
GtkTreeIter child;
if (gtk_tree_model_iter_next (model, &iter) ||
theme_model_iter_last (model, &iter))
theme_select_iter (icon_view, &iter);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (model), &child, &iter);
gtk_list_store_remove (data->theme_store, &child);
}
g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
g_list_free (selected);
g_free (name);
}
}
static void
update_thumbnail_in_treeview (const gchar *tv_name,
const gchar *theme_name,
GdkPixbuf *theme_thumbnail,
AppearanceData *data)
{
GtkTreeView *treeview;
GtkListStore *model;
GtkTreeIter iter;
if (theme_thumbnail == NULL)
return;
treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
model = GTK_LIST_STORE (
gtk_tree_model_sort_get_model (
GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (treeview))));
if (theme_find_in_model (GTK_TREE_MODEL (model), theme_name, &iter)) {
gtk_list_store_set (model, &iter,
COL_THUMBNAIL, theme_thumbnail,
-1);
}
}
static void
project_root_added (AnjutaPlugin *plugin, const gchar *name,
const GValue *value, gpointer user_data)
{
AnjutaFileManager* file_manager;
GtkTreeModelSort *tree_model;
FileModel *file_model;
const gchar *root_uri;
file_manager = (AnjutaFileManager*) plugin;
tree_model = GTK_TREE_MODEL_SORT (
gtk_tree_view_get_model (GTK_TREE_VIEW (file_manager->fv)));
file_model = FILE_MODEL (gtk_tree_model_sort_get_model (tree_model));
root_uri = g_value_get_string (value);
if (root_uri)
{
GFile *base_path;
base_path = g_file_new_for_uri (root_uri);
g_object_set (G_OBJECT(file_manager->fv), "base-path", base_path, NULL);
g_object_unref (base_path);
file_model_set_ivcs (file_model, get_vcs_plugin (file_manager,
root_uri));
file_view_refresh (file_manager->fv);
file_manager->have_project = TRUE;
}
else
{
file_model_set_ivcs(file_model, NULL);
file_manager_set_default_uri (file_manager);
file_view_refresh (file_manager->fv);
}
}
void
tasks_item_entered_cb (GtkWidget *widget, gpointer data) {
GtkTextBuffer *text_buffer;
GtkTextIter iter_a, iter_b;
GtkTreePath *sort_path, *filter_path, *path;
GtkTreeIter iter;
guint32 fstartdate;
GUI *appGUI = (GUI *)data;
if (appGUI->tsk->tasks_edit_state == TRUE) {
gtk_tree_view_get_cursor (GTK_TREE_VIEW (appGUI->tsk->tasks_list), &sort_path, NULL);
if (sort_path != NULL) {
filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT(appGUI->tsk->tasks_sort), sort_path);
if (filter_path != NULL) {
path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), filter_path);
if (path != NULL) {
gtk_tree_model_get_iter(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), &iter, path);
gtk_tree_model_get (GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), &iter,
COLUMN_START_DATE_JULIAN, &fstartdate, -1);
gtk_list_store_remove(appGUI->tsk->tasks_list_store, &iter);
gtk_tree_path_free(path);
}
gtk_tree_path_free(filter_path);
}
gtk_tree_path_free(sort_path);
}
}
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->desc_textview));
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(text_buffer), &iter_a, 0);
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(text_buffer), &iter_b, -1);
if(appGUI->tsk->tasks_edit_state == TRUE) {
add_item_to_list(FALSE,
appGUI->tsk->tasks_due_julian_day,
fstartdate,
gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->priority_combobox)),
gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->category_combobox)),
(gchar *) gtk_entry_get_text(GTK_ENTRY(appGUI->tsk->summary_entry)),
gtk_text_buffer_get_text(GTK_TEXT_BUFFER(text_buffer), &iter_a, &iter_b, TRUE), appGUI);
} else {
add_item_to_list(FALSE,
appGUI->tsk->tasks_due_julian_day,
get_julian_for_today(),
gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->priority_combobox)),
gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->category_combobox)),
(gchar *) gtk_entry_get_text(GTK_ENTRY(appGUI->tsk->summary_entry)),
gtk_text_buffer_get_text(GTK_TEXT_BUFFER(text_buffer), &iter_a, &iter_b, TRUE), appGUI);
}
gtk_widget_destroy(appGUI->tsk->tasks_add_window);
update_n_items(appGUI);
tasks_select_first_position_in_list(appGUI);
g_signal_emit_by_name(G_OBJECT(appGUI->cal->calendar), "day-selected");
}
int add_cr_list_items_GTK(int index, GtkTreeView *tree_view_to_add,
struct chara_real_clist *cr_clist)
{
GtkTreeModel *model_to_add;
GtkTreeModel *child_model_to_add;
GtkTreeSelection *selection;
GList *list;
GList *reference_list;
GList *cur;
gchar *field_name;
gchar *field_math;
int index_field;
double value;
/* 選択されている行のパスを取得する */
/* パスはツリーモデルソートのもの */
model_to_add = gtk_tree_view_get_model(tree_view_to_add);
child_model_to_add = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_to_add));
selection = gtk_tree_view_get_selection(tree_view_to_add);
list = gtk_tree_selection_get_selected_rows(selection, NULL);
/* 最初にパスからリファレンスを作成する */
/* データの削除を行なうと取得済みのパスが(大抵の場合)無効になる */
reference_list = NULL;
for (cur = g_list_first(list); cur != NULL; cur = g_list_next(cur)) {
GtkTreePath *child_path;
GtkTreeRowReference *child_reference;
/* ツリーモデルソートのパスをツリーモデルのパスに変換する */
child_path = gtk_tree_model_sort_convert_path_to_child_path(GTK_TREE_MODEL_SORT(model_to_add),
(GtkTreePath *)cur->data);
child_reference = gtk_tree_row_reference_new(child_model_to_add, child_path);
reference_list = g_list_append(reference_list, child_reference);
gtk_tree_path_free(child_path);
gtk_tree_path_free((GtkTreePath *)cur->data);
}
g_list_free(list);
/* GtkTreeSelectionのchangedシグナルを一時的にブロックする */
block_changed_signal(G_OBJECT(child_model_to_add));
/* リファレンスをパスに戻して削除 */
GtkTreePath *tree_path;
GtkTreeIter iter;
cur = g_list_first(reference_list);
tree_path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)cur->data);
gtk_tree_model_get_iter(child_model_to_add, &iter, tree_path);
gtk_tree_model_get(child_model_to_add, &iter, COLUMN_FIELD_NAME, &field_name, -1);
for (cur = g_list_first(reference_list); cur != NULL; cur = g_list_next(cur)) {
/* Add */
gchar row_string[30] = "new_number";
gchar math_string[30] = "$$ $$";
double value = 0.0;
add_chara_real_clist_before_c_tbl(field_name, row_string, value, cr_clist);
gtk_tree_row_reference_free((GtkTreeRowReference *)cur->data);
}
gtk_tree_path_free(tree_path);
g_list_free(reference_list);
gtk_list_store_clear(child_model_to_add);
append_cr_list_from_ctl(index, &cr_clist->cr_item_head, tree_view_to_add);
/* changedシグナルのブロックを解除する */
unblock_changed_signal(G_OBJECT(child_model_to_add));
return index;
}
static GtkWidget *create_field_selection_box(struct field_views *fields_vws, GtkWidget *window)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *scrolled_window;
GtkWidget *combobox_field;
GtkWidget *combobox_comp;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeModel *child_model;
gulong changed_handler_id;
GList *list;
GtkWidget *expander;
GtkWidget *hbox_1, *vbox_1, *Frame_1;
GtkWidget *label_1;
GtkWidget *scrolled_window_1;
GtkWidget *hbox_11;
GtkTreeSelection *selection_1;
GtkTreeModel *model_1;
GtkTreeModel *child_model_1;
gulong changed_handler_id_1;
GList *list_1;
GtkCellRenderer *column;
char *c_label;
c_label = (char *)calloc(KCHARA_C, sizeof(char));
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* Delete data bottun */
button = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(remove_field_to_use), fields_vws);
/* Close window bottun */
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(cb_close_window), window);
/* ラベル */
label = gtk_label_new("");
gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 0);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(scrolled_window, 400, 300);
gtk_container_add(GTK_CONTAINER(scrolled_window), fields_vws->used_tree_view);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
/*
* selectionにchangedシグナルハンドラを登録する。
* 後で同じchild_modelを使用しているselectionのchangedシグナルをブロック出来るように
* child_modelにselectionのリストを、selectionにシグナルハンドラIDを登録する。
* changedハンドラ内で使用するlabelも同様に登録しておく。
*/
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(fields_vws->used_tree_view));
changed_handler_id = g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(sum_selected_rows), NULL);
g_object_set_data(G_OBJECT(selection), "changed_handler_id", GUINT_TO_POINTER(changed_handler_id));
g_object_set_data(G_OBJECT(selection), "label", label);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(fields_vws->used_tree_view));
child_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
list = g_object_get_data(G_OBJECT(child_model), "selection_list");
list = g_list_append(list, selection);
g_object_set_data(G_OBJECT(child_model), "selection_list", list);
get_label_MHD_control_head(c_label);
expander = gtk_expander_new_with_mnemonic("Field to add");
vbox_1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
Frame_1 = gtk_frame_new("");
gtk_frame_set_shadow_type(GTK_FRAME(Frame_1), GTK_SHADOW_IN);
scrolled_window_1 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window_1),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// gtk_widget_set_size_request(scrolled_window_1, 400, 300);
gtk_container_add(GTK_CONTAINER(scrolled_window_1), fields_vws->unused_field_tree_view);
gtk_box_pack_start(GTK_BOX(vbox_1), scrolled_window_1, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(Frame_1), vbox_1);
/* Add data bottun */
hbox_1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
button = gtk_button_new_from_stock(GTK_STOCK_ADD);
gtk_box_pack_start(GTK_BOX(hbox_1), button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(add_field_to_use), fields_vws);
label_1 = gtk_label_new("");
gtk_box_pack_end(GTK_BOX(hbox_1), label_1, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox_1), gtk_label_new(" "), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_1), Frame_1, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(expander), hbox_1);
gtk_box_pack_start(GTK_BOX(vbox), expander, TRUE, TRUE, 0);
selection_1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(fields_vws->unused_field_tree_view));
changed_handler_id_1 = g_signal_connect(G_OBJECT(selection_1), "changed",
G_CALLBACK(sum_selected_rows), NULL);
g_object_set_data(G_OBJECT(selection_1), "changed_handler_id", GUINT_TO_POINTER(changed_handler_id_1));
g_object_set_data(G_OBJECT(selection_1), "label", label_1);
model_1 = gtk_tree_view_get_model(GTK_TREE_VIEW(fields_vws->unused_field_tree_view));
child_model_1 = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_1));
list_1 = g_object_get_data(G_OBJECT(child_model_1), "selection_list");
list_1 = g_list_append(list_1, selection_1);
g_object_set_data(G_OBJECT(child_model_1), "selection_list", list_1);
hbox_11 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
combobox_field = gtk_combo_box_new_with_model(model);
g_signal_connect(G_OBJECT(combobox_field), "changed",
G_CALLBACK(format_entry_text_callback), fields_vws->used_tree_view);
column = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_field), column, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_field), column,
"text", COLUMN_FIELD_NAME, NULL);
gtk_box_pack_start(GTK_BOX(hbox_11), combobox_field, FALSE, FALSE, 0);
combobox_comp = gtk_combo_box_new();
g_signal_connect(G_OBJECT(combobox_comp), "changed",
G_CALLBACK(format_entry_text_callback), fields_vws->used_tree_view);
column = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_comp), column, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_comp), column,
"text", COLUMN_FIELD_NAME, NULL);
gtk_box_pack_start(GTK_BOX(hbox_11), combobox_comp, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox_11, FALSE, FALSE, 0);
return vbox;
}
static void
on_delete_clicked (GtkWidget *button, MokoHistory *history)
{
MokoHistoryPrivate *priv;
GtkWidget *dialog;
GtkTreeIter iter0;
GtkTreeIter iter1;
GtkTreeIter iter2;
GtkTreeModel *filtered;
GtkTreeModel *sorted;
GtkTreeModel *store;
GtkTreeSelection *selection;
GtkTreeView *treeview;
GtkTreePath *path;
const gchar *uid;
gint result = 0;
g_return_if_fail (MOKO_IS_HISTORY (history));
priv = history->priv;
treeview = GTK_TREE_VIEW (priv->treeview);
selection = gtk_tree_view_get_selection (treeview);
if (!gtk_tree_selection_get_selected (selection, &filtered, &iter0))
return;
gtk_tree_model_get (filtered, &iter0, ENTRY_POINTER_COLUMN, &uid, -1);
/* Create a dialog */
dialog = gtk_message_dialog_new (GTK_WINDOW (
gtk_widget_get_ancestor(GTK_WIDGET (history),
GTK_TYPE_WINDOW)),
0,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"Are you sure you want to permanantly delete this call?"
);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
"Don't Delete", GTK_RESPONSE_CANCEL,
GTK_STOCK_DELETE, GTK_RESPONSE_YES,
NULL);
gtk_widget_set_name (dialog, "mokomessagedialog");
gtk_container_set_border_width (GTK_CONTAINER (dialog), 0);
/* Just some tests
gtk_widget_set_size_request (dialog,
GTK_WIDGET (history)->allocation.width,
GTK_WIDGET (history)->allocation.height);
gtk_window_move (GTK_WINDOW (dialog),
GTK_WIDGET (history)->allocation.x,
GTK_WIDGET (history)->allocation.y);
*/
result = gtk_dialog_run (GTK_DIALOG (dialog));
switch (result)
{
case GTK_RESPONSE_YES:
break;
default:
gtk_widget_destroy (dialog);
return;
break;
}
/* Remove the entry from the journal */
if (moko_journal_remove_entry_by_uid (priv->journal, uid))
moko_journal_write_to_storage (priv->journal);
/* Remove the row from the list store */
path = gtk_tree_model_get_path (filtered, &iter0);
sorted = priv->sort_model;
gtk_tree_model_filter_convert_iter_to_child_iter (
GTK_TREE_MODEL_FILTER (filtered),
&iter1, &iter0);
store = priv->main_model;
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sorted),
&iter2, &iter1);
gtk_list_store_remove (GTK_LIST_STORE (store), &iter2);
gtk_tree_view_set_cursor (treeview, path, 0, 0);
/* Clean up */
gtk_tree_path_free (path);
gtk_widget_destroy (dialog);
}
static void
rejilla_split_dialog_merge_clicked_cb (GtkButton *button,
RejillaSplitDialog *self)
{
RejillaSplitDialogPrivate *priv;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (self);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree));
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
do {
guint64 end;
guint64 start;
gchar *end_str;
gchar *start_str;
GtkTreeIter next;
gchar *length_str;
GtkTreeIter child;
if (!gtk_tree_selection_iter_is_selected (selection, &iter))
continue;
next = iter;
if (!gtk_tree_model_iter_next (model, &next))
continue;
if (!gtk_tree_selection_iter_is_selected (selection, &next))
continue;
gtk_tree_model_get (model, &iter,
START_COL, &start,
-1);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child,
&iter);
do {
GtkTreeIter next_child;
gtk_tree_model_get (model, &next,
END_COL, &end,
-1);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&next_child,
&next);
if (!gtk_list_store_remove (priv->model, &next_child))
break;
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (model),
&next,
&next_child);
} while (gtk_tree_selection_iter_is_selected (selection, &next));
length_str = rejilla_units_get_time_string (end - start, TRUE, FALSE);
start_str = rejilla_units_get_time_string (start, TRUE, FALSE);
end_str = rejilla_units_get_time_string (end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, (gint64) start,
END_COL, (gint64) end,
LENGTH_COL, (gint64) end - start,
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (model),
&iter,
&child);
} while (gtk_tree_model_iter_next (model, &iter));
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (priv->model), NULL) == 1)
gtk_list_store_clear (priv->model);
}
/*
* Selects a single price in the price tree view. The price
* tree must be in single selection mode.
*/
void
gnc_tree_view_price_set_selected_price (GncTreeViewPrice *view,
GNCPrice *price)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreePath *path, *f_path, *s_path, *parent_path;
GtkTreeSelection *selection;
ENTER("view %p, price %p", view, price);
/* Clear any existing selection. */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_unselect_all (selection);
if (price == NULL)
return;
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (f_model));
path = gnc_tree_model_price_get_path_from_price (GNC_TREE_MODEL_PRICE(model), price);
if (path == NULL)
{
LEAVE("get_path_from_price failed");
return;
}
debug_path(DEBUG, path);
f_path = gtk_tree_model_filter_convert_child_path_to_path (GTK_TREE_MODEL_FILTER (f_model),
path);
gtk_tree_path_free(path);
if (f_path == NULL)
{
LEAVE("no filter path");
return;
}
debug_path(DEBUG, f_path);
s_path = gtk_tree_model_sort_convert_child_path_to_path (GTK_TREE_MODEL_SORT (s_model),
f_path);
gtk_tree_path_free(f_path);
if (s_path == NULL)
{
LEAVE("no sort path");
return;
}
/* gtk_tree_view requires that a row be visible before it can be selected */
parent_path = gtk_tree_path_copy (s_path);
if (gtk_tree_path_up (parent_path))
{
/* This function is misnamed. It expands the actual item
* specified, not the path to the item specified. I.E. It expands
* one level too many, thus the get of the parent. */
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), parent_path);
}
gtk_tree_path_free(parent_path);
gtk_tree_selection_select_path (selection, s_path);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(view), s_path, NULL, FALSE, 0.0, 0.0);
debug_path(LEAVE, s_path);
gtk_tree_path_free(s_path);
}
void
fill_fields (GtkWidget *due_date_entry, GtkWidget *summary_entry, GtkWidget *desc_entry, GUI *appGUI) {
GtkTreeIter iter;
GtkTextIter titer;
GtkTreePath *sort_path, *filter_path, *path;
gchar *fduedate, *fpriority, *fcategory, *fsummary, *fdesc;
GtkTextBuffer *text_buffer;
gtk_tree_view_get_cursor (GTK_TREE_VIEW (appGUI->tsk->tasks_list), &sort_path, NULL);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(desc_entry));
gui_clear_text_buffer (text_buffer, &titer);
if (sort_path != NULL) {
filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT(appGUI->tsk->tasks_sort), sort_path);
if (filter_path != NULL) {
path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), filter_path);
if (path != NULL) {
gtk_tree_model_get_iter(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), &iter, path);
gtk_tree_model_get (GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), &iter,
COLUMN_DUE_DATE, &fduedate,
COLUMN_DUE_DATE_JULIAN, &appGUI->tsk->tasks_due_julian_day,
COLUMN_PRIORITY, &fpriority,
COLUMN_CATEGORY, &fcategory,
COLUMN_SUMMARY, &fsummary,
COLUMN_DESCRIPTION, &fdesc, -1);
gtk_entry_set_text(GTK_ENTRY(due_date_entry), fduedate);
g_free(fduedate);
gtk_entry_set_text(GTK_ENTRY(summary_entry), fsummary);
g_free(fsummary);
gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->tsk->category_combobox),
gui_list_store_get_text_index (appGUI->opt->tasks_category_store, fcategory));
g_free(fcategory);
gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->tsk->priority_combobox),
get_priority_index (fpriority));
g_free(fpriority);
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(text_buffer), &titer, 0);
if (fdesc != NULL) {
gtk_text_buffer_insert(text_buffer, &titer, fdesc, -1);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(desc_entry), text_buffer);
g_free(fdesc);
}
gtk_tree_path_free(path);
}
gtk_tree_path_free(filter_path);
}
gtk_tree_path_free(sort_path);
}
}
static void
toggled_callback (GtkCellRendererToggle *celltoggle,
gchar *path_string,
GtkTreeView *tree_view)
{
GtkTreeModel *model = NULL;
GtkTreeModelSort *sort_model = NULL;
GtkTreePath *path;
GtkTreeIter iter;
gboolean active = FALSE;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
model = gtk_tree_view_get_model (tree_view);
if (GTK_IS_TREE_MODEL_SORT (model))
{
sort_model = GTK_TREE_MODEL_SORT (model);
model = gtk_tree_model_sort_get_model (sort_model);
}
if (model == NULL)
return;
if (sort_model)
{
g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");
return;
}
path = gtk_tree_path_new_from_string (path_string);
if (!gtk_tree_model_get_iter (model,
&iter, path))
{
g_warning ("%s: bad path?", G_STRLOC);
return;
}
gtk_tree_path_free (path);
if (GTK_IS_LIST_STORE (model))
{
gtk_tree_model_get (GTK_TREE_MODEL (model),
&iter,
BOOL_COLUMN,
&active,
-1);
gtk_list_store_set (GTK_LIST_STORE (model),
&iter,
BOOL_COLUMN,
!active,
-1);
}
else if (GTK_IS_TREE_STORE (model))
{
gtk_tree_model_get (GTK_TREE_MODEL (model),
&iter,
BOOL_COLUMN,
&active,
-1);
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
BOOL_COLUMN,
!active,
-1);
}
else
g_warning ("don't know how to actually toggle value for model type %s",
g_type_name (G_TYPE_FROM_INSTANCE (model)));
}
static gboolean
rejilla_split_dialog_cut (RejillaSplitDialog *self,
gint64 pos,
gboolean warn)
{
RejillaSplitDialogPrivate *priv;
RejillaAudioSlice slice = {0,0};
GtkTreeModel *model;
GtkTreeIter child;
GtkTreeIter iter;
gchar *length_str;
gchar *start_str;
gchar *end_str;
if (!pos)
return FALSE;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (self);
/* since pos is in nanosecond we have a small lattitude. Make sure that
* is up to the size of a sector */
if (REJILLA_DURATION_TO_BYTES (pos) % 2352)
pos += REJILLA_BYTES_TO_DURATION (2352 - (REJILLA_DURATION_TO_BYTES (pos) % 2352));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree));
if (!gtk_tree_model_get_iter_first (model, &iter)) {
gint64 end;
/* nothing in the tree yet */
if (priv->end <= 0)
end = rejilla_song_control_get_length (REJILLA_SONG_CONTROL (priv->player));
else
end = priv->end;
/* check that pos > 300 sectors ( == 4 sec ) */
if (warn
&& pos - priv->start < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
return FALSE;
if (warn
&& end - (pos + 1) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
return FALSE;
length_str = rejilla_units_get_time_string (pos - priv->start, TRUE, FALSE);
start_str = rejilla_units_get_time_string (priv->start, TRUE, FALSE);
end_str = rejilla_units_get_time_string (pos, TRUE, FALSE);
gtk_list_store_append (priv->model, &iter);
gtk_list_store_set (priv->model, &iter,
START_COL, (gint64) priv->start,
END_COL, (gint64) pos,
LENGTH_COL, (gint64) pos - priv->start,
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
pos ++;
length_str = rejilla_units_get_time_string (end - pos, TRUE, FALSE);
start_str = rejilla_units_get_time_string (pos, TRUE, FALSE);
end_str = rejilla_units_get_time_string (end, TRUE, FALSE);
gtk_list_store_append (priv->model, &iter);
gtk_list_store_set (priv->model, &iter,
START_COL, pos,
END_COL, end,
LENGTH_COL, (gint64) (end - pos),
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
return TRUE;
}
/* Try to find an already created slice encompassing the position */
do {
gint64 start;
gint64 end;
gtk_tree_model_get (model, &iter,
START_COL, &start,
END_COL, &end,
-1);
/* NOTE: if pos == start or pos == end then nothing changes */
if (pos <= start || pos >= end)
continue;
/* check the size of the new tracks */
if (warn
&& (pos - start) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
return FALSE;
if (warn
&& (end - (pos + 1)) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
return FALSE;
/* Found one */
slice.start = start;
slice.end = end;
break;
} while (gtk_tree_model_iter_next (model, &iter));
/* see if we found a slice, if not create a new one starting at pos
* until the end of the song */
if (slice.start == 0 && slice.end == 0) {
slice.start = pos;
/* check if we need to stop this slice at the end of the song
* or at the start of the next slice. */
if (gtk_tree_model_get_iter_first (model, &iter)) {
do {
gint64 start;
gint64 end;
gtk_tree_model_get (model, &iter,
START_COL, &start,
END_COL, &end,
-1);
if (pos >= start)
continue;
/* Found one */
slice.end = start - 1;
} while (gtk_tree_model_iter_next (model, &iter));
}
if (!slice.end)
slice.end = priv->end;
/* check the size of the new slice */
if (warn
&& (slice.end - slice.start) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
return FALSE;
}
else {
/* we are in the middle of an existing slice */
length_str = rejilla_units_get_time_string (pos - slice.start, TRUE, FALSE);
end_str = rejilla_units_get_time_string (pos, TRUE, FALSE);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child,
&iter);
gtk_list_store_set (priv->model, &child,
END_COL, (gint64) pos,
LENGTH_COL, (gint64) (pos - slice.start),
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (end_str);
/* move the position by one */
pos ++;
}
/* create a new one */
gtk_list_store_append (priv->model, &child);
length_str = rejilla_units_get_time_string (slice.end - pos, TRUE, FALSE);
start_str = rejilla_units_get_time_string (pos, TRUE, FALSE);
end_str = rejilla_units_get_time_string (slice.end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, pos,
END_COL, slice.end,
LENGTH_COL, (gint64) (slice.end - pos),
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
return TRUE;
}
static void
rejilla_split_dialog_remove_range (RejillaSplitDialog *self,
gint64 start,
gint64 end,
gint64 length)
{
RejillaSplitDialogPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *length_str;
gchar *start_str;
gchar *end_str;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (self);
/* align on 2352 byte boundary */
if (REJILLA_DURATION_TO_BYTES (start) % 2352)
start += REJILLA_BYTES_TO_DURATION (2352 - (REJILLA_DURATION_TO_BYTES (start) % 2352));
if (REJILLA_DURATION_TO_BYTES (end) % 2352) {
end += REJILLA_BYTES_TO_DURATION (2352 - (REJILLA_DURATION_TO_BYTES (end) % 2352));
if (end > length)
end = length;
}
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->tree));
if (!gtk_tree_model_get_iter_first (model, &iter)) {
/* nothing in the tree yet; so create two new segments:
* - 0 => start
* - end => song end
* also make sure that the track is longer than 4 sec */
if (start - priv->start < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self)) {
/* that's not necessarily a good solution */
start = REJILLA_MIN_STREAM_LENGTH;
if (start > end)
end = start;
}
if ((length - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = length - REJILLA_MIN_STREAM_LENGTH;
length_str = rejilla_units_get_time_string (start - priv->start, TRUE, FALSE);
start_str = rejilla_units_get_time_string (priv->start, TRUE, FALSE);
end_str = rejilla_units_get_time_string (start, TRUE, FALSE);
gtk_list_store_append (priv->model, &iter);
gtk_list_store_set (priv->model, &iter,
START_COL, (gint64) priv->start,
END_COL, (gint64) start,
LENGTH_COL, (gint64) start - priv->start,
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
if (end == length)
return;
length_str = rejilla_units_get_time_string (length - end, TRUE, FALSE);
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
end_str = rejilla_units_get_time_string (length, TRUE, FALSE);
gtk_list_store_append (priv->model, &iter);
gtk_list_store_set (priv->model, &iter,
START_COL, end,
END_COL, length,
LENGTH_COL, (gint64) (length - end),
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
return;
}
do {
GtkTreeIter child;
gint64 track_start;
gint64 track_end;
gtk_tree_model_get (model, &iter,
START_COL, &track_start,
END_COL, &track_end,
-1);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child,
&iter);
if (start == track_start) {
if (start == end)
return;
if (end == track_end) {
/* suppress it */
gtk_list_store_remove (priv->model, &child);
return;
}
if (end < track_end) {
/* reduce the size but make sure the remaining
* track is > 4 sec */
if ((track_end - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = track_end - REJILLA_MIN_STREAM_LENGTH;
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
length_str = rejilla_units_get_time_string (track_end - end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, end,
START_STR_COL, start_str,
LENGTH_COL, track_end - end,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
}
else if (!gtk_list_store_remove (priv->model, &child))
return;
}
else if (start > track_start) {
if (start > track_end)
continue;
/* reduce the size but make sure the remaining track is
* > 4 sec else change it */
if ((start - track_start) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
start = track_start + REJILLA_MIN_STREAM_LENGTH;
start_str = rejilla_units_get_time_string (start, TRUE, FALSE);
length_str = rejilla_units_get_time_string (start - track_start, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
END_COL, start,
END_STR_COL, start_str,
LENGTH_COL, start - track_start,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
if (end == length)
return;
if (end == track_end)
return;
if (end > track_end)
continue;
/* create a new track with the remaining time.
* make sure the remaining track is > 4 sec */
if ((track_end - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = track_end - REJILLA_MIN_STREAM_LENGTH;
gtk_list_store_append (priv->model, &child);
length_str = rejilla_units_get_time_string (track_end - end, TRUE, FALSE);
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
end_str = rejilla_units_get_time_string (track_end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, end,
END_COL, track_end,
LENGTH_COL, (gint64) (track_end - end),
START_STR_COL, start_str,
END_STR_COL, end_str,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
g_free (end_str);
}
else if (end > track_end) {
if (!gtk_list_store_remove (priv->model, &child))
return;
}
else if (end == track_end) {
gtk_list_store_remove (priv->model, &child);
return;
}
else {
if (end == length) {
gtk_list_store_remove (priv->model, &child);
return;
}
/* resize (make sure about the 4s) */
if ((track_end - end) < REJILLA_MIN_STREAM_LENGTH
&& !rejilla_split_dialog_size_error (self))
end = track_end - REJILLA_MIN_STREAM_LENGTH;
start_str = rejilla_units_get_time_string (end, TRUE, FALSE);
length_str = rejilla_units_get_time_string (track_end - end, TRUE, FALSE);
gtk_list_store_set (priv->model, &child,
START_COL, end,
START_STR_COL, start_str,
LENGTH_COL, track_end - end,
LENGTH_STR_COL, length_str,
-1);
g_free (length_str);
g_free (start_str);
}
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (model),
&iter,
&child);
} while (gtk_tree_model_iter_next (model, &iter));
}
static void
file_view_select_from_iter (AnjutaFileView* view, GtkTreeIter iter)
{
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModelSort* model_sort;
gboolean valid;
GtkTreeIter sort_iter;
GFile* file;
model_sort = GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (GTK_TREE_VIEW (view)));
do
{
gboolean is_dummy, is_dir;
gtk_tree_model_get (GTK_TREE_MODEL (priv->model), &iter,
COLUMN_FILE, &file, COLUMN_DUMMY, &is_dummy,
COLUMN_IS_DIR, &is_dir, -1);
if (is_dummy)
break;
if (g_file_equal (priv->pending_selected_file, file))
{
file_view_select_iter (view, iter);
break;
}
else if (g_file_has_prefix (priv->pending_selected_file, file))
{
if (is_dir)
{
GtkTreePath *path = NULL;
gtk_tree_model_sort_convert_child_iter_to_iter (model_sort, &sort_iter, &iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model_sort), &sort_iter);
if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (view), path))
{
GtkTreeIter parent = iter;
valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (priv->model), &iter, &parent);
gtk_tree_path_free (path);
}
else
{
gtk_tree_view_expand_row (GTK_TREE_VIEW (view), path, FALSE);
gtk_tree_path_free (path);
break;
}
}
else
{
file_view_select_iter (view, iter);
break;
}
}
else
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->model), &iter);
g_clear_object (&file);
} while (valid);
if (file)
g_object_unref (file);
}
gint
birthdays_list_dbclick_cb (GtkWidget * widget, GdkEventButton * event, gpointer user_data)
{
GtkTreeIter iter;
GtkTreeModel *model, *contacts_model;
GtkTreePath *sort_path, *filter_path, *path;
gint id, id_c;
GUI *appGUI = (GUI *) user_data;
contacts_model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store);
if (((event->type == GDK_2BUTTON_PRESS) && (event->button == 1)) == FALSE)
return FALSE;
if (gtk_tree_selection_get_selected (appGUI->cnt->birthdays_list_selection, &model, &iter)) {
if (strlen (gtk_entry_get_text (GTK_ENTRY (appGUI->cnt->contacts_find_entry)))) {
gtk_entry_set_text (GTK_ENTRY (appGUI->cnt->contacts_find_entry), "");
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (appGUI->cnt->contacts_filter));
}
gtk_tree_model_get (model, &iter, B_COLUMN_ID, &id, -1);
gtk_widget_destroy (appGUI->cnt->birthdays_window);
contacts_selection_activate (FALSE, appGUI);
if (gtk_tree_model_get_iter_first (contacts_model, &iter) == TRUE) {
sort_path = gtk_tree_model_get_path (contacts_model, &iter);
while (sort_path != NULL) {
gtk_tree_view_set_cursor (GTK_TREE_VIEW (appGUI->cnt->contacts_list), sort_path, NULL, FALSE);
filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT (appGUI->cnt->contacts_sort), sort_path);
if (filter_path != NULL) {
path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER (appGUI->cnt->contacts_filter), filter_path);
if (path != NULL) {
gtk_tree_model_get_iter (contacts_model, &iter, path);
gtk_tree_model_get (contacts_model, &iter, COLUMN_ID, &id_c, -1);
if (id == id_c) {
contacts_selection_activate (TRUE, appGUI);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (appGUI->cnt->contacts_list), sort_path, NULL, FALSE);
show_contacts_desc_panel (TRUE, appGUI);
gtk_tree_path_free (path);
gtk_tree_path_free (filter_path);
g_signal_emit_by_name (G_OBJECT (appGUI->cnt->contacts_list_selection), "changed");
break;
}
gtk_tree_path_free (path);
}
gtk_tree_path_free (filter_path);
}
gtk_tree_path_next (sort_path);
if (gtk_tree_model_get_iter (contacts_model, &iter, sort_path) == FALSE) break;
}
gtk_tree_path_free (sort_path);
}
}
return TRUE;
}
gint
export_contacts_to_file(gchar *filename, gboolean header, GUI *appGUI) {
GtkTreePath *sort_path, *filter_path, *path;
gint i, j, a, b, c, e, n, m, max_field, exported;
gchar *text;
GtkTreeIter iter;
FILE *filehandle;
guint32 date;
gchar tmpbuf[BUFFER_SIZE];
gchar tmp_buffer_1[BUFFER_SIZE], tmp_buffer_2[BUFFER_SIZE];
exported = 0;
if (utl_gui_check_overwrite_file (filename, appGUI->cnt->export_window, appGUI) != 0) {
return -1;
}
for(max_field = CONTACTS_NUM_COLUMNS-1; max_field >= 0; --max_field) {
if(config.export_fields[max_field] == '+') break;
}
if (max_field == -1) {
max_field = CONTACTS_NUM_COLUMNS-1;
}
filehandle = g_fopen (filename, "w");
if(filehandle) {
if (config.export_format == EXPORT_TO_XHTML) {
fprintf(filehandle, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");
fprintf(filehandle, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n");
fprintf(filehandle, "<head>\n");
fprintf(filehandle, "\t<title>Contact List</title>\n");
fprintf(filehandle, "\t<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" />\n");
fprintf(filehandle, "\t<meta name=\"generator\" content=\"OSMO - http://clay.ll.pl/osmo\" />\n");
fprintf(filehandle, "\t<style type=\"text/css\">\n");
fprintf(filehandle, "\t\tbody { color:black; background-color:white; }\n");
fprintf(filehandle, "\t\ta { color:#0000ff; }\n");
fprintf(filehandle, "\t\ta:visited { color:#000055; }\n");
fprintf(filehandle, "\t\ttable { border-collapse:collapse; }\n");
fprintf(filehandle, "\t\ttr.header { background-color:#c0c0c0; }\n");
fprintf(filehandle, "\t\ttr.evenrow { background-color:#f0f0f0; }\n");
fprintf(filehandle, "\t\ttr.oddrow { background-color:#fafafa; }\n");
fprintf(filehandle, "\t\tth, td { border:1px solid #555555; padding:3px; }\n");
fprintf(filehandle, "\t</style>\n");
fprintf(filehandle, "</head>\n\n");
fprintf(filehandle, "<body>\n\n");
fprintf(filehandle, "<h1>Contact List</h1>\n\n");
fprintf(filehandle, "<table>\n");
fprintf(filehandle, "<tr class=\"header\">\n");
for(i=0; i < CONTACTS_NUM_COLUMNS; i++) {
if(config.export_fields[i] == '+') {
fprintf(filehandle, "\t<th>");
if (appGUI->cnt->contact_fields_tags_name[i*2] != NULL) {
for(a=b=0; a < strlen(appGUI->cnt->contact_fields_tags_name[i*2]); a++) {
if(appGUI->cnt->contact_fields_tags_name[i*2][a] == ' ') {
tmpbuf[b] = '\0';
strcat(tmpbuf, " ");
b += 6;
} else {
tmpbuf[b++] = appGUI->cnt->contact_fields_tags_name[i*2][a];
}
}
tmpbuf[b] = '\0';
fprintf(filehandle, "%s", tmpbuf);
}
fprintf(filehandle, "</th>\n");
}
}
fprintf(filehandle, "</tr>\n\n");
}
j = 0;
sort_path = gtk_tree_path_new_first ();
while (gtk_tree_model_get_iter (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, sort_path) == TRUE) {
if (sort_path != NULL) {
filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT(appGUI->cnt->contacts_sort), sort_path);
if (filter_path != NULL) {
path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER(appGUI->cnt->contacts_filter), filter_path);
if (path != NULL) {
gtk_tree_model_get_iter (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, path);
if (config.export_format == EXPORT_TO_XHTML) {
if(j & 1) {
fprintf(filehandle, "<tr class=\"evenrow\">\n");
} else {
fprintf(filehandle, "<tr class=\"oddrow\">\n");
}
} else if (config.export_format == EXPORT_TO_CSV && header == TRUE && j == 0) {
for(i=n=0; i < CONTACTS_NUM_COLUMNS; i++) {
if (i != COLUMN_PHOTO && i != COLUMN_ID && config.export_fields[i] == '+') {
n++;
}
}
for(i=m=0; i < CONTACTS_NUM_COLUMNS; i++) {
if (i != COLUMN_PHOTO && i != COLUMN_ID && config.export_fields[i] == '+') {
fprintf(filehandle, "%s", appGUI->cnt->contact_fields_tags_name[i*2]);
if (m != n-1) {
fprintf(filehandle, ",");
}
m++;
}
}
fprintf(filehandle, "\n");
}
for(i=0; i < CONTACTS_NUM_COLUMNS; i++) {
if(config.export_fields[i] == '+') {
if (i == COLUMN_BIRTH_DAY_DATE || i == COLUMN_NAME_DAY_DATE) {
gtk_tree_model_get (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, i, &date, -1);
if (date == 0) {
text = NULL;
} else {
if (i == COLUMN_BIRTH_DAY_DATE) {
text = g_strdup((const gchar *)julian_to_str(date, DATE_FULL, config.override_locale_settings));
} else {
text = g_strdup((const gchar *)julian_to_str(date, DATE_NAME_DAY, config.override_locale_settings));
}
}
} else {
gtk_tree_model_get (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, i, &text, -1);
}
if (config.export_format == EXPORT_TO_XHTML) {
fprintf(filehandle, "\t<td>");
if (text != NULL) {
for(a=b=0; a < strlen(text); a++) {
if(text[a] == ' ') {
tmpbuf[b] = '\0';
strcat(tmpbuf, " ");
b += 6;
} else {
tmpbuf[b++] = text[a];
}
}
tmpbuf[b] = '\0';
switch (i) {
case COLUMN_EMAIL_1:
case COLUMN_EMAIL_2:
case COLUMN_EMAIL_3:
case COLUMN_EMAIL_4:
fprintf(filehandle, "<a href=\"mailto:%s\">%s</a>", tmpbuf, tmpbuf);
break;
case COLUMN_WWW_1:
case COLUMN_WWW_2:
case COLUMN_WWW_3:
case COLUMN_WWW_4:
case COLUMN_BLOG:
fprintf(filehandle, "<a href=\"%s\">%s</a>", tmpbuf, tmpbuf);
break;
default:
fprintf(filehandle, "%s", tmpbuf);
}
g_free(text);
}
fprintf(filehandle, "</td>\n");
} else {
/* CSV */
if (text != NULL) {
/* 1 */
for(a = b = e = 0; a < strlen(text); a++) {
if(text[a]=='"') {
b = 1;
}
if(text[a]=='\n') {
e = 1; /* found new line */
}
}
c = a = 0;
if (b) {
tmp_buffer_1[c++] = '"';
}
do {
if(text[a]=='"') {
tmp_buffer_1[c++] = '"';
}
tmp_buffer_1[c++] = text[a];
a++;
} while (text[a]!='\0');
if(b) {
tmp_buffer_1[c++] = '"';
}
tmp_buffer_1[c] = '\0';
/* 2 */
for(a = b = 0; a < strlen(tmp_buffer_1); a++) {
if(tmp_buffer_1[a]==',') {
b = 1;
}
}
c = a = 0;
if (b) {
tmp_buffer_2[c++] = '"';
}
do {
tmp_buffer_2[c++] = tmp_buffer_1[a];
a++;
} while (tmp_buffer_1[a]!='\0');
if (b) {
tmp_buffer_2[c++] = '"';
}
tmp_buffer_2[c] = '\0';
if (e) {
fprintf(filehandle, "\"%s\"", tmp_buffer_2);
} else {
fprintf(filehandle, "%s", tmp_buffer_2);
}
g_free(text);
}
if (i != max_field) {
fprintf(filehandle, ",");
}
}
}
}
if (config.export_format == EXPORT_TO_XHTML) {
fprintf(filehandle, "</tr>\n\n");
} else {
/* CSV */
fprintf(filehandle, "\n");
}
j++;
exported++;
gtk_tree_path_free(path);
}
gtk_tree_path_free(filter_path);
}
}
gtk_tree_path_next (sort_path);
}
if (config.export_format == EXPORT_TO_XHTML) {
fprintf(filehandle, "</table>\n");
fprintf(filehandle, "</body>\n");
fprintf(filehandle, "</html>\n");
}
fclose(filehandle);
} else {
utl_gui_create_dialog(GTK_MESSAGE_ERROR, _("Cannot create file."), GTK_WINDOW(appGUI->cnt->export_window));
return -1;
}
return exported;
}
static void transfer_model_data(int iflag_if_add,
GtkTreeView *tree_view_to_del, GtkTreeView *tree_view_to_add)
{
GtkTreeModel *model_to_del;
GtkTreeModel *child_model_to_del;
GtkTreeModel *model_to_add;
GtkTreeModel *child_model_to_add;
GtkTreeSelection *selection;
GList *list;
GList *reference_list;
GList *cur;
gchar *field_name;
gchar *field_math;
int index_field;
int iflag_viz, iflag_monitor, num_comp, iflag_quad;
/* 選択されている行のパスを取得する */
/* パスはツリーモデルソートのもの */
model_to_del = gtk_tree_view_get_model(tree_view_to_del);
child_model_to_del = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_to_del));
model_to_add = gtk_tree_view_get_model(tree_view_to_add);
child_model_to_add = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_to_add));
selection = gtk_tree_view_get_selection(tree_view_to_del);
list = gtk_tree_selection_get_selected_rows(selection, NULL);
/* 最初にパスからリファレンスを作成する */
/* データの削除を行なうと取得済みのパスが(大抵の場合)無効になる */
reference_list = NULL;
for (cur = g_list_first(list); cur != NULL; cur = g_list_next(cur)) {
GtkTreePath *child_path;
GtkTreeRowReference *child_reference;
/* ツリーモデルソートのパスをツリーモデルのパスに変換する */
child_path = gtk_tree_model_sort_convert_path_to_child_path(GTK_TREE_MODEL_SORT(model_to_del),
(GtkTreePath *)cur->data);
child_reference = gtk_tree_row_reference_new(child_model_to_del, child_path);
reference_list = g_list_append(reference_list, child_reference);
gtk_tree_path_free(child_path);
gtk_tree_path_free((GtkTreePath *)cur->data);
}
g_list_free(list);
/* GtkTreeSelectionのchangedシグナルを一時的にブロックする */
block_changed_signal(G_OBJECT(child_model_to_del));
block_changed_signal(G_OBJECT(child_model_to_add));
/* リファレンスをパスに戻して削除 */
for (cur = g_list_first(reference_list); cur != NULL; cur = g_list_next(cur)) {
GtkTreePath *tree_path;
GtkTreeIter iter;
tree_path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)cur->data);
gtk_tree_model_get_iter(child_model_to_del, &iter, tree_path);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_INDEX, &index_field, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_NAME, &field_name, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_MATH, &field_math, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_VIZ_FLAG, &iflag_viz, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_MONITOR_FLAG, &iflag_monitor, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_NUM_COMP, &num_comp, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_QUADRATURE, &iflag_quad, -1);
printf("To be moved: %d, %s: %s\n", index_field, field_name,
all_fld_list[index_field]->field_name);
/* Delete */
gtk_list_store_remove(GTK_LIST_STORE(child_model_to_del), &iter);
/* Add */
append_model_data(index_field, child_model_to_add);
gtk_tree_path_free(tree_path);
gtk_tree_row_reference_free((GtkTreeRowReference *)cur->data);
/* Update control data */
if(iflag_if_add == 1){
printf("Add field list \n");
add_field_wqflag_to_ctl(all_fld_list[index_field], mhd_ctl->model_ctl->fld_ctl);
} else {
printf("Delete field list \n");
delete_field_wqflag_in_ctl(all_fld_list[index_field], mhd_ctl->model_ctl->fld_ctl);
};
}
g_list_free(reference_list);
/* changedシグナルのブロックを解除する */
unblock_changed_signal(G_OBJECT(child_model_to_del));
unblock_changed_signal(G_OBJECT(child_model_to_add));
/*
check_field_ctl_list(mhd_ctl->model_ctl->fld_ctl);
*/
}
void
on_action_item_delete (GtkAction *action,
GeditCollaborationWindowHelper *helper)
{
GtkTreeIter iter;
GtkTreeIter selected;
InfcBrowser *browser;
InfcBrowserIter *browser_iter;
InfcBrowserIter parent;
if (!inf_gtk_browser_view_get_selected (INF_GTK_BROWSER_VIEW (helper->priv->browser_view),
&selected))
{
return;
}
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (
gtk_tree_view_get_model (
GTK_TREE_VIEW (helper->priv->browser_view)
)
),
&iter,
&selected
);
gtk_tree_model_get (GTK_TREE_MODEL (helper->priv->browser_store),
&iter,
INF_GTK_BROWSER_MODEL_COL_BROWSER,
&browser,
INF_GTK_BROWSER_MODEL_COL_NODE,
&browser_iter,
-1);
parent = *browser_iter;
if (!infc_browser_iter_get_parent (browser, &parent))
{
/* Toplevel bookmark */
InfXmlConnection *connection = infc_browser_get_connection (browser);
GeditCollaborationBookmarks *bookmarks;
GeditCollaborationBookmark *bookmark =
g_object_get_data (G_OBJECT (connection),
BOOKMARK_DATA_KEY);
/* Close connection first */
if (infc_browser_get_status (browser) != INFC_BROWSER_DISCONNECTED)
{
inf_xml_connection_close (connection);
}
inf_gtk_browser_store_remove_connection (helper->priv->browser_store,
connection);
bookmarks = gedit_collaboration_bookmarks_get_default ();
gedit_collaboration_bookmarks_remove (bookmarks, bookmark);
}
else
{
/* Remove the iter itself */
infc_browser_remove_node (browser, browser_iter);
}
g_object_unref (browser);
if (browser_iter)
{
infc_browser_iter_free (browser_iter);
}
}
int
_pygtk_tree_model_set_row(GtkTreeModel *model, GtkTreeIter *iter,
PyObject *items)
{
gint n_columns, i;
GtkTreeModel *child;
GtkTreeIter citer;
if (!GTK_IS_LIST_STORE(model) && !GTK_IS_TREE_STORE(model) &&
!GTK_IS_TREE_MODEL_SORT(model) && !GTK_IS_TREE_MODEL_FILTER(model)) {
PyErr_SetString(PyExc_TypeError,
"cannot set cells in this tree model");
return -1;
}
if (GTK_IS_TREE_MODEL_SORT(model)) {
child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_sort_convert_iter_to_child_iter(
GTK_TREE_MODEL_SORT(model), &citer, iter);
return _pygtk_tree_model_set_row(child, &citer, items);
}
if (GTK_IS_TREE_MODEL_FILTER(model)) {
child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &citer, iter);
return _pygtk_tree_model_set_row(child, &citer, items);
}
if (!PySequence_Check(items)) {
PyErr_SetString(PyExc_TypeError, "expecting a sequence");
return -1;
}
n_columns = gtk_tree_model_get_n_columns(model);
if (PySequence_Length(items) != n_columns) {
PyErr_SetString(PyExc_ValueError, "row sequence has wrong length");
return -1;
}
for (i = 0; i < n_columns; i++) {
GValue value = { 0, };
PyObject *item;
item = PySequence_GetItem(items, i);
if (!item)
return -1;
g_value_init(&value, gtk_tree_model_get_column_type(model, i));
if (pyg_value_from_pyobject(&value, item)) {
Py_DECREF(item);
PyErr_SetString(PyExc_TypeError,
"value is of wrong type for this column");
return -1;
}
if (GTK_IS_LIST_STORE(model))
gtk_list_store_set_value(GTK_LIST_STORE(model), iter, i, &value);
else if (GTK_IS_TREE_STORE(model))
gtk_tree_store_set_value(GTK_TREE_STORE(model), iter, i, &value);
g_value_unset(&value);
Py_DECREF(item);
}
return 0;
}
static void
item_new_dialog (GeditCollaborationWindowHelper *helper,
gboolean newfile)
{
GtkWidget *dialog;
ItemNew *item;
GtkTreeIter iter;
GtkTreeIter selected;
InfcBrowser *browser;
InfcBrowserIter *node;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *hbox;
if (!inf_gtk_browser_view_get_selected (INF_GTK_BROWSER_VIEW (helper->priv->browser_view),
&selected))
{
return;
}
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (
gtk_tree_view_get_model (
GTK_TREE_VIEW (helper->priv->browser_view)
)
),
&iter,
&selected
);
dialog = gtk_dialog_new_with_buttons (newfile ? _("New File") : _("New Folder"),
GTK_WINDOW (helper->priv->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (newfile ? _("File _name:") : _("Folder _name:"));
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_widget_show (entry);
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox,
FALSE,
FALSE,
0);
gtk_tree_model_get (GTK_TREE_MODEL (helper->priv->browser_store),
&iter,
INF_GTK_BROWSER_MODEL_COL_BROWSER,
&browser,
INF_GTK_BROWSER_MODEL_COL_NODE,
&node,
-1);
item = g_slice_new (ItemNew);
item->helper = helper;
item->iter = *node;
item->browser = browser;
item->newfile = newfile;
item->entry = GTK_ENTRY (entry);
infc_browser_iter_free (node);
g_signal_connect (dialog,
"response",
G_CALLBACK (on_item_new_response),
item);
gtk_widget_show (dialog);
}
void delete_cr_list_items_GTK(GtkTreeView *tree_view_to_del,
struct chara_real_clist *cr_clist)
{
GtkTreeModel *model_to_del;
GtkTreeModel *child_model_to_del;
GtkTreeSelection *selection;
GList *list;
GList *reference_list;
GList *cur;
gchar *field_name;
gchar *field_math;
int index_field;
double value;
/* 選択されている行のパスを取得する */
/* パスはツリーモデルソートのもの */
model_to_del = gtk_tree_view_get_model(tree_view_to_del);
child_model_to_del = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_to_del));
selection = gtk_tree_view_get_selection(tree_view_to_del);
list = gtk_tree_selection_get_selected_rows(selection, NULL);
/* 最初にパスからリファレンスを作成する */
/* データの削除を行なうと取得済みのパスが(大抵の場合)無効になる */
reference_list = NULL;
for (cur = g_list_first(list); cur != NULL; cur = g_list_next(cur)) {
GtkTreePath *child_path;
GtkTreeRowReference *child_reference;
/* ツリーモデルソートのパスをツリーモデルのパスに変換する */
child_path = gtk_tree_model_sort_convert_path_to_child_path(GTK_TREE_MODEL_SORT(model_to_del),
(GtkTreePath *)cur->data);
child_reference = gtk_tree_row_reference_new(child_model_to_del, child_path);
reference_list = g_list_append(reference_list, child_reference);
gtk_tree_path_free(child_path);
gtk_tree_path_free((GtkTreePath *)cur->data);
}
g_list_free(list);
/* GtkTreeSelectionのchangedシグナルを一時的にブロックする */
block_changed_signal(G_OBJECT(child_model_to_del));
/* リファレンスをパスに戻して削除 */
for (cur = g_list_first(reference_list); cur != NULL; cur = g_list_next(cur)) {
GtkTreePath *tree_path;
GtkTreeIter iter;
tree_path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)cur->data);
gtk_tree_model_get_iter(child_model_to_del, &iter, tree_path);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_INDEX, &index_field, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_NAME, &field_name, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_MATH, &field_math, -1);
gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_VALUE, &value, -1);
printf("To be moved: %d, %s %lf\n", index_field, field_name, value);
/* Delete */
gtk_list_store_remove(GTK_LIST_STORE(child_model_to_del), &iter);
gtk_tree_path_free(tree_path);
gtk_tree_row_reference_free((GtkTreeRowReference *)cur->data);
/* Update control data */
del_chara_real_clist_by_c_tbl(field_name, cr_clist);
}
g_list_free(reference_list);
/* changedシグナルのブロックを解除する */
unblock_changed_signal(G_OBJECT(child_model_to_del));
}
static void
on_browser_activate (InfGtkBrowserView *view,
GtkTreeIter *iter,
GeditCollaborationWindowHelper *helper)
{
InfcBrowser *browser;
InfcBrowserIter *browser_iter;
InfDiscovery *discovery;
GeditCollaborationUser *user;
GtkTreeIter selected;
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (inf_gtk_browser_view_get_model (view)),
&selected,
iter
);
gtk_tree_model_get (GTK_TREE_MODEL (helper->priv->browser_store),
&selected,
INF_GTK_BROWSER_MODEL_COL_BROWSER,
&browser,
INF_GTK_BROWSER_MODEL_COL_DISCOVERY,
&discovery,
-1);
if (browser == NULL)
{
if (discovery)
{
g_object_unref (discovery);
}
return;
}
gtk_tree_model_get (GTK_TREE_MODEL (helper->priv->browser_store),
&selected,
INF_GTK_BROWSER_MODEL_COL_NODE,
&browser_iter,
-1);
if (browser_iter == NULL ||
infc_browser_iter_is_subdirectory (browser, browser_iter))
{
g_object_unref (browser);
if (browser_iter)
{
infc_browser_iter_free (browser_iter);
}
if (discovery)
{
g_object_unref (discovery);
}
return;
}
if (discovery)
{
user = gedit_collaboration_user_get_default ();
}
else
{
GeditCollaborationBookmark *bookmark;
bookmark = g_object_get_data (G_OBJECT (infc_browser_get_connection (browser)),
BOOKMARK_DATA_KEY);
user = gedit_collaboration_bookmark_get_user (bookmark);
}
gedit_collaboration_manager_subscribe (helper->priv->manager,
user,
browser,
browser_iter);
if (discovery)
{
g_object_unref (discovery);
}
if (browser_iter)
{
infc_browser_iter_free (browser_iter);
}
}
/**
* ephy_node_view_remove:
* @view: an #EphyNodeView
*
* Remove the currently selected nodes from @view.
**/
void
ephy_node_view_remove (EphyNodeView *view)
{
EphyNodeViewPrivate *priv = view->priv;
GList *list, *l;
EphyNode *node;
GtkTreeIter iter, iter2, iter3;
GtkTreePath *path;
GtkTreeRowReference *row_ref = NULL;
GtkTreeSelection *selection;
/* Before removing we try to get a reference to the next node in the view. If that is
* not available we try with the previous one, and if that is absent too,
* we will not select anything (which equals to select the topic "All")
*/
list = ephy_node_view_get_selection (view);
if (list == NULL) return;
node = g_list_first (list)->data;
ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel),
node, &iter3);
gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel),
&iter2, &iter3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel),
&iter, &iter2);
iter2 = iter;
if (gtk_tree_model_iter_next (GTK_TREE_MODEL (view->priv->sortmodel), &iter))
{
path = gtk_tree_model_get_path (GTK_TREE_MODEL (view->priv->sortmodel), &iter);
row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (view->priv->sortmodel), path);
}
else
{
path = gtk_tree_model_get_path (GTK_TREE_MODEL (view->priv->sortmodel), &iter2);
if (gtk_tree_path_prev (path))
{
row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (view->priv->sortmodel), path);
}
}
gtk_tree_path_free (path);
/* Work around bug #346662 */
priv->changing_selection = TRUE;
for (l = list; l != NULL; l = l->next)
{
ephy_node_unref (l->data);
}
priv->changing_selection = FALSE;
g_list_free (list);
/* Fake a selection changed signal */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_emit_by_name (selection, "changed");
/* Select the "next" node */
if (row_ref != NULL)
{
path = gtk_tree_row_reference_get_path (row_ref);
if (path != NULL)
{
gtk_tree_view_set_cursor (GTK_TREE_VIEW (view), path, NULL, FALSE);
gtk_tree_path_free (path);
}
gtk_tree_row_reference_free (row_ref);
}
}
static void
update_sensitivity (GeditCollaborationWindowHelper *helper)
{
gboolean has_selection;
GtkTreeIter selected;
GtkTreeIter sorted;
InfcBrowser *browser = NULL;
InfDiscovery *discovery = NULL;
GtkTreeModel *model;
GtkAction *action;
GtkTreePath *path;
gboolean toplevel = FALSE;
model = GTK_TREE_MODEL (helper->priv->browser_store);
has_selection =
inf_gtk_browser_view_get_selected (INF_GTK_BROWSER_VIEW (helper->priv->browser_view),
&sorted);
if (has_selection)
{
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (
inf_gtk_browser_view_get_model (
INF_GTK_BROWSER_VIEW (helper->priv->browser_view)
)
),
&selected,
&sorted
);
}
if (has_selection)
{
/* Check if the iter is a top-level (aka. browser node) */
gtk_tree_model_get (model,
&selected,
INF_GTK_BROWSER_MODEL_COL_BROWSER,
&browser,
INF_GTK_BROWSER_MODEL_COL_DISCOVERY,
&discovery,
-1);
path = gtk_tree_model_get_path (model, &selected);
toplevel = gtk_tree_path_get_depth (path) == 1;
gtk_tree_path_free (path);
}
gtk_action_group_set_sensitive (get_action_group (helper, "action_group_connected"),
browser != NULL &&
infc_browser_get_status (browser) == INFC_BROWSER_CONNECTED);
action = get_action (helper, "SessionDisconnect");
gtk_action_set_sensitive (action,
toplevel &&
browser != NULL &&
infc_browser_get_status (browser) != INFC_BROWSER_DISCONNECTED);
/* Handle other actions manually */
action = get_action (helper, "ItemDelete");
gtk_action_set_sensitive (action,
has_selection &&
(!toplevel || (
discovery == NULL &&
(browser == NULL ||
infc_browser_get_status (browser) != INFC_BROWSER_CONNECTED))));
action = get_action (helper, "BookmarkEdit");
gtk_action_set_sensitive (action,
has_selection &&
discovery == NULL &&
toplevel);
if (browser)
{
g_object_unref (browser);
}
if (discovery)
{
g_object_unref (discovery);
}
}
static
gchar *get_tooltip_text()
{
gchar *retval = NULL;
GString *string;
guint64 id;
GtkTreePath *path;
GtkTreeIter iterp, iter;
GTodoItem *item;
int i = gtk_combo_box_get_active(GTK_COMBO_BOX(mw.option));
string = g_string_new("");
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(mw.treeview), rect.x, rect.y, &path, NULL, NULL, NULL))
{
gtk_tree_model_get_iter(GTK_TREE_MODEL(mw.sortmodel), &iterp, path);
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(mw.sortmodel), &iter, &iterp);
gtk_tree_model_get(GTK_TREE_MODEL(mw.list), &iter,
ID, &id,
-1);
gtk_tree_path_free(path);
item = gtodo_client_get_todo_item_from_id(cl, (guint32)id);
if(item != NULL)
{
if(i == 0)
{
g_string_append_printf(string, "<i>%s:</i>\n",
gtodo_todo_item_get_category(item));
}
if(gtodo_todo_item_get_summary(item) != NULL)
{
g_string_append_printf(string, "<b>%s</b>\t%s", _("Summary:"),
gtodo_todo_item_get_summary(item));
}
if(gtodo_todo_item_get_due_date(item) != NULL
&& gtodo_todo_item_get_due_time_houre(item) == -1){
g_string_append_printf(string, "\n<b>%s</b>\t%s", _("Due date:"),
gtodo_todo_item_get_due_date_as_string(item));
}
else if(gtodo_todo_item_get_due_date(item) != NULL)
{
g_string_append_printf(string, "\n<b>%s</b>\t%s at %02i:%02i" ,
_("Due date:") ,
gtodo_todo_item_get_due_date_as_string(item),
gtodo_todo_item_get_due_time_houre(item),
gtodo_todo_item_get_due_time_minute(item));
}
if(gtodo_todo_item_get_priority(item) == 0)
{
g_string_append_printf(string,
"\n<b>%s</b>\t\t<span color=\"dark green\">%s</span>",
_("Priority:"),
_("Low"));
}
else if(gtodo_todo_item_get_priority(item) == 1)
{
g_string_append_printf(string,
"\n<b>%s</b>\t\t%s",
_("Priority:"), _("Medium"));
}
else
{
g_string_append_printf(string,
"\n<b>%s</b>\t\t<span color=\"red\">%s</span>",
_("Priority:"), _("High"));
}
if(gtodo_todo_item_get_comment(item) != NULL && strlen(gtodo_todo_item_get_comment(item)))
{
g_string_append_printf(string, "\n<b>%s</b>\t%s", _("Comment:"),
gtodo_todo_item_get_comment(item));
}
gtodo_todo_item_free(item);
}
/* free all the stuff */
for(i=0;i < string->len;i++)
{
if(string->str[i] == '&')
{
g_string_insert(string, i+1, "amp;");
}
}
retval = string->str;
g_string_free(string, FALSE);
return retval;
}
else return g_strdup("oeps");
}
static void Operator_add(GtkWidget * UNUSED(button), GtkTreeView * treeview) {
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *table;
GtkWidget *name_entry;
GtkWidget *password_entry;
GtkWidget *label;
gint response;
GtkTreeModel * model = gtk_tree_view_get_model(treeview);
dialog = gtk_dialog_new_with_buttons("Nouvel opérateur", NULL, GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, NULL);
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER (hbox), 8);
gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0);
table = gtk_table_new(2, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE (table), 4);
gtk_table_set_col_spacings(GTK_TABLE (table), 4);
gtk_box_pack_start(GTK_BOX (hbox), table, TRUE, TRUE, 0);
label = gtk_label_new("Nom :");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0, 1, 0, 1);
name_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY (name_entry), "");
gtk_table_attach_defaults(GTK_TABLE (table), name_entry, 1, 2, 0, 1);
gtk_label_set_mnemonic_widget(GTK_LABEL (label), name_entry);
gtk_entry_set_max_length(GTK_ENTRY (name_entry), OPERATORTABLE_MAXNAMESIZE - 1);
label = gtk_label_new("Mot de passe");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0, 1, 1, 2);
password_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY (password_entry), "");
gtk_table_attach_defaults(GTK_TABLE (table), password_entry, 1, 2, 1, 2);
gtk_label_set_mnemonic_widget(GTK_LABEL (label), password_entry);
gtk_entry_set_max_length(GTK_ENTRY (password_entry), OPERATORTABLE_MAXPASSWORDSIZE - 1);
gtk_widget_show_all(hbox);
response = gtk_dialog_run(GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
OperatorTable * optable = OperatorTable_loadFromFile(OPERATORDB_FILENAME);
if (optable != NULL) {
int i;
GtkTreeIter iter;
GtkListStore * store =
GTK_LIST_STORE(gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT (model)));
OperatorTable_setOperator(optable, gtk_entry_get_text(GTK_ENTRY (name_entry)),
gtk_entry_get_text(GTK_ENTRY (password_entry)));
OperatorTable_saveToFile(optable, OPERATORDB_FILENAME);
gtk_list_store_clear(store);
for (i = 0; i < OperatorTable_getRecordCount(optable); ++i) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, OperatorTable_getName(optable, i), -1);
}
OperatorTable_destroy(optable);
}
}
gtk_widget_destroy(dialog);
}
