/**
* Crée le GtkIconView
*
* \param nom de l'icône
*
* \return le GtkIconView rempli avec l'icône sélectionnée au premier plan
*
* */
GtkWidget * gsb_select_icon_create_icon_view ( gchar * name_icon )
{
GtkTreePath * tree_path;
/* construct the GtkIconView */
icon_view = gtk_icon_view_new ();
gtk_icon_view_set_margin ( GTK_ICON_VIEW ( icon_view ), 0 );
gtk_icon_view_set_spacing (GTK_ICON_VIEW ( icon_view ), 0 );
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW ( icon_view ),
GTK_SELECTION_SINGLE );
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW ( icon_view ), PIXBUF_COLUMN);
gtk_icon_view_set_text_column (GTK_ICON_VIEW ( icon_view ), TEXT_COLUMN);
/* remplissage et positionnement initial du curseur dans le GtkIconView */
tree_path = gsb_select_icon_fill_icon_view ( name_icon );
gtk_icon_view_select_path ( GTK_ICON_VIEW ( icon_view ), tree_path );
gtk_icon_view_set_cursor (GTK_ICON_VIEW ( icon_view ), tree_path,
NULL, TRUE);
gtk_icon_view_scroll_to_path (GTK_ICON_VIEW ( icon_view ),
tree_path, TRUE, 0.5, 0 );
return icon_view;
}
/*
* Configure the GtkIconView: background color, visual columns, drag-and-drop,
* and icon activation.
*/
static void
set_up_icon_view(GtkWidget *icons, struct state *d)
{
/* Background color */
GdkRGBA transparent = {0, 0, 0, 0};
override_background_color(icons, &transparent);
/* Columns */
gtk_icon_view_set_text_column(d->icon_view, FILE_NAME);
gtk_icon_view_set_pixbuf_column(d->icon_view, FILE_ICON);
/* Drag */
gtk_drag_source_set(icons, GDK_BUTTON1_MASK,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_add_text_targets(icons);
gtk_drag_source_add_uri_targets(icons);
g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d);
g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d);
g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d);
/* Drop */
gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_text_targets(icons);
gtk_drag_dest_add_uri_targets(icons);
g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d);
g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d);
g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d);
/* Activations */
g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d);
g_signal_connect(icons, "button-press-event", G_CALLBACK(on_desktop_icon_button_press_event), d);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkIconView_gtk_1icon_1view_1set_1text_1column
(
JNIEnv* env,
jclass cls,
jlong _self,
jint _column
)
{
GtkIconView* self;
gint column;
// convert parameter self
self = (GtkIconView*) _self;
// convert parameter column
column = (gint) _column;
// call function
gtk_icon_view_set_text_column(self, column);
// cleanup parameter self
// cleanup parameter column
}
// Iconview Dialog
static void
mud_connections_show_icon_dialog(MudConnections *conn)
{
GladeXML *glade;
gint result;
glade = glade_xml_new(GLADEDIR "/muds.glade", "iconselect", NULL);
conn->priv->icon_dialog = glade_xml_get_widget(glade, "iconselect");
conn->priv->icon_dialog_view = glade_xml_get_widget(glade, "view");
conn->priv->icon_dialog_chooser =
glade_xml_get_widget(glade, "chooser");
g_object_unref(glade);
conn->priv->icon_dialog_view_model =
GTK_TREE_MODEL(gtk_list_store_new(MODEL_COLUMN_N,
G_TYPE_STRING,
GDK_TYPE_PIXBUF));
gtk_icon_view_set_model(GTK_ICON_VIEW(conn->priv->icon_dialog_view),
conn->priv->icon_dialog_view_model);
gtk_icon_view_set_text_column(
GTK_ICON_VIEW(conn->priv->icon_dialog_view),
MODEL_COLUMN_STRING);
gtk_icon_view_set_pixbuf_column(
GTK_ICON_VIEW(conn->priv->icon_dialog_view),
MODEL_COLUMN_PIXBUF);
if(conn->priv->icon_current != NULL)
g_free(conn->priv->icon_current);
conn->priv->icon_current = NULL;
g_signal_connect(
conn->priv->icon_dialog_chooser, "current-folder-changed",
G_CALLBACK(mud_connections_icon_fileset_cb),
conn);
g_signal_connect(conn->priv->icon_dialog_view, "selection-changed",
G_CALLBACK(mud_connections_icon_select_cb),
conn);
g_object_set(conn->priv->icon_dialog_view, "item-width", 64, NULL);
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(conn->priv->icon_dialog_chooser),
"/usr/share/icons");
result = gtk_dialog_run(GTK_DIALOG(conn->priv->icon_dialog));
gtk_widget_destroy(conn->priv->icon_dialog);
if(result == GTK_RESPONSE_OK)
{
if(conn->priv->icon_current == NULL)
return;
GdkPixbuf *icon = gdk_pixbuf_new_from_file_at_size(
conn->priv->icon_current, 48, 48, NULL);
gtk_image_set_from_pixbuf(GTK_IMAGE(conn->priv->icon_image),
icon);
g_object_unref(icon);
}
}
void addGroup (const gchar *name, const gchar *icon_path,
const gchar *nick, const gchar *sort_key)
{
// calculate position
int pos;
{
std::list <std::string>::iterator it;
for (it = sort_keys.begin(), pos = 0; it != sort_keys.end(); it++, pos++)
if (strcmp (it->c_str(), sort_key) >= 0)
break;
sort_keys.insert (it, sort_key);
}
// label widget
GtkWidget *tab_label, *image, *label;
GdkPixbuf *icon = NULL;
if (icon_path) {
GError *error = 0;
std::string path = ICONS + std::string (icon_path) + ".png";
icon = gdk_pixbuf_new_from_file (path.c_str(), &error);
if (!icon)
g_warning ("Could not load icon: %s.\nReason: %s", icon_path, error->message);
}
tab_label = gtk_hbox_new (FALSE, 0);
label = gtk_label_new (name);
if (icon)
image = gtk_image_new_from_pixbuf (icon);
if (icon)
gtk_box_pack_start (GTK_BOX (tab_label), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tab_label), label, TRUE, TRUE, icon ? 6 : 0);
// page widget
GtkListStore *store = gtk_list_store_new (3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
m_stores [nick] = store;
GtkWidget *icons_view;
icons_view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store));
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icons_view), 0);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icons_view), 1);
g_signal_connect(G_OBJECT (icons_view), "item-activated",
G_CALLBACK (executeCommand), this);
GtkWidget *page;
page = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (page),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (page), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (page), icons_view);
// add those to the notebook
gtk_widget_show_all (tab_label);
gtk_notebook_insert_page_menu (GTK_NOTEBOOK (m_widget), page, tab_label, NULL, pos);
}
static void
fcitx_main_window_init(FcitxMainWindow* self)
{
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
self->pagestore = _fcitx_main_window_create_model();
self->pageview = gtk_icon_view_new_with_model(GTK_TREE_MODEL(self->pagestore));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(self->pageview), PAGE_LIST_ICON);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(self->pageview), PAGE_LIST_NAME);
#if GTK_CHECK_VERSION(2, 22, 0)
gtk_icon_view_set_item_orientation(GTK_ICON_VIEW(self->pageview), GTK_ORIENTATION_VERTICAL);
#endif
_fcitx_main_window_add_im_page(self);
_fcitx_main_window_add_config_file_page(self);
_fcitx_main_window_add_addon_page(self);
gtk_widget_set_size_request(GTK_WIDGET(self), -1, 500);
self->vbox = gtk_vbox_new(FALSE, 0);
self->pagelabel = gtk_label_new("");
gtk_label_set_use_markup(GTK_LABEL(self->pagelabel), true);
gtk_misc_set_alignment(GTK_MISC(self->pagelabel), 0, 0.5);
gtk_box_pack_start(GTK_BOX(self->vbox), self->pagelabel, FALSE, FALSE, 14);
GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_container_add(GTK_CONTAINER(scrolledwindow), self->pageview);
gtk_box_pack_start(GTK_BOX(hbox), scrolledwindow, FALSE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(hbox), self->vbox, TRUE, TRUE, 8);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 8);
gtk_container_add(GTK_CONTAINER(self), vbox);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(self->pageview), GTK_SELECTION_SINGLE);
gtk_icon_view_set_item_padding(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_margin(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_column_spacing(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_row_spacing(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_item_width(GTK_ICON_VIEW(self->pageview), 96);
g_signal_connect_swapped(G_OBJECT(self), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(self->pageview), "selection-changed",
G_CALLBACK(_fcitx_main_window_selection_changed_cb), self);
GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(self->pagestore), &self->impage->iter);
gtk_icon_view_select_path(GTK_ICON_VIEW(self->pageview), path);
gtk_tree_path_free(path);
gtk_window_set_icon_name(GTK_WINDOW(self), "fcitx-configtool");
gtk_window_set_title(GTK_WINDOW(self), _("Fcitx Config"));
}
static GtkWidget *
get_view (gboolean first)
{
GtkWidget *view;
view = gtk_icon_view_new_with_model (get_filter_model (first));
gtk_icon_view_set_text_column (GTK_ICON_VIEW (view), 0);
gtk_widget_set_size_request (view, 0, -1);
return view;
}
static int _settings(void)
{
Settings settings;
GtkAccelGroup * accel;
GtkWidget * widget;
GtkListStore * store;
GtkTreeModel * model;
accel = gtk_accel_group_new();
settings.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(settings.window), accel);
desktop_accel_create(_settings_accel, &settings, accel);
g_object_unref(accel);
gtk_window_set_default_size(GTK_WINDOW(settings.window), 400, 300);
gtk_window_set_icon_name(GTK_WINDOW(settings.window),
GTK_STOCK_PREFERENCES);
gtk_window_set_title(GTK_WINDOW(settings.window),
_("System preferences"));
g_signal_connect_swapped(settings.window, "delete-event", G_CALLBACK(
_settings_on_closex), NULL);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(SC_COUNT,
GDK_TYPE_PIXBUF, /* SC_ICON */
G_TYPE_STRING, /* SC_NAME */
G_TYPE_STRING, /* SC_EXEC */
G_TYPE_BOOLEAN); /* SC_PRIVILEGED */
model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
_settings_on_filter_view, &settings, NULL);
model = gtk_tree_model_sort_new_with_model(model);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), SC_NAME,
GTK_SORT_ASCENDING);
settings.view = gtk_icon_view_new_with_model(model);
gtk_icon_view_set_item_width(GTK_ICON_VIEW(settings.view), 96);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(settings.view), SC_ICON);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(settings.view), SC_NAME);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(settings.view),
GTK_SELECTION_SINGLE);
#if GTK_CHECK_VERSION(2, 10, 0)
g_signal_connect(settings.view, "item-activated", G_CALLBACK(
_settings_on_item_activated), &settings);
#endif
gtk_container_add(GTK_CONTAINER(widget), settings.view);
gtk_container_add(GTK_CONTAINER(settings.window), widget);
gtk_widget_show_all(settings.window);
g_idle_add(_settings_on_idle, &settings);
gtk_main();
return 0;
}
GtkWidget *
create_icon_view(void) {
GtkListStore *list_store;
GtkWidget *widget;
assert(list_store);
list_store = gtk_list_store_new(N_COLS, G_TYPE_STRING, GDK_TYPE_PIXBUF);
widget = gtk_icon_view_new_with_model(GTK_TREE_MODEL(list_store));
gtk_icon_view_set_text_column(GTK_ICON_VIEW(widget), COL_NAME);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(widget), COL_ICON);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(widget), GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_margin(GTK_ICON_VIEW(widget), 4);
gtk_icon_view_set_spacing(GTK_ICON_VIEW(widget), 5);
gtk_icon_view_set_item_width(GTK_ICON_VIEW(widget), 80);
g_signal_connect(G_OBJECT(widget), "item-activated", G_CALLBACK(handle_icon_view_item_activated), NULL);
return widget;
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *icon_view;
GtkWidget *sw;
gtk_init (&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), "Icon View");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_widget_set_size_request(window, 350, 330);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER (window), sw);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
icon_view = gtk_icon_view_new_with_model(init_model());
gtk_container_add(GTK_CONTAINER(sw), icon_view);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view),
COL_DISPLAY_NAME);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view),
COL_PIXBUF);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(icon_view),
GTK_SELECTION_MULTIPLE);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main(int argc, char** argv)
{
GtkWidget *window;
GtkWidget *scroll_window;
GtkWidget *iconview;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "IconView");
gtk_widget_set_size_request(window, 500, 300);
gtk_container_set_border_width(GTK_CONTAINER(window), 5);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
scroll_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(window), scroll_window);
iconview = create_icon_view_widget();
//表示項目のラベル設定
gtk_icon_view_set_text_column(GTK_ICON_VIEW(iconview), COLUMN_NAME);
//表示項目の画像設定
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(iconview), COLUMN_PIXBUF);
//アイテムの幅を設定
gtk_icon_view_set_item_width(GTK_ICON_VIEW(iconview), 128);
//表示されているアイテムがダブルクリックされた時に発生するシグナル
g_signal_connect(G_OBJECT(iconview), "item-activated", G_CALLBACK(cb_item_activated), NULL);
gtk_container_add(GTK_CONTAINER(scroll_window), iconview);
add_data(GTK_ICON_VIEW(iconview));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static GtkIconView* graph_media_modelos_sentimientos_real_filtrar (GraphMediaModelosFiltrable* base, const gchar* consulta, gint lim) {
GraphMediaModelosSentimientos * self;
GtkIconView* result = NULL;
Block9Data* _data9_;
GeeArrayList* sentimientos = NULL;
GeeArrayList* _tmp0_ = NULL;
GtkListStore* _tmp1_ = NULL;
GtkListStore* _tmp2_ = NULL;
GtkIconView* _tmp3_ = NULL;
GtkIconView* _tmp4_ = NULL;
GtkIconView* _tmp5_ = NULL;
GtkIconView* _tmp6_ = NULL;
GtkIconView* _tmp28_ = NULL;
GtkIconView* _tmp29_ = NULL;
GtkIconView* _tmp30_ = NULL;
self = (GraphMediaModelosSentimientos*) base;
g_return_val_if_fail (consulta != NULL, NULL);
_data9_ = g_slice_new0 (Block9Data);
_data9_->_ref_count_ = 1;
_data9_->self = g_object_ref (self);
_tmp0_ = graph_media_modelos_sentimientos_lista_sentimientos (self);
sentimientos = _tmp0_;
_tmp1_ = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT64, -1);
_data9_->model = _tmp1_;
_tmp2_ = _data9_->model;
_tmp3_ = (GtkIconView*) gtk_icon_view_new_with_model ((GtkTreeModel*) _tmp2_);
g_object_ref_sink (_tmp3_);
_data9_->vista = _tmp3_;
_tmp4_ = _data9_->vista;
gtk_icon_view_set_pixbuf_column (_tmp4_, 0);
_tmp5_ = _data9_->vista;
gtk_icon_view_set_text_column (_tmp5_, 1);
_tmp6_ = _data9_->vista;
gtk_icon_view_set_item_width (_tmp6_, 120);
memset (&_data9_->iter, 0, sizeof (GtkTreeIter));
{
GeeArrayList* _a_list = NULL;
GeeArrayList* _tmp7_ = NULL;
GeeArrayList* _tmp8_ = NULL;
gint _a_size = 0;
GeeArrayList* _tmp9_ = NULL;
gint _tmp10_ = 0;
gint _tmp11_ = 0;
gint _a_index = 0;
_tmp7_ = sentimientos;
_tmp8_ = _g_object_ref0 (_tmp7_);
_a_list = _tmp8_;
_tmp9_ = _a_list;
_tmp10_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp9_);
_tmp11_ = _tmp10_;
_a_size = _tmp11_;
_a_index = -1;
while (TRUE) {
gint _tmp12_ = 0;
gint _tmp13_ = 0;
gint _tmp14_ = 0;
GraphMediaModelosSentimiento* a = NULL;
GeeArrayList* _tmp15_ = NULL;
gint _tmp16_ = 0;
gpointer _tmp17_ = NULL;
GtkListStore* _tmp18_ = NULL;
GtkTreeIter _tmp19_ = {0};
GtkListStore* _tmp20_ = NULL;
GtkTreeIter _tmp21_ = {0};
GdkPixbuf* _tmp22_ = NULL;
GdkPixbuf* _tmp23_ = NULL;
GraphMediaModelosSentimiento* _tmp24_ = NULL;
const gchar* _tmp25_ = NULL;
GraphMediaModelosSentimiento* _tmp26_ = NULL;
gint64 _tmp27_ = 0LL;
_tmp12_ = _a_index;
_a_index = _tmp12_ + 1;
_tmp13_ = _a_index;
_tmp14_ = _a_size;
if (!(_tmp13_ < _tmp14_)) {
break;
}
_tmp15_ = _a_list;
_tmp16_ = _a_index;
_tmp17_ = gee_abstract_list_get ((GeeAbstractList*) _tmp15_, _tmp16_);
a = (GraphMediaModelosSentimiento*) _tmp17_;
_tmp18_ = _data9_->model;
gtk_list_store_append (_tmp18_, &_tmp19_);
_data9_->iter = _tmp19_;
_tmp20_ = _data9_->model;
_tmp21_ = _data9_->iter;
_tmp22_ = graph_media_modelos_filtrable_cargar_icono_ubicacion ((GraphMediaModelosFiltrable*) self, "sentimiento", GRAPH_MEDIA_MODELOS_APP_GUI_TAM_ICONO, GRAPH_MEDIA_MODELOS_APP_GUI_TAM_ICONO);
_tmp23_ = _tmp22_;
_tmp24_ = a;
_tmp25_ = _tmp24_->nombre;
_tmp26_ = a;
_tmp27_ = _tmp26_->id;
gtk_list_store_set (_tmp20_, &_tmp21_, 0, _tmp23_, 1, _tmp25_, 2, _tmp27_, -1);
_g_object_unref0 (_tmp23_);
_graph_media_modelos_sentimiento_unref0 (a);
}
_g_object_unref0 (_a_list);
}
_tmp28_ = _data9_->vista;
g_signal_connect_data (_tmp28_, "selection-changed", (GCallback) ___lambda5__gtk_icon_view_selection_changed, block9_data_ref (_data9_), (GClosureNotify) block9_data_unref, 0);
_tmp29_ = _data9_->vista;
_tmp30_ = _g_object_ref0 (_tmp29_);
result = _tmp30_;
_g_object_unref0 (sentimientos);
block9_data_unref (_data9_);
_data9_ = NULL;
return result;
}
/* The main GUI function for saving multi-paged PDFs */
static gboolean
gui_multi (void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *file_label;
GtkWidget *file_entry;
GtkWidget *file_browse;
GtkWidget *file_hbox;
GtkWidget *vectorize_c;
GtkWidget *ignore_hidden_c;
GtkWidget *apply_c;
GtkWidget *scroll;
GtkWidget *page_view;
GtkWidget *h_but_box;
GtkWidget *del;
GtkWidget *h_box;
GtkWidget *img_combo;
GtkWidget *add_image;
gboolean run;
const gchar *temp;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_MULTI_PROC);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
file_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
file_label = gtk_label_new (_("Save to:"));
file_entry = gtk_entry_new ();
if (file_name != NULL)
gtk_entry_set_text (GTK_ENTRY (file_entry), file_name);
file_browse = gtk_button_new_with_label (_("Browse..."));
file_choose = gtk_file_chooser_dialog_new (_("Multipage PDF export"),
GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE,
"gtk-save", GTK_RESPONSE_OK,
"gtk-cancel", GTK_RESPONSE_CANCEL,
NULL);
gtk_box_pack_start (GTK_BOX (file_hbox), file_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (file_hbox), file_entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (file_hbox), file_browse, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), file_hbox, TRUE, TRUE, 0);
page_view = gtk_icon_view_new ();
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (page_view), model);
gtk_icon_view_set_reorderable (GTK_ICON_VIEW (page_view), TRUE);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (page_view), GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (page_view), THUMB);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (page_view), PAGE_NUMBER);
gtk_icon_view_set_tooltip_column (GTK_ICON_VIEW (page_view), IMAGE_NAME);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scroll, -1, 300);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (scroll), page_view);
gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
h_but_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (h_but_box), GTK_BUTTONBOX_START);
del = gtk_button_new_with_label (_("Remove the selected pages"));
gtk_box_pack_start (GTK_BOX (h_but_box), del, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), h_but_box, FALSE, FALSE, 0);
h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
img_combo = gimp_image_combo_box_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (h_box), img_combo, FALSE, FALSE, 0);
add_image = gtk_button_new_with_label (_("Add this image"));
gtk_box_pack_start (GTK_BOX (h_box), add_image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), h_box, FALSE, FALSE, 0);
ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden);
gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, FALSE, FALSE, 0);
vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize);
gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, FALSE, FALSE, 0);
apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks);
gtk_box_pack_end (GTK_BOX (vbox), apply_c, FALSE, FALSE, 0);
gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL);
gtk_widget_show_all (window);
g_signal_connect (G_OBJECT (file_browse), "clicked",
G_CALLBACK (choose_file_call), G_OBJECT (file_entry));
g_signal_connect (G_OBJECT (add_image), "clicked",
G_CALLBACK (add_image_call), G_OBJECT (img_combo));
g_signal_connect (G_OBJECT (del), "clicked",
G_CALLBACK (del_image_call), G_OBJECT (page_view));
g_signal_connect (G_OBJECT (model), "row-deleted",
G_CALLBACK (remove_call), NULL);
run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK;
run &= get_image_list ();
temp = gtk_entry_get_text (GTK_ENTRY (file_entry));
g_stpcpy (file_name, temp);
optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c));
optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c));
optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c));
gtk_widget_destroy (window);
return run;
}
Compose * compose_new(Config * config)
{
Compose * compose;
GtkAccelGroup * group;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkToolItem * toolitem;
GtkSizeGroup * sizegroup;
GtkWidget * vpaned;
GtkWidget * vbox2;
GtkWidget * widget;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GtkTreeIter iter;
char const * headers[] = {
"To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:",
"Followup-To:" };
size_t i;
if((compose = malloc(sizeof(*compose))) == NULL)
{
compose_error(NULL, strerror(errno), 0);
return NULL;
}
compose->mime = mime_new(NULL);
/* check errors */
if(compose->mime == NULL)
{
free(compose);
return NULL;
}
compose->config = config;
compose->standalone = FALSE;
/* window */
group = gtk_accel_group_new();
compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(compose->window), group);
#ifndef EMBEDDED
gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384);
#else
gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300);
#endif
gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose"));
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer");
#endif
g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event",
G_CALLBACK(_compose_on_closex), compose);
vbox = gtk_vbox_new(FALSE, 0);
/* menubar */
#ifndef EMBEDDED
widget = desktop_menubar_create(_compose_menubar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
#endif
/* toolbar */
toolbar = desktop_toolbar_create(_compose_toolbar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* from */
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("From: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_widget_set_size_request(widget, 80, -1);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
#if GTK_CHECK_VERSION(2, 24, 0)
compose->from = gtk_combo_box_text_new_with_entry();
#else
compose->from = gtk_combo_box_entry_new_text();
#endif
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->from);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* paned */
vpaned = gtk_vpaned_new();
/* headers */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN);
compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(
compose->h_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(
compose->h_store_filter),
_compose_on_headers_filter, compose, NULL);
compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
compose->h_store_filter));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view),
FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE);
compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_STRING);
for(i = 0; i < sizeof(headers) / sizeof(*headers); i++)
{
gtk_list_store_append(compose->h_headers, &iter);
gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1,
headers[i], -1);
}
renderer = gtk_cell_renderer_combo_new();
g_object_set(renderer, "editable", TRUE, "model", compose->h_headers,
"text-column", 1, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_field_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_HEADER, NULL);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_VALUE, NULL);
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_tree_view_column_set_expand(column, TRUE);
#endif
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
/* default to 8-bits transfers with UTF-8 encoding */
compose_set_header(compose, "Content-Transfer-Encoding:", "8bit",
FALSE);
compose_set_header(compose, "Content-Type:",
"text/plain; charset=UTF-8", FALSE);
compose_add_field(compose, "To:", NULL);
gtk_container_add(GTK_CONTAINER(widget), compose->h_view);
gtk_paned_add1(GTK_PANED(vpaned), widget);
/* paned */
vbox2 = gtk_vbox_new(FALSE, 0);
/* subject */
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("Subject: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
compose->subject = gtk_entry_new();
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->subject);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0);
/* view */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->view = _new_text_view(compose);
compose_set_font(compose, _compose_get_font(compose));
gtk_container_add(GTK_CONTAINER(widget), compose->view);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
gtk_paned_add2(GTK_PANED(vpaned), vbox2);
gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
/* attachments */
compose->a_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, GDK_TYPE_PIXBUF);
compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(
compose->a_store));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view),
CAC_ICON);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view),
GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view),
CAC_BASENAME);
gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view);
gtk_widget_show_all(compose->a_view);
gtk_widget_set_no_show_all(compose->a_window, TRUE);
gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0);
/* statusbar */
compose->statusbar = gtk_statusbar_new();
compose->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(compose->window), vbox);
/* about dialog */
compose->ab_window = NULL;
/* signature */
compose_append_signature(compose);
compose_set_modified(compose, FALSE);
compose_scroll_to_offset(compose, 0);
/* display */
gtk_widget_grab_focus(compose->view);
gtk_widget_show_all(vbox);
gtk_widget_show(compose->window);
return compose;
}
/*
* Set up the window: build the interface, connect the signals, insert the
* file icons.
*/
static GtkWidget *
prepare_window(char *dir, struct geometry *geometry, struct state *d)
{
GtkBuilder *builder;
GtkWidget *icons, *window, *directory_close, *file_open;
GtkWidget *directory_up, *directory_open, *help_about;
GtkListStore *model;
builder = gtk_builder_new_from_file(INTERFACE_PATH);
window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
icons = GTK_WIDGET(gtk_builder_get_object(builder, "icons"));
directory_up = GTK_WIDGET(gtk_builder_get_object(builder, "directory-up-menu-item"));
directory_open = GTK_WIDGET(gtk_builder_get_object(builder, "directory-open-menu-item"));
directory_close = GTK_WIDGET(gtk_builder_get_object(builder, "directory-close-menu-item"));
file_open = GTK_WIDGET(gtk_builder_get_object(builder, "file-open-menu-item"));
help_about = GTK_WIDGET(gtk_builder_get_object(builder, "help-about-menu-item"));
d->icon_view = GTK_ICON_VIEW(icons);
g_object_unref(builder);
gtk_window_set_default_size(GTK_WINDOW(window), geometry->w,
geometry->h);
gtk_window_move(GTK_WINDOW(window), geometry->x, geometry->y);
gtk_window_set_title(GTK_WINDOW(window), dir);
model = gtk_list_store_new(MODEL_CNT,
G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
if (populate(model, dir) == -1)
err(66, "failed to populate icon model from %s", dir);
watch_dir(model, dir);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icons), 0);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icons), 1);
gtk_icon_view_set_model(GTK_ICON_VIEW(icons), GTK_TREE_MODEL(model));
g_object_unref(model);
gtk_widget_set_sensitive(directory_up, strlen(d->dir) > 1);
/* Drag */
gtk_drag_source_set(icons, GDK_BUTTON1_MASK,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_add_text_targets(icons);
gtk_drag_source_add_uri_targets(icons);
g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d);
g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d);
g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d);
/* Drop */
gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_text_targets(icons);
gtk_drag_dest_add_uri_targets(icons);
g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d);
g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d);
g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d);
/* Activations */
g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "configure-event", G_CALLBACK(on_window_configure_event), dir);
g_signal_connect(directory_up, "activate", G_CALLBACK(on_directory_up_menu_item_activate), d);
g_signal_connect(directory_open, "activate", G_CALLBACK(on_directory_open_menu_item_activate), d);
g_signal_connect(directory_close, "activate", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(file_open, "activate", G_CALLBACK(on_file_open_menu_item_activate), d);
g_signal_connect(help_about, "activate", G_CALLBACK(on_help_about_menu_item_activate), NULL);
g_signal_connect(icons, "button-press-event", G_CALLBACK(on_icons_button_press_event), d);
return window;
}
static GtkWidget*
create_icon_view ()
{
GtkWidget *scroll = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *icon_view = gtk_icon_view_new ();
int col_text = 0,col_icon = 1;
GtkTreeModel *list_model = gtk_list_store_new (2,
G_TYPE_STRING,
GDK_TYPE_PIXBUF );
gtk_icon_view_set_model (GTK_ICON_VIEW (icon_view), list_model);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_view), col_text);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_view), col_icon);
gtk_icon_view_set_item_width (GTK_ICON_VIEW (icon_view), 100);
GtkTreeIter iter;
GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
GList *contxt_list, *icon_names_list, *ctx, *icn;
gint max_icons = 100;
gint icon_size = 32;
ctx = contxt_list = gtk_icon_theme_list_contexts (icon_theme);
while (ctx && max_icons) {
gchar *context = ctx->data;
icn = icon_names_list = gtk_icon_theme_list_icons (icon_theme, context);
g_debug ("Context %s: %d icons listed", context, g_list_length (icn));
while (icn && max_icons) {
gchar *icon_name = icn->data;
g_debug (" - %s", icon_name);
GdkPixbuf *pixbuf = NULL;
pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name,
icon_size, GTK_ICON_LOOKUP_FORCE_SVG, NULL);
if (pixbuf != NULL){
gtk_list_store_append (list_model, &iter);
gtk_list_store_set (list_model, &iter,
col_text, icon_name,
col_icon, pixbuf,
-1);
--max_icons;
}else{
g_free (icon_name);
}
icn = g_list_next (icn);
}
g_list_free (icon_names_list);
g_free (context);
ctx = g_list_next (ctx);
}
g_list_free (contxt_list);
gtk_container_add (GTK_CONTAINER (scroll), icon_view);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_name (scroll, "Icon View");
return scroll;
}
int main(int argc, char** argv) {
//gtk wdiget init start...
GtkWidget *window, *icon_view, *notebook;
GtkWidget *current_user_name, *current_time, *network_speed;
GtkWidget *home_button, *access_token_entry, *access_token_ok_button;
GtkWidget *access_token_cancel_button;
GtkWidget *get_access_token_button, *post_blog_title_entry;
GtkWidget *post_blog_content_text_view, *post_blog_content_text_buffer;
GtkWidget *post_blog_ok_button, *post_blog_cancel_button;
GtkWidget *blog_access_permission, *blog_password;
GList *post_blog_page = NULL;
GtkBuilder *builder;
GError *error = NULL;
//widget init
gtk_init(&argc, &argv);
builder = gtk_builder_new();
if(!gtk_builder_add_from_file(builder, "./sources/glade.glade", &error))
{
g_print("Error occured while loading UI files\n");
g_print("Message: %s\n", error->message);
g_free(error);
return 1;
}
//widget get from builder(glade files)
window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook1"));
icon_view = GTK_WIDGET(gtk_builder_get_object(builder, "iconview1"));
current_user_name = GTK_WIDGET(gtk_builder_get_object(builder,"label4"));
current_time = GTK_WIDGET(gtk_builder_get_object(builder, "label5"));
network_speed = GTK_WIDGET(gtk_builder_get_object(builder, "label6"));
access_token_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button3"));
access_token_cancel_button = GTK_WIDGET(gtk_builder_get_object(builder, "button6"));
get_access_token_button = GTK_WIDGET(gtk_builder_get_object(builder, "button2"));
home_button = GTK_WIDGET(gtk_builder_get_object(builder, "button1"));
access_token_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry1"));
post_blog_content_text_view= GTK_WIDGET(gtk_builder_get_object(builder, "textview1"));
post_blog_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button4"));
post_blog_title_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry2"));
blog_access_permission = GTK_WIDGET(gtk_builder_get_object(builder, "comboboxtext1"));
blog_password = GTK_WIDGET(gtk_builder_get_object(builder, "entry4"));
//set object attributes
gtk_window_set_title(GTK_WINDOW(window), "Xiao nei Gtk App");
gtk_window_set_default_size(GTK_WINDOW(window), 800, 400);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_icon_view_set_model(GTK_ICON_VIEW(icon_view), create_model());
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view), COL_DISPLAY_NAME);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), COL_PIXBUF);
gtk_icon_view_set_columns(GTK_ICON_VIEW(icon_view), 4);
gtk_label_set_text(GTK_LABEL(current_user_name), "Current user:fengtianba");
g_timeout_add_seconds(1, (GSourceFunc)set_label_time, current_time);
gtk_label_set_text(GTK_LABEL(network_speed), "Network Speed:100M");
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
int n = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), icon_view);
//gtk_combo_box_set_model(GTK_COMBO_BOX(blog_access_permission), create_combo_box_tree_model());
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "private", "PRIVATE");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "public", "PUBLIC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "password", "PASSWORD");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "friend", "FRIEND");
printf("n is %d\n", n);
struct tm *time_ptr;
time_t the_time;
char *time_malloc;
(void)time(&the_time);
time_ptr = localtime(&the_time);
time_malloc = malloc(sizeof(struct tm));
memset(time_malloc, 0, sizeof(struct tm));
sprintf(time_malloc, "%d/%d/%d/%d:%d:%d", 1900 + time_ptr->tm_year, time_ptr->tm_mon, time_ptr->tm_mday,
time_ptr->tm_hour, time_ptr->tm_min, time_ptr->tm_sec);
gtk_label_set_text(GTK_LABEL(current_time), time_malloc);
post_blog_page = g_list_append(post_blog_page, post_blog_title_entry);
post_blog_page = g_list_append(post_blog_page, post_blog_content_text_view);
post_blog_page = g_list_append(post_blog_page, blog_access_permission);
post_blog_page = g_list_append(post_blog_page, blog_password);
//signal to connect to widget
g_signal_connect(window, "delete-event", gtk_main_quit, NULL);
g_signal_connect(GTK_BUTTON(get_access_token_button), "clicked", G_CALLBACK(get_access_token_button_clicked), NULL);
g_signal_connect(GTK_ICON_VIEW(icon_view), "item-activated", G_CALLBACK(icon_view_item_select), notebook);
g_signal_connect(GTK_BUTTON(home_button), "clicked", G_CALLBACK(home_button_clicked), notebook);
g_signal_connect(GTK_BUTTON(access_token_ok_button), "clicked", G_CALLBACK(access_token_ok_button_clicked), access_token_entry);
g_signal_connect(GTK_BUTTON(post_blog_ok_button), "clicked", G_CALLBACK(post_blog_ok_button_clicked), post_blog_page);
//object unref
g_object_unref(G_OBJECT(builder));
//show widget
gtk_widget_show_all(window);
gtk_main();
int i = 100;
char *decode_string;
/*CURL *curl;
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
decode_string = curl_easy_unescape(curl, ACCESS_TOKEN, 0, &i);
printf("origin url: %s\n", ACCESS_TOKEN);
printf("new url: %s\n", decode_string);
curl_easy_cleanup(curl);*/
//puts("enter access token\n");
//scanf("%s", accesstoken);
//调用自己写的SDK
xiaonei_gtk_get_blog_list(accesstoken);
xiaonei_gtk_get_one_blog(accesstoken);
return (EXIT_SUCCESS);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *paned, *tv;
GtkWidget *window, *icon_list, *scrolled_window;
GtkWidget *vbox, *bbox;
GtkWidget *button;
GtkWidget *prop_editor;
GtkTreeModel *model;
GtkCellRenderer *cell;
GtkTreeViewColumn *tvc;
gtk_init (&argc, &argv);
/* to test rtl layout, set RTL=1 in the environment */
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 700, 400);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE);
tv = gtk_tree_view_new ();
tvc = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc);
g_signal_connect_after (icon_list, "button_press_event",
G_CALLBACK (button_press_event_handler), NULL);
g_signal_connect (icon_list, "selection_changed",
G_CALLBACK (selection_changed), NULL);
g_signal_connect (icon_list, "popup_menu",
G_CALLBACK (popup_menu_handler), NULL);
g_signal_connect (icon_list, "item_activated",
G_CALLBACK (item_activated), NULL);
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (icon_list), model);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), model);
fill_model (model);
#if 0
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_list), 0);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_list), 1);
#else
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"editable", TRUE,
"xalign", 0.5,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", 100,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
/* now the tree view... */
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "editable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
#endif
/* Allow DND between the icon view and the tree view */
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (icon_list),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_icon_view_enable_model_drag_dest (GTK_ICON_VIEW (icon_list),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
prop_editor = create_prop_editor (G_OBJECT (icon_list), 0);
gtk_widget_show_all (prop_editor);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled_window);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tv);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add some");
g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add many");
g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add large");
g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Remove selected");
g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Swap");
g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Select all");
g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Unselect all");
g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Select nonexisting");
g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static GObject *
mud_connections_constructor (GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
MudConnections *conn;
GladeXML *glade;
GConfClient *client;
GtkWidget *main_window;
GObject *obj;
MudConnectionsClass *klass;
GObjectClass *parent_class;
/* Chain up to parent constructor */
klass = MUD_CONNECTIONS_CLASS( g_type_class_peek(MUD_TYPE_CONNECTIONS) );
parent_class = G_OBJECT_CLASS( g_type_class_peek_parent(klass) );
obj = parent_class->constructor(gtype, n_properties, properties);
conn = MUD_CONNECTIONS(obj);
if(!conn->parent_window)
g_error("Tried to instantiate MudConnections without passing parent MudWindow\n");
g_object_get(conn->parent_window,
"window", &conn->priv->winwidget,
"tray", &conn->priv->tray,
NULL);
glade = glade_xml_new(GLADEDIR "/muds.glade", "mudviewwindow", NULL);
conn->priv->window = glade_xml_get_widget(glade, "mudviewwindow");
conn->priv->iconview = glade_xml_get_widget(glade, "iconview");
conn->priv->qconnect_host_entry =
glade_xml_get_widget(glade, "qconnect_host_entry");
conn->priv->qconnect_port_entry =
glade_xml_get_widget(glade, "qconnect_port_entry");
conn->priv->qconnect_connect_button =
glade_xml_get_widget(glade, "qconnect_connect_button");
conn->priv->icon_model =
GTK_TREE_MODEL(gtk_list_store_new(MODEL_COLUMN_N,
G_TYPE_STRING,
GDK_TYPE_PIXBUF));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(conn->priv->icon_model),
MODEL_COLUMN_STRING,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(conn->priv->icon_model),
MODEL_COLUMN_STRING,
mud_connections_compare_func,
NULL,
NULL);
conn->priv->original_name = NULL;
conn->priv->original_char_name = NULL;
gtk_icon_view_set_model(GTK_ICON_VIEW(conn->priv->iconview),
conn->priv->icon_model);
g_object_unref(conn->priv->icon_model);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(conn->priv->iconview),
MODEL_COLUMN_STRING);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(conn->priv->iconview),
MODEL_COLUMN_PIXBUF);
client = gconf_client_get_default();
gconf_client_add_dir(client, "/apps/gnome-mud/muds",
GCONF_CLIENT_PRELOAD_NONE, NULL);
conn->priv->connection =
gconf_client_notify_add(client, "/apps/gnome-mud/muds",
(GConfClientNotifyFunc)
mud_connections_gconf_notify_cb,
conn, NULL, NULL);
g_signal_connect(conn->priv->iconview, "item-activated",
G_CALLBACK(mud_connections_iconview_activate_cb),
conn);
g_signal_connect(conn->priv->iconview, "button-press-event",
G_CALLBACK(mud_connections_button_press_cb),
conn);
g_signal_connect(conn->priv->window, "destroy",
G_CALLBACK(mud_connections_close_cb), conn);
g_signal_connect(glade_xml_get_widget(glade, "connect_button"),
"clicked", G_CALLBACK(mud_connections_connect_cb),
conn);
g_signal_connect(glade_xml_get_widget(glade, "add_button"),
"clicked", G_CALLBACK(mud_connections_add_cb), conn);
g_signal_connect(glade_xml_get_widget(glade, "delete_button"),
"clicked", G_CALLBACK(mud_connections_delete_cb),
conn);
g_signal_connect(glade_xml_get_widget(glade, "properties_button"),
"clicked", G_CALLBACK(mud_connections_properties_cb),
conn);
g_signal_connect(conn->priv->qconnect_connect_button, "clicked",
G_CALLBACK(mud_connections_qconnect_cb), conn);
mud_connections_populate_iconview(conn);
g_object_get(conn->parent_window, "window", &main_window, NULL);
g_object_set(conn->priv->window,
"transient-for", GTK_WINDOW(main_window),
NULL);
gtk_widget_show_all(conn->priv->window);
g_object_unref(glade);
g_object_unref(client);
return obj;
}
static void
gimp_page_selector_init (GimpPageSelector *selector)
{
GimpPageSelectorPrivate *priv;
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *hbox;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *combo;
selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (selector,
GIMP_TYPE_PAGE_SELECTOR,
GimpPageSelectorPrivate);
priv = GIMP_PAGE_SELECTOR_GET_PRIVATE (selector);
priv->n_pages = 0;
priv->target = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
gtk_orientable_set_orientation (GTK_ORIENTABLE (selector),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (selector), 12);
/* Pages */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_start (GTK_BOX (selector), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
priv->store = gtk_list_store_new (4,
G_TYPE_INT,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
priv->view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (priv->store));
gtk_icon_view_set_text_column (GTK_ICON_VIEW (priv->view),
COLUMN_LABEL);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (priv->view),
COLUMN_THUMBNAIL);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (priv->view),
GTK_SELECTION_MULTIPLE);
gtk_container_add (GTK_CONTAINER (sw), priv->view);
gtk_widget_show (priv->view);
g_signal_connect (priv->view, "selection-changed",
G_CALLBACK (gimp_page_selector_selection_changed),
selector);
g_signal_connect (priv->view, "item-activated",
G_CALLBACK (gimp_page_selector_item_activated),
selector);
/* Count label */
priv->count_label = gtk_label_new (_("Nothing selected"));
gtk_misc_set_alignment (GTK_MISC (priv->count_label), 0.0, 0.5);
gimp_label_set_attributes (GTK_LABEL (priv->count_label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox), priv->count_label, FALSE, FALSE, 0);
gtk_widget_show (priv->count_label);
/* Select all button & range entry */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (selector), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_mnemonic (_("Select _All"));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gimp_page_selector_select_all),
selector);
priv->range_entry = gtk_entry_new ();
gtk_widget_set_size_request (priv->range_entry, 80, -1);
gtk_box_pack_end (GTK_BOX (hbox), priv->range_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->range_entry);
g_signal_connect (priv->range_entry, "focus-out-event",
G_CALLBACK (gimp_page_selector_range_focus_out),
selector);
g_signal_connect (priv->range_entry, "activate",
G_CALLBACK (gimp_page_selector_range_activate),
selector);
label = gtk_label_new_with_mnemonic (_("Select _range:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->range_entry);
/* Target combo */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (selector), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Open _pages as"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_prop_enum_combo_box_new (G_OBJECT (selector), "target", -1, -1);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
priv->default_thumbnail =
gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
"text-x-generic", 32, 0, NULL);
}
