static void PopulateForm(int pgs)
{
if (pgs & (1<<TAB_CONFIG)) {
int mode3d, i;
GtkListStore *modes3d;
GtkTreeIter iter;
GtkComboBox *box3d;
char buf[64];
mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1);
if (mode3d < 0) {
int i, cd[] = { 32, 24, 16, 15, 8, 0 };
for (i=0; cd[i]; ) {
if (cd[i] >= settings.bpp3d) i++;
else break;
}
for ( ; cd[i]; i++) {
mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1);
if (mode3d < 0) continue;
settings.bpp3d = cd[i];
break;
}
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"fullscreencheck")), settings.fullscreen);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"alwaysshowcheck")), settings.forcesetup);
box3d = GTK_COMBO_BOX(lookup_widget(startwin,"vmode3dcombo"));
modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(box3d));
gtk_list_store_clear(modes3d);
for (i=0; i<validmodecnt; i++) {
if (validmode[i].fs != settings.fullscreen) continue;
// all modes get added to the 3D mode list
Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp);
gtk_list_store_append(modes3d, &iter);
gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1);
if (i == mode3d) {
g_signal_handlers_block_by_func(box3d, on_vmode3dcombo_changed, NULL);
gtk_combo_box_set_active_iter(box3d, &iter);
g_signal_handlers_unblock_by_func(box3d, on_vmode3dcombo_changed, NULL);
}
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputmousecheck")), settings.usemouse);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputjoycheck")), settings.usejoy);
}
if (pgs & (1<<TAB_GAME)) {
struct grpfile *fg;
int i;
GtkListStore *list;
GtkTreeIter iter;
GtkTreeView *gamelist;
gamelist = GTK_TREE_VIEW(lookup_widget(startwin,"gamelist"));
list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist));
gtk_list_store_clear(list);
for (fg = foundgrps; fg; fg=fg->next) {
for (i = 0; i<numgrpfiles; i++)
if (fg->crcval == grpfiles[i].crcval) break;
if (i == numgrpfiles) continue; // unrecognised grp file
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1);
if (!Bstrcasecmp(fg->name, settings.selectedgrp)) {
GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist);
g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL);
gtk_tree_selection_select_iter(sel, &iter);
g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL);
}
}
}
}
static void exec_autoforward_menu_cb(void)
{
/* show modal dialog */
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *radio1;
GtkWidget *radio2;
GtkWidget *frame;
GtkWidget *vbox_cond;
GtkTreeIter iter;
GtkTreeViewColumn *column;
GtkWidget *view;
GtkWidget *sw;
GtkWidget *bbox;
gchar *rcpath;
gchar *to;
gsize sz=0;
GError *errval;
gchar **folders;
int nindex;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
/*gtk_widget_set_size_request(window, 200, 100);*/
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE);
gtk_widget_realize(window);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
confirm_area = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(confirm_area), 6);
ok_btn = gtk_button_new_from_stock(GTK_STOCK_OK);
GTK_WIDGET_SET_FLAGS(ok_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_area), ok_btn, FALSE, FALSE, 0);
gtk_widget_show(ok_btn);
cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(cancel_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_area), cancel_btn, FALSE, FALSE, 0);
gtk_widget_show(cancel_btn);
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_btn);
gtk_window_set_title(GTK_WINDOW(window), _("Autoforward Settings [autoforward]"));
g_signal_connect(G_OBJECT(ok_btn), "clicked",
G_CALLBACK(prefs_ok_cb), window);
g_signal_connect(G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(prefs_cancel_cb), window);
/* email settings */
hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Forward to(E-mail):"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
g_address = gtk_entry_new();
gtk_widget_show(g_address);
gtk_box_pack_start(GTK_BOX(hbox), g_address, FALSE, TRUE, 0);
/* email settings */
g_startup = gtk_check_button_new_with_label(_("Enable plugin on startup"));
gtk_widget_show(g_startup);
gtk_box_pack_start(GTK_BOX(vbox), g_startup, FALSE, FALSE, 0);
#if 0
g_unreadonly = gtk_check_button_new_with_label(_("Forward unread mail only"));
gtk_widget_show(g_unreadonly);
gtk_box_pack_start(GTK_BOX(vbox), g_unreadonly, FALSE, FALSE, 0);
#endif
/* all */
radio1 = gtk_radio_button_new_with_label(NULL, _("Forward all mail"));
/* folder filtered */
radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
_("Forward mail in folder"));
frame = gtk_frame_new(_("Forward condition:"));
gtk_widget_show(frame);
gtk_container_add(GTK_CONTAINER(vbox), frame);
vbox_cond = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox_cond);
gtk_container_add(GTK_CONTAINER(frame), vbox_cond);
gtk_box_pack_start(GTK_BOX(vbox_cond), radio1, FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox_cond), radio2, FALSE, FALSE, 6);
/* treeview */
g_folders = gtk_list_store_new(1, G_TYPE_STRING);
column = gtk_tree_view_column_new_with_attributes (_("Forward mail in following folder:"),
gtk_cell_renderer_text_new (),
"text", 0,
NULL);
view=gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_folders));
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw), view);
gtk_box_pack_start (GTK_BOX(vbox_cond), sw, TRUE, TRUE, 2);
/* add and delete */
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 6);
g_add_btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
g_delete_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_box_pack_start(GTK_BOX(bbox), g_add_btn, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bbox), g_delete_btn, FALSE, FALSE, 0);
gtk_widget_show_all(bbox);
gtk_box_pack_end(GTK_BOX(vbox_cond), bbox, FALSE, FALSE, 6);
gtk_widget_show_all(vbox_cond);
g_signal_connect (g_add_btn, "clicked",
G_CALLBACK (add_mail_folder_cb), view);
g_signal_connect (g_delete_btn, "clicked",
G_CALLBACK (delete_mail_folder_cb), view);
g_signal_connect(GTK_BUTTON(radio1), "clicked",
G_CALLBACK(forward_mail_all_cb), view);
g_signal_connect(GTK_BUTTON(radio2), "clicked",
G_CALLBACK(forward_mail_folder_cb), view);
/* load settings */
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL);
g_keyfile = g_key_file_new();
if (g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL)){
g_startup_flg = g_key_file_get_boolean (g_keyfile, "forward", "startup", NULL);
debug_print("startup:%s\n", g_startup_flg ? "true" : "false");
if (g_startup_flg){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_startup), TRUE);
}
#if 0
g_unreadonly_flg = g_key_file_get_boolean (g_keyfile, "forward", "unreadonly", NULL);
debug_print("unreadonly:%s\n", g_unreadonly_flg ? "true" : "false");
if (g_unreadonly_flg){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_unreadonly), TRUE);
}
#endif
to=g_key_file_get_string (g_keyfile, "forward", "to", NULL);
gtk_entry_set_text(GTK_ENTRY(g_address), to);
g_forward_flg=g_key_file_get_boolean (g_keyfile, "forward", "all", NULL);
if (g_forward_flg){
gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE);
}else{
g_print("activate view and radio2\n");
gtk_widget_set_sensitive(GTK_WIDGET(view), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), TRUE);
}
/**/
folders = g_key_file_get_string_list(g_keyfile, "forward", "folder", &sz, &errval);
if (folders!=NULL){
nindex=0;
for (nindex = 0; nindex < sz; nindex++){
gtk_list_store_append(g_folders, &iter);
gtk_list_store_set(g_folders, &iter, 0, folders[nindex], -1);
}
}
}else{
/* default settings */
g_startup_flg = FALSE;
g_forward_flg = TRUE;
gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE);
}
g_free(rcpath);
gtk_widget_show(window);
}
GtkWidget *
gimp_file_proc_view_new (Gimp *gimp,
GSList *procedures,
const gchar *automatic,
const gchar *automatic_help_id)
{
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *store;
GSList *list;
GtkTreeIter iter;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
store = gtk_list_store_new (NUM_COLUMNS,
GIMP_TYPE_PLUG_IN_PROCEDURE, /* COLUMN_PROC */
G_TYPE_STRING, /* COLUMN_LABEL */
G_TYPE_STRING, /* COLUMN_EXTENSIONS */
G_TYPE_STRING); /* COLUMN_HELP_ID */
view = g_object_new (GIMP_TYPE_FILE_PROC_VIEW,
"model", store,
"rules-hint", TRUE,
NULL);
g_object_unref (store);
for (list = procedures; list; list = g_slist_next (list))
{
GimpPlugInProcedure *proc = list->data;
if (! proc->prefixes_list) /* skip URL loaders */
{
const gchar *label = gimp_plug_in_procedure_get_label (proc);
gchar *help_id = gimp_plug_in_procedure_get_help_id (proc);
GSList *list2;
if (label)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_PROC, proc,
COLUMN_LABEL, label,
COLUMN_EXTENSIONS, proc->extensions,
COLUMN_HELP_ID, help_id,
-1);
}
g_free (help_id);
for (list2 = proc->extensions_list;
list2;
list2 = g_slist_next (list2))
{
GimpFileProcView *proc_view = GIMP_FILE_PROC_VIEW (view);
const gchar *ext = list2->data;
const gchar *dot = strchr (ext, '.');
if (dot && dot != ext)
proc_view->meta_extensions =
g_list_append (proc_view->meta_extensions,
g_strdup (dot + 1));
}
}
}
if (automatic)
{
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_PROC, NULL,
COLUMN_LABEL, automatic,
COLUMN_HELP_ID, automatic_help_id,
-1);
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("File Type"));
gtk_tree_view_column_set_expand (column, TRUE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_LABEL,
NULL);
gtk_tree_view_append_column (view, column);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Extensions"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_EXTENSIONS,
NULL);
gtk_tree_view_append_column (view, column);
g_signal_connect (gtk_tree_view_get_selection (view), "changed",
G_CALLBACK (gimp_file_proc_view_selection_changed),
view);
return GTK_WIDGET (view);
}
// added a call to DisplaySymbols() so window updates right away
void Callback_TextEdited(GtkCellRendererText *cell, gchar *path_string,
gchar *new_text, gpointer data) {
int OffsetArray = -999;
StrSymbol * pSymbol;
GtkTreeModel *treemodel = (GtkTreeModel *)ListStore;
GtkTreeIter iter;
/* Convert the string path to the row that has changed to a GtkIter */
gtk_tree_model_get_iter (treemodel, &iter, gtk_tree_path_new_from_string (path_string));
/* Update the GtkTreeModel with the new value */
gtk_tree_model_get (treemodel, &iter,
NUM_ARRAY, &OffsetArray,
-1);
gtk_list_store_set( ListStore, &iter,
data, new_text, -1);
//printf( "path=%s, new_text=%s, data_column=%d, offset_array=%d\n",path_string, new_text, (int)data, OffsetArray );
pSymbol = &SymbolArray[ OffsetArray ];
switch( (long)data )
{
case VAR_NAME:
if ( new_text[ 0 ]!='%' )
{
ShowMessageBox(_("Error"),_("A variable name always start with '%' character !"),_("Ok"));
}
else
{
if (TextParserForAVar( new_text, NULL, NULL, NULL, TRUE/*PartialNames*/ ) )
{
strncpy( pSymbol->VarName, new_text, LGT_VAR_NAME-1 );
pSymbol->VarName[ LGT_VAR_NAME-1 ] = '\0';
gtk_list_store_set( ListStore, &iter, data, pSymbol->VarName, -1);
if ( pSymbol->Symbol[0]=='\0' )
strcpy( pSymbol->Symbol, "***" );
InfosGene->AskConfirmationToQuit = TRUE;
}
else
{
if (ErrorMessageVarParser)
ShowMessageBox( _("Error"), ErrorMessageVarParser, _("Ok") );
else
ShowMessageBox( _("Error"), _("Unknown variable..."), _("Ok") );
}
}
break;
case SYMBOL:
strncpy( pSymbol->Symbol, new_text, LGT_SYMBOL_STRING-1 );
pSymbol->Symbol[ LGT_SYMBOL_STRING-1 ] = '\0';
gtk_list_store_set( ListStore, &iter, data, pSymbol->Symbol, -1);
InfosGene->AskConfirmationToQuit = TRUE;
break;
case COMMENT:
strncpy( pSymbol->Comment, new_text, LGT_SYMBOL_COMMENT-1 );
pSymbol->Comment[ LGT_SYMBOL_COMMENT-1 ] = '\0';
gtk_list_store_set( ListStore, &iter, data, pSymbol->Comment, -1);
InfosGene->AskConfirmationToQuit = TRUE;
break;
}
DisplaySymbols();
}
int configure_static(fwnet_interface_t *interface, GtkTreeIter iter)
{
extern GtkWidget *assistant;
GtkWidget *phboxtemp, *labeltemp;
char option[50];
char *ipaddr, *netmask, *gateway;
GtkWidget *pBoite = gtk_dialog_new_with_buttons(_("Configure static network"),
GTK_WINDOW(assistant),
GTK_DIALOG_MODAL,
GTK_STOCK_OK,GTK_RESPONSE_OK,
NULL);
GtkWidget *labelinfo = gtk_label_new(_("Enter static network parameters :"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), labelinfo, FALSE, FALSE, 5);
phboxtemp = gtk_hbox_new(FALSE, 0);
labeltemp = gtk_label_new(_("IP Address : "));
gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5);
GtkWidget *pEntryIP = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryIP, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5);
phboxtemp = gtk_hbox_new(FALSE, 0);
labeltemp = gtk_label_new(_("Network Mask : "));
gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5);
GtkWidget *pEntryNetmask = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryNetmask, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5);
phboxtemp = gtk_hbox_new(FALSE, 0);
labeltemp = gtk_label_new(_("Gateway : "));
gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5);
GtkWidget *pEntryGateway = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryGateway, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5);
/* Affichage des elements de la boite de dialogue */
gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox);
/* On lance la boite de dialogue et on recupere la reponse */
switch (gtk_dialog_run(GTK_DIALOG(pBoite)))
{
/* L utilisateur valide */
case GTK_RESPONSE_OK:
ipaddr = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryIP));
netmask = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryNetmask));
if(strlen(ipaddr))
snprintf(option, 49, "%s netmask %s", ipaddr, netmask);
interface->options = g_list_append(interface->options, strdup(option));
gateway = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryGateway));
if(strlen(gateway))
snprintf(interface->gateway, FWNET_GW_MAX_SIZE, "default gw %s", gateway);
GtkTreeView *treeview = (GtkTreeView *)viewif;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_NET_IP, ipaddr,COLUMN_NET_NETMASK, netmask, COLUMN_NET_GATEWAY, gateway, -1);
break;
/* L utilisateur annule */
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_NONE:
default:
break;
}
/* Destruction de la boite de dialogue */
gtk_widget_destroy(pBoite);
return 0;
}
int init_main_list_store(GtkListStore* list_store, sqlite3_stmt* query)
{
if(gtk_tree_model_get_n_columns(GTK_TREE_MODEL(list_store)) != sqlite3_column_count(query)) // последний столбец пустой
{
fputs("ERROR: different columns count\n", stderr);
return EXIT_FAILURE;
}
GtkTreeIter iter;
int column_count = gtk_tree_model_get_n_columns(GTK_TREE_MODEL(list_store));
while(sqlite3_step(query) == SQLITE_ROW)
{
gtk_list_store_append(list_store, &iter);
for(int i=0; i<column_count; i++)
{
GType column_type = gtk_tree_model_get_column_type(GTK_TREE_MODEL(list_store), i);
if(column_type == G_TYPE_STRING)
{
if(is_date_column(query, i) == TRUE)
{
time_t bin_time = (time_t)sqlite3_column_int64(query, i);
if(bin_time != -1)
{
char time_str[32];
struct tm* struct_time = localtime(&bin_time);
strftime(time_str, sizeof(time_str), "%H:%M:%S - %d.%m.%Y", struct_time);
gtk_list_store_set(list_store, &iter, i, time_str, -1);
}
else
gtk_list_store_set(list_store, &iter, i, "-1", -1);
}
else
{
const unsigned char* text = sqlite3_column_text(query, i);
gtk_list_store_set(list_store, &iter, i, text, -1);
}
}
else if(column_type == G_TYPE_INT64)
{
sqlite_int64 num = sqlite3_column_int64(query, i);
gtk_list_store_set(list_store, &iter, i, num, -1);
}
else if(column_type == G_TYPE_INT64)
{
int num = sqlite3_column_int(query, i);
gtk_list_store_set(list_store, &iter, i, num, -1);
}
else if(column_type == G_TYPE_DOUBLE)
{
double num = sqlite3_column_double(query, i);
gtk_list_store_set(list_store, &iter, i, num, -1);
}
else if(column_type == G_TYPE_BOOLEAN)
{
int flag = sqlite3_column_int(query, i);
gtk_list_store_set(list_store, &iter, i, flag, -1);
}
else if(column_type == G_TYPE_BYTE_ARRAY)
{
const void* data = sqlite3_column_blob(query, i);
gtk_list_store_set(list_store, &iter, i, data, -1);
}
}
}
return EXIT_SUCCESS;
}
static void
update_detailed_info(PidginXferDialog *dialog, PurpleXfer *xfer)
{
PidginXferUiData *data;
char *kbsec, *time_elapsed, *time_remaining;
char *status, *utf8;
if (dialog == NULL || xfer == NULL)
return;
data = PIDGINXFER(xfer);
get_xfer_info_strings(xfer, &kbsec, &time_elapsed, &time_remaining);
status = g_strdup_printf("%d%% (%" G_GSIZE_FORMAT " of %" G_GSIZE_FORMAT " bytes)",
(int)(purple_xfer_get_progress(xfer)*100),
purple_xfer_get_bytes_sent(xfer),
purple_xfer_get_size(xfer));
if (purple_xfer_is_completed(xfer)) {
GdkPixbuf *pixbuf = NULL;
pixbuf = gtk_widget_render_icon(xfer_dialog->window,
PIDGIN_STOCK_FILE_DONE,
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
COLUMN_STATUS, pixbuf,
-1);
g_object_unref(pixbuf);
}
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label),
_("<b>Receiving As:</b>"));
gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label),
_("<b>Receiving From:</b>"));
}
else {
gtk_label_set_markup(GTK_LABEL(dialog->remote_user_desc_label),
_("<b>Sending To:</b>"));
gtk_label_set_markup(GTK_LABEL(dialog->local_user_desc_label),
_("<b>Sending As:</b>"));
}
gtk_label_set_text(GTK_LABEL(dialog->local_user_label),
purple_account_get_username(xfer->account));
gtk_label_set_text(GTK_LABEL(dialog->remote_user_label), xfer->who);
gtk_label_set_text(GTK_LABEL(dialog->protocol_label),
purple_account_get_protocol_name(xfer->account));
if (purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE) {
gtk_label_set_text(GTK_LABEL(dialog->filename_label),
purple_xfer_get_filename(xfer));
} else {
char *tmp;
tmp = g_path_get_basename(purple_xfer_get_local_filename(xfer));
utf8 = g_filename_to_utf8(tmp, -1, NULL, NULL, NULL);
g_free(tmp);
gtk_label_set_text(GTK_LABEL(dialog->filename_label), utf8);
g_free(utf8);
}
utf8 = g_filename_to_utf8((purple_xfer_get_local_filename(xfer)), -1, NULL, NULL, NULL);
gtk_label_set_text(GTK_LABEL(dialog->localfile_label), utf8);
g_free(utf8);
gtk_label_set_text(GTK_LABEL(dialog->status_label), status);
gtk_label_set_text(GTK_LABEL(dialog->speed_label), kbsec);
gtk_label_set_text(GTK_LABEL(dialog->time_elapsed_label), time_elapsed);
gtk_label_set_text(GTK_LABEL(dialog->time_remaining_label),
time_remaining);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dialog->progress),
purple_xfer_get_progress(xfer));
g_free(kbsec);
g_free(time_elapsed);
g_free(time_remaining);
g_free(status);
}
static void changed(GtkWidget *widget, struct search_param *search)
{
struct search_list_result *res;
GtkTreeIter iter;
search->attr.u.str=(char *)gtk_entry_get_text(GTK_ENTRY(widget));
printf("changed %s partial %d\n", search->attr.u.str, search->partial);
if (widget == search->entry_country) {
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 3, GTK_SORT_ASCENDING);
dbg(0,"country\n");
search->attr.type=attr_country_all;
set_columns(search, 0);
}
if (widget == search->entry_postal) {
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 1, GTK_SORT_ASCENDING);
dbg(0,"postal\n");
search->attr.type=attr_town_postal;
if (strlen(search->attr.u.str) < 2)
return;
set_columns(search, 1);
}
if (widget == search->entry_city) {
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 2, GTK_SORT_ASCENDING);
dbg(0,"town\n");
search->attr.type=attr_town_name;
if (strlen(search->attr.u.str) < 3)
return;
set_columns(search, 1);
}
if (widget == search->entry_street) {
dbg(0,"street\n");
search->attr.type=attr_street_name;
set_columns(search, 2);
}
search_list_search(search->sl, &search->attr, search->partial);
gtk_list_store_clear(search->liststore);
while((res=search_list_get_result(search->sl))) {
gtk_list_store_append(search->liststore,&iter);
gtk_list_store_set(search->liststore,&iter,COL_COUNT,res->c,-1);
if (widget == search->entry_country) {
if (res->country) {
gtk_list_store_set(search->liststore,&iter,0,res->country->car,-1);
gtk_list_store_set(search->liststore,&iter,1,res->country->iso3,-1);
gtk_list_store_set(search->liststore,&iter,2,res->country->iso2,-1);
gtk_list_store_set(search->liststore,&iter,3,res->country->name,-1);
}
} else {
if (res->country)
gtk_list_store_set(search->liststore,&iter,0,res->country->car,-1);
else
gtk_list_store_set(search->liststore,&iter,0,"",-1);
if (res->town) {
gtk_list_store_set(search->liststore,&iter,1,res->town->common.postal,-1);
gtk_list_store_set(search->liststore,&iter,2,res->town->name,-1);
gtk_list_store_set(search->liststore,&iter,3,res->town->district,-1);
} else {
gtk_list_store_set(search->liststore,&iter,1,"",-1);
gtk_list_store_set(search->liststore,&iter,2,"",-1);
gtk_list_store_set(search->liststore,&iter,3,"",-1);
}
if (res->street)
gtk_list_store_set(search->liststore,&iter,4,res->street->name,-1);
else
gtk_list_store_set(search->liststore,&iter,4,"",-1);
}
}
if (! search->partial)
next_focus(search, widget);
search->partial=1;
}
void OnDPress_rub(GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
t_window *window)
{
column = column;
tree_view = tree_view;
char *tmp ;
GtkTreeIter iter;
/* Clear zone d affichage */
gtk_container_foreach(GTK_CONTAINER(window->pBox_aff_p),
(GtkCallback)OnClear_HBox_p,
window);
GtkWidget *pTable = gtk_table_new(5, 5, TRUE);
gtk_box_pack_start(GTK_BOX(window->pBox_aff_p),
pTable,
TRUE, TRUE, 0);
/* nom de la rub 2clique */
gtk_tree_model_get_iter (GTK_TREE_MODEL(window->pTreeStore_p),
&iter,
path);
gtk_tree_model_get(GTK_TREE_MODEL(window->pTreeStore_p),
&iter,
0,
&tmp,
-1);
if (!strcmp(tmp,"Contacts")) {
GtkListStore* pListstore;
GtkWidget *pListView;
GtkCellRenderer *pCellRenderer;
GtkTreeViewColumn *pColumn;
GtkWidget *pScrollbar;
pListstore = gtk_list_store_new(N_COLUMN,
GDK_TYPE_PIXBUF,
G_TYPE_STRING);
/*** Insertion contact ***/
GdkPixbuf *pPixBufA;
GtkTreeIter pIter;
t_contact *p;
p = window->contacts;
while (p!= NULL){
gtk_list_store_append(pListstore, &pIter);
pPixBufA = gdk_pixbuf_new_from_file(p->pic, NULL);
gtk_list_store_set(pListstore, &pIter,
PIX_COLUMN, pPixBufA,
TEXT_COLUMN, p->name,
-1);
p = p->next;
}
/**************************/
/* Creation de la vue */
pListView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pListstore));
/* Creation de la premiere colonne */
pCellRenderer = gtk_cell_renderer_pixbuf_new();
pColumn = gtk_tree_view_column_new_with_attributes("B",
pCellRenderer,
"pixbuf", PIX_COLUMN,
NULL);
/* Ajout de la colonne à la vue */
gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn);
/* Creation de la deuxieme colonne */
pCellRenderer = gtk_cell_renderer_text_new();
pColumn = gtk_tree_view_column_new_with_attributes("login",
pCellRenderer,
"text", TEXT_COLUMN,
NULL);
/* Ajout de la colonne à la vue*/
gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn);
/* scrollbar */
pScrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(pScrollbar), pListView);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
/*BOUTONS*/
GtkWidget *pVBox = gtk_vbox_new(FALSE, 0);
/* ajouter*/
GtkWidget *pBajouter = gtk_button_new_with_label("Ajouter");
g_signal_connect(G_OBJECT(pBajouter),
"clicked",
G_CALLBACK(OnButton_contact_ajouter),
window);
gtk_box_pack_start(GTK_BOX(pVBox),
pBajouter,
FALSE, FALSE, 0);
/*supprimer*/
GtkWidget *pBsupprimer = gtk_button_new_with_label("Supprimer");
g_signal_connect(G_OBJECT(pBsupprimer),
"clicked",
G_CALLBACK(OnButton_contact_supprimer),
window);
gtk_box_pack_start(GTK_BOX(pVBox),
pBsupprimer,
FALSE, FALSE, 0);
/*modifier*/
GtkWidget *pBmodifier = gtk_button_new_with_label("Modifier");
g_signal_connect(G_OBJECT(pBmodifier),
"clicked",
G_CALLBACK(OnButton_contact_modifier),
window);
gtk_box_pack_start(GTK_BOX(pVBox),
pBmodifier,
FALSE, FALSE, 0);
/* mis dans la zone d affichage */
GtkWidget *label;
label = gtk_label_new(" Gestion des contacts ");
gtk_table_attach_defaults(GTK_TABLE(pTable),
label,
1,4,
0,1);
gtk_table_attach_defaults(GTK_TABLE(pTable),
pScrollbar,
0,4,
1,5);
gtk_table_attach_defaults(GTK_TABLE(pTable),
pVBox,
4,5,
1,5);
/*affichage */
gtk_widget_show_all(GTK_WIDGET(window->pHBox_p));
}
if (!strcmp(tmp,"Apparence")) {
GtkWidget *label;
label = gtk_label_new(" Choisir un theme : ");
gtk_table_attach_defaults(GTK_TABLE(pTable),
label,
0,2,
0,1);
GtkWidget *pbred = gtk_button_new_with_label("red");
gtk_table_attach_defaults(GTK_TABLE(pTable),
pbred,
0,1,
1,2);
g_signal_connect(G_OBJECT(pbred),
"clicked",
G_CALLBACK(OnButton_red),
window);
GtkWidget *pbdual = gtk_button_new_with_label("dual");
gtk_table_attach_defaults(GTK_TABLE(pTable),
pbdual,
1,2,
1,2);
g_signal_connect(G_OBJECT(pbdual),
"clicked",
G_CALLBACK(OnButton_dual),
window);
GtkWidget *pblogo = gtk_button_new_with_label("logo");
gtk_table_attach_defaults(GTK_TABLE(pTable),
pblogo,
2,3,
1,2);
g_signal_connect(G_OBJECT(pblogo),
"clicked",
G_CALLBACK(OnButton_logo),
window);
gtk_widget_show_all(GTK_WIDGET(window->pHBox_p));
}
}
/* Helper function to set session values */
static void
populate_session (GObject * object)
{
GList *tmp;
/* Last isn't in the session list, so add separate. */
if (GTK_IS_COMBO_BOX (object))
gtk_combo_box_append_text (GTK_COMBO_BOX (object), _("Last session"));
else if (GTK_IS_TREE_MODEL (object))
{
GtkTreeIter loopiter;
GtkTreeModel *tm = GTK_TREE_MODEL (object);
gtk_list_store_append (GTK_LIST_STORE (tm), &loopiter);
gtk_list_store_set (GTK_LIST_STORE (tm), &loopiter,
GREETER_LIST_TEXT, _("Last session"),
GREETER_LIST_ID, LAST_SESSION,
-1);
}
/* Loop through the sessions and set the custom list values. */
for (tmp = sessions; tmp != NULL; tmp = tmp->next)
{
MdmSession *session;
char *file;
file = (char *) tmp->data;
session = g_hash_table_lookup (sessnames, file);
if (GTK_IS_COMBO_BOX (object))
{
if (session->clearname != NULL)
gtk_combo_box_append_text (GTK_COMBO_BOX (object), (session->clearname));
else
gtk_combo_box_append_text (GTK_COMBO_BOX (object), (session->name));
}
else if (GTK_IS_TREE_MODEL (object))
{
GtkTreeIter loopiter;
GtkTreeModel *tm = GTK_TREE_MODEL (object);
gchar *to_display;
gtk_list_store_append (GTK_LIST_STORE (tm), &loopiter);
if (session->clearname != NULL)
to_display = session->clearname;
else
to_display = session->name;
gtk_list_store_set (GTK_LIST_STORE (tm), &loopiter,
GREETER_LIST_TEXT, to_display,
GREETER_LIST_ID, file,
-1);
}
}
/*
* Set the session if one exists, this will calback and set the
* custom list
*/
if (session_key != NULL)
greeter_custom_set_session (session_key);
}
void
prefsbox_open (void)
{
GtkWidget *notebook;
GtkWidget *grid;
GtkWidget *controls_list;
GtkWidget *label;
GtkCellRenderer *renderer;
GtkListStore *model;
GtkTreeIter iter;
gint i;
if (prefsbox != NULL) {
gtk_window_present (GTK_WINDOW (prefsbox));
return;
}
prefsbox = gtk_dialog_new_with_buttons (_("Four-in-a-Row Preferences"),
GTK_WINDOW (app),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE,
GTK_RESPONSE_ACCEPT, NULL);
gtk_container_set_border_width (GTK_CONTAINER (prefsbox), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefsbox))),
2);
g_signal_connect (G_OBJECT (prefsbox), "destroy",
G_CALLBACK (gtk_widget_destroyed), &prefsbox);
notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefsbox))), notebook, TRUE, TRUE, 0);
/* game tab */
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 12);
gtk_container_set_border_width (GTK_CONTAINER (grid), 12);
label = gtk_label_new (_("Game"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), grid, label);
label = gtk_label_new (_("Player One:"));
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
combobox1 = gtk_combo_box_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox1), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox1), renderer, "text", 0);
model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
gtk_combo_box_set_model (GTK_COMBO_BOX (combobox1), GTK_TREE_MODEL (model));
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Human"), 1, LEVEL_HUMAN, -1);
if (p.level[PLAYER1] == LEVEL_HUMAN)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Level one"), 1, LEVEL_WEAK, -1);
if (p.level[PLAYER1] == LEVEL_WEAK)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Level two"), 1, LEVEL_MEDIUM, -1);
if (p.level[PLAYER1] == LEVEL_MEDIUM)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Level three"), 1, LEVEL_STRONG, -1);
if (p.level[PLAYER1] == LEVEL_STRONG)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter);
g_signal_connect (combobox1, "changed", G_CALLBACK (on_select_player1), NULL);
gtk_grid_attach (GTK_GRID (grid), combobox1, 1, 0, 1, 1);
label = gtk_label_new (_("Player Two:"));
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
combobox2 = gtk_combo_box_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox2), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox2), renderer, "text", 0);
model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
gtk_combo_box_set_model (GTK_COMBO_BOX (combobox2), GTK_TREE_MODEL (model));
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Human"), 1, LEVEL_HUMAN, -1);
if (p.level[PLAYER2] == LEVEL_HUMAN)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Level one"), 1, LEVEL_WEAK, -1);
if (p.level[PLAYER2] == LEVEL_WEAK)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Level two"), 1, LEVEL_MEDIUM, -1);
if (p.level[PLAYER2] == LEVEL_MEDIUM)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("Level three"), 1, LEVEL_STRONG, -1);
if (p.level[PLAYER2] == LEVEL_STRONG)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter);
g_signal_connect (combobox2, "changed", G_CALLBACK (on_select_player2), NULL);
gtk_grid_attach (GTK_GRID (grid), combobox2, 1, 1, 1, 1);
label = gtk_label_new_with_mnemonic (_("_Theme:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
combobox_theme = gtk_combo_box_text_new ();
for (i = 0; i < n_themes; i++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combobox_theme),
_(theme_get_title (i)));
}
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combobox_theme);
gtk_grid_attach (GTK_GRID (grid), combobox_theme, 1, 2, 1, 1);
checkbutton_animate =
gtk_check_button_new_with_mnemonic (_("Enable _animation"));
gtk_grid_attach (GTK_GRID (grid), checkbutton_animate, 0, 3, 2, 1);
checkbutton_sound =
gtk_check_button_new_with_mnemonic (_("E_nable sounds"));
gtk_grid_attach (GTK_GRID (grid), checkbutton_sound, 0, 4, 2, 1);
/* keyboard tab */
label = gtk_label_new_with_mnemonic (_("Keyboard Controls"));
controls_list = games_controls_list_new (settings);
games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls_list),
"key-left", _("Move left"), DEFAULT_KEY_LEFT,
"key-right", _("Move right"), DEFAULT_KEY_RIGHT,
"key-drop", _("Drop marble"), DEFAULT_KEY_DROP,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (controls_list), 12);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), controls_list, label);
/* fill in initial values */
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox_theme), p.theme_id);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_animate),
p.do_animate);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_sound),
p.do_sound);
/* connect signals */
g_signal_connect (prefsbox, "response", G_CALLBACK (on_dialog_close),
&prefsbox);
g_signal_connect (G_OBJECT (combobox_theme), "changed",
G_CALLBACK (on_select_theme), NULL);
g_signal_connect (G_OBJECT (checkbutton_animate), "toggled",
G_CALLBACK (on_toggle_animate), NULL);
g_signal_connect (G_OBJECT (checkbutton_sound), "toggled",
G_CALLBACK (on_toggle_sound), NULL);
gtk_widget_show_all (prefsbox);
}
gint
main (gint argc, gchar * argv[])
{
IconBrowserData *data;
gchar **themes = NULL;
GList *ic, *icat;
GtkListStore *store;
GtkTreeSelection *sel;
GtkTreeViewColumn *col;
GtkCellRenderer *r;
GtkWidget *w, *p, *box, *t;
GOptionEntry entrs[] = {
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &themes, NULL, NULL},
{NULL}
};
data = g_new0 (IconBrowserData, 1);
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
data = g_new0 (IconBrowserData, 1);
/* initialize GTK+ and parse the command line arguments */
gtk_init_with_args (&argc, &argv, _("- Icon browser"), entrs, GETTEXT_PACKAGE, NULL);
/* load icon theme */
if (themes && themes[0])
{
data->theme = gtk_icon_theme_new ();
gtk_icon_theme_set_custom_theme (data->theme, themes[0]);
}
else
data->theme = gtk_icon_theme_get_default ();
/* create interface */
data->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (data->win), _("Icon browser"));
gtk_window_set_icon_name (GTK_WINDOW (data->win), "gtk-info");
gtk_window_set_default_size (GTK_WINDOW (data->win), 500, 400);
g_signal_connect (G_OBJECT (data->win), "delete-event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (G_OBJECT (data->win), "key-press-event", G_CALLBACK (key_press_cb), NULL);
#if !GTK_CHECK_VERSION(3,0,0)
box = gtk_vbox_new (FALSE, 5);
#else
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
#endif
gtk_container_add (GTK_CONTAINER (data->win), box);
gtk_container_set_border_width (GTK_CONTAINER (data->win), 5);
/* create icon info box */
#if !GTK_CHECK_VERSION(3,0,0)
t = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (t), 5);
gtk_table_set_row_spacings (GTK_TABLE (t), 5);
#else
t = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (t), 5);
gtk_grid_set_column_spacing (GTK_GRID (t), 5);
#endif
gtk_box_pack_start (GTK_BOX (box), t, FALSE, FALSE, 2);
data->image = gtk_image_new_from_stock ("gtk-missing-image", GTK_ICON_SIZE_DIALOG);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), data->image, 0, 1, 0, 3, GTK_FILL, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), data->image, 0, 0, 1, 3);
#endif
w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), _("<b>Name:</b>"));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), w, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), w, 1, 0, 1, 1);
#endif
data->lname = gtk_label_new (NULL);
gtk_label_set_selectable (GTK_LABEL (data->lname), TRUE);
gtk_misc_set_alignment (GTK_MISC (data->lname), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), data->lname, 2, 3, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), data->lname, 2, 0, 1, 1);
gtk_widget_set_hexpand (data->lname, TRUE);
#endif
w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), _("<b>Sizes:</b>"));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), w, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), w, 1, 1, 1, 1);
#endif
data->lsize = gtk_label_new (NULL);
gtk_label_set_selectable (GTK_LABEL (data->lsize), TRUE);
gtk_misc_set_alignment (GTK_MISC (data->lsize), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), data->lsize, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), data->lsize, 2, 1, 1, 1);
gtk_widget_set_hexpand (data->lsize, TRUE);
#endif
w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), _("<b>Filename:</b>"));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), w, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), w, 1, 2, 1, 1);
#endif
data->lfile = gtk_label_new (NULL);
gtk_label_set_selectable (GTK_LABEL (data->lfile), TRUE);
gtk_misc_set_alignment (GTK_MISC (data->lfile), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
gtk_table_attach (GTK_TABLE (t), data->lfile, 2, 3, 2, 3, GTK_FILL | GTK_EXPAND, 0, 0, 0);
#else
gtk_grid_attach (GTK_GRID (t), data->lfile, 2, 2, 1, 1);
gtk_widget_set_hexpand (data->lfile, TRUE);
#endif
/* create icon browser */
#if !GTK_CHECK_VERSION(3,0,0)
p = gtk_hpaned_new ();
#else
p = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_paned_set_position (GTK_PANED (p), 150);
gtk_box_pack_start (GTK_BOX (box), p, TRUE, TRUE, 2);
/* create category list */
w = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN);
gtk_paned_add1 (GTK_PANED (p), w);
store = gtk_list_store_new (1, G_TYPE_STRING);
data->cat_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->cat_list), TRUE);
gtk_container_add (GTK_CONTAINER (w), data->cat_list);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->cat_list));
g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_cat), data);
r = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Category"), r, "text", 0, NULL);
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (data->cat_list), col);
/* load icons category */
data->icons = g_hash_table_new (g_direct_hash, g_direct_equal);
icat = gtk_icon_theme_list_contexts (data->theme);
for (ic = icat; ic; ic = ic->next)
{
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, ic->data, -1);
g_free (ic->data);
}
g_list_free (icat);
/* create icons list */
w = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN);
gtk_paned_add2 (GTK_PANED (p), w);
data->icon_list = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->icon_list), TRUE);
gtk_container_add (GTK_CONTAINER (w), data->icon_list);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->icon_list));
g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_icon), data);
col = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (col, _("Icons"));
gtk_tree_view_column_set_sort_column_id (col, 1);
r = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, r, FALSE);
gtk_tree_view_column_set_attributes (col, r, "pixbuf", 0, NULL);
r = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, r, FALSE);
gtk_tree_view_column_set_attributes (col, r, "text", 1, NULL);
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (data->icon_list), col);
gtk_widget_show_all (data->win);
/* run it */
gtk_main ();
return 0;
}
static void
cg_cell_renderer_flags_selected (CgComboFlags *combo,
GtkTreeIter *iter,
CgComboFlagsSelectionType type,
gpointer user_data)
{
CgCellRendererFlags *cell_flags;
CgCellRendererFlagsPrivate *priv;
gpointer result;
gchar *name;
gchar *abbr;
cell_flags = CG_CELL_RENDERER_FLAGS (user_data);
priv = CG_CELL_RENDERER_FLAGS_PRIVATE (cell_flags);
gtk_tree_model_get (priv->model, iter, priv->text_column, &name,
priv->abbr_column, &abbr, -1);
g_assert (priv->edit_status != NULL);
result = g_hash_table_lookup (priv->edit_status, abbr);
/* abbr needs not to be freed if it gets inserted into the hash table
* because the hash table then takes ownership of it. */
switch (type)
{
case CG_COMBO_FLAGS_SELECTION_NONE:
g_free (abbr);
break;
case CG_COMBO_FLAGS_SELECTION_SELECT:
if (GPOINTER_TO_INT(result) != 1)
g_hash_table_insert (priv->edit_status, abbr, GINT_TO_POINTER (1));
else
g_free (abbr);
break;
case CG_COMBO_FLAGS_SELECTION_UNSELECT:
if (GPOINTER_TO_INT (result) == 1)
g_hash_table_remove(priv->edit_status, abbr);
g_free (abbr);
break;
case CG_COMBO_FLAGS_SELECTION_TOGGLE:
if (GPOINTER_TO_INT (result) == 1)
{
g_hash_table_remove (priv->edit_status, abbr);
g_free(abbr);
}
else
{
g_hash_table_insert (priv->edit_status, abbr, GINT_TO_POINTER (1));
}
break;
default:
g_assert_not_reached ();
break;
}
/* This is done to get GTK+ to re-render this row with the changed flag
* status that is set via the cell data func, but GTK+ does not call it
* again because it does not know that the hash table changed. There are
* probably better means to achieve this, but I am not aware of those. */
gtk_list_store_set (GTK_LIST_STORE (priv->model), iter,
priv->text_column, name, -1);
g_free (name);
}
/*
* Open the window to select and type the picture properties
*/
void Picture_Properties_Button_Clicked (GObject *object)
{
GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow;
GtkWidget *type, *label, *desc;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkListStore *store;
GtkTreeIter type_iter_to_select, iter;
GtkTreeModel *model;
GtkWindow *parent_window = NULL;
GList *selection_list = NULL;
GList *l;
gint selection_nbr, selection_i = 1;
gint response;
EtPictureType pic_type;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));
for (l = selection_list; l != NULL; l = g_list_next (l))
{
GtkTreePath *path = l->data;
Picture *pic = NULL;
GtkTreeSelection *selectiontype;
gchar *title;
GtkTreePath *rowPath;
gboolean valid;
// Get corresponding picture
valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
if (valid)
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);
title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++,
selection_nbr);
PictureTypesWindow = gtk_dialog_new_with_buttons(title,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_free(title);
gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK);
ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT);
type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref (store);
gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_title (column, _("Image Type"));
gtk_tree_view_column_set_attributes(column, renderer,
"text", PICTURE_TYPE_COLUMN_TEXT,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(type), column);
gtk_widget_set_size_request(type, 256, 256);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0);
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
/* Load picture type (only Front Cover!). */
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype, G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
ET_PICTURE_TYPE_FRONT_COVER,
-1);
/* Line to select by default. */
type_iter_to_select = itertype;
break;
}
// Other tag types
default:
{
// Load pictures types
for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++)
{
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype,
G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (pic_type)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
pic_type, -1);
/* Line to select by default. */
if (pic->type == pic_type)
type_iter_to_select = itertype;
}
break;
}
}
// Select the line by default
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select);
// Set visible the current selected line
rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0);
gtk_tree_path_free(rowPath);
// Description of the picture
label = gtk_label_new (_("Image Description:"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4);
// Entry for the description
desc = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0);
if (pic->description)
{
gchar *tmp = Try_To_Validate_Utf8_String(pic->description);
gtk_entry_set_text(GTK_ENTRY(desc), tmp);
g_free(tmp);
}
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE);
break;
}
// Other tag types
default:
{
break;
}
}
gtk_widget_show_all(PictureTypesWindow);
response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow));
if (response == GTK_RESPONSE_OK)
{
GtkTreeModel *modeltype;
GtkTreeIter itertype;
modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type));
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype))
{
gchar *buffer, *pic_info;
gint t;
gtk_tree_model_get(modeltype, &itertype,
PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1);
pic->type = t;
buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc)));
Strip_String(buffer);
if (pic->description)
g_free(pic->description);
/* If the entry was empty, buffer will be the empty string "".
* This can be safely passed to the underlying
* FLAC__metadata_object_picture_set_description(). See
* https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804
* and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for
* downstream bugs when 0 was passed instead. */
pic->description = buffer;
// Update value in the PictureEntryView
pic_info = Picture_Info(pic);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
PICTURE_COLUMN_TEXT, pic_info,
-1);
g_free(pic_info);
}
}
gtk_widget_destroy(PictureTypesWindow);
}
g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
static void
update_menu (XedEncodingsComboBox *menu)
{
GtkListStore *store;
GtkTreeIter iter;
GSList *encodings, *l;
gchar *str;
const XedEncoding *utf8_encoding;
const XedEncoding *current_encoding;
store = menu->priv->store;
/* Unset the previous model */
g_signal_handler_block (menu, menu->priv->changed_id);
gtk_list_store_clear (store);
gtk_combo_box_set_model (GTK_COMBO_BOX (menu),
NULL);
utf8_encoding = xed_encoding_get_utf8 ();
current_encoding = xed_encoding_get_current ();
if (!menu->priv->save_mode)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
NAME_COLUMN, _("Automatically Detected"),
ENCODING_COLUMN, NULL,
ADD_COLUMN, FALSE,
-1);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
NAME_COLUMN, "",
ENCODING_COLUMN, NULL,
ADD_COLUMN, FALSE,
-1);
}
if (current_encoding != utf8_encoding)
str = xed_encoding_to_string (utf8_encoding);
else
str = g_strdup_printf (_("Current Locale (%s)"),
xed_encoding_get_charset (utf8_encoding));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
NAME_COLUMN, str,
ENCODING_COLUMN, utf8_encoding,
ADD_COLUMN, FALSE,
-1);
g_free (str);
if ((utf8_encoding != current_encoding) &&
(current_encoding != NULL))
{
str = g_strdup_printf (_("Current Locale (%s)"),
xed_encoding_get_charset (current_encoding));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
NAME_COLUMN, str,
ENCODING_COLUMN, current_encoding,
ADD_COLUMN, FALSE,
-1);
g_free (str);
}
encodings = xed_prefs_manager_get_shown_in_menu_encodings ();
for (l = encodings; l != NULL; l = g_slist_next (l))
{
const XedEncoding *enc = (const XedEncoding *)l->data;
if ((enc != current_encoding) &&
(enc != utf8_encoding) &&
(enc != NULL))
{
str = xed_encoding_to_string (enc);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
NAME_COLUMN, str,
ENCODING_COLUMN, enc,
ADD_COLUMN, FALSE,
-1);
g_free (str);
}
}
g_slist_free (encodings);
if (xed_prefs_manager_shown_in_menu_encodings_can_set ())
{
gtk_list_store_append (store, &iter);
/* separator */
gtk_list_store_set (store, &iter,
NAME_COLUMN, "",
ENCODING_COLUMN, NULL,
ADD_COLUMN, FALSE,
-1);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
NAME_COLUMN, _("Add or Remove..."),
ENCODING_COLUMN, NULL,
ADD_COLUMN, TRUE,
-1);
}
/* set the model back */
gtk_combo_box_set_model (GTK_COMBO_BOX (menu),
GTK_TREE_MODEL (menu->priv->store));
gtk_combo_box_set_active (GTK_COMBO_BOX (menu), 0);
g_signal_handler_unblock (menu, menu->priv->changed_id);
}
void
preferences_dialog_init (PreferencesDialog *pd)
{
GtkWidget *widget, *entry;
GtkComboBox *combo;
GtkListStore *store;
GtkTreeIter treeiter;
GtkAdjustment *itemCount;
GtkTreeStore *treestore;
GtkTreeViewColumn *column;
GSList *list;
gchar *proxyport;
gchar *configuredBrowser, *name;
gboolean enabled;
static int manual;
struct browser *iter;
gint tmp, i, iSetting, proxy_port;
gboolean bSetting;
gchar *proxy_host, *proxy_user, *proxy_passwd;
gchar *browser_command;
prefdialog = pd;
pd->priv = PREFERENCES_DIALOG_GET_PRIVATE (pd);
pd->priv->dialog = liferea_dialog_new ("prefs.ui", "prefdialog");
/* Set up browser selection popup */
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
for(i = 0, iter = browser_get_all (); iter->id != NULL; iter++, i++) {
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _(iter->display), 1, i, -1);
}
manual = i;
/* This allows the user to choose their own browser by typing in the command. */
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("Manual"), 1, i, -1);
combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserpopup"));
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
ui_common_setup_combo_text (combo, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_changed), pd);
/* Create location menu */
store = gtk_list_store_new (1, G_TYPE_STRING);
combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserlocpopup"));
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
ui_common_setup_combo_text (combo, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_place_changed), pd);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("Browser default"), -1);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("Existing window"), -1);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("New window"), -1);
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, _("New tab"), -1);
/* ================== panel 1 "feeds" ==================== */
/* check box for feed startup update */
conf_get_int_value (STARTUP_FEED_ACTION, &iSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "startupactionbtn")), (iSetting == 0));
/* cache size setting */
widget = liferea_dialog_lookup (pd->priv->dialog, "itemCountBtn");
itemCount = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
conf_get_int_value (DEFAULT_MAX_ITEMS, &iSetting);
gtk_adjustment_set_value (itemCount, iSetting);
/* set default update interval spin button and unit combo box */
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"),
default_update_interval_unit_options,
G_CALLBACK (on_default_update_interval_unit_changed),
-1);
widget = liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox");
conf_get_int_value (DEFAULT_UPDATE_INTERVAL, &tmp);
if (tmp % 1440 == 0) { /* days */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2);
tmp /= 1440;
} else if (tmp % 60 == 0) { /* hours */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
tmp /= 60;
} else { /* minutes */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
}
widget = liferea_dialog_lookup (pd->priv->dialog,"globalRefreshIntervalSpinButton");
gtk_spin_button_set_range (GTK_SPIN_BUTTON (widget), 0, 1000000000);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), tmp);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (on_default_update_interval_value_changed), pd);
/* ================== panel 2 "folders" ==================== */
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "updateAllFavicons")), "clicked", G_CALLBACK(on_updateallfavicons_clicked), pd);
conf_get_int_value (FOLDER_DISPLAY_MODE, &iSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "folderdisplaybtn")), iSetting?TRUE:FALSE);
conf_get_bool_value (FOLDER_DISPLAY_HIDE_READ, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "hidereadbtn")), bSetting?TRUE:FALSE);
/* ================== panel 3 "headlines" ==================== */
conf_get_int_value (BROWSE_KEY_SETTING, &iSetting);
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "skimKeyCombo"),
browser_skim_key_options,
G_CALLBACK (on_skim_key_changed),
iSetting);
conf_get_int_value (DEFAULT_VIEW_MODE, &iSetting);
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "defaultViewModeCombo"),
default_view_mode_options,
G_CALLBACK (on_default_view_mode_changed),
iSetting);
/* Setup social bookmarking list */
i = 0;
conf_get_str_value (SOCIAL_BM_SITE, &name);
store = gtk_list_store_new (1, G_TYPE_STRING);
list = bookmarkSites;
while (list) {
socialSitePtr siter = list->data;
if (name && !strcmp (siter->name, name))
tmp = i;
gtk_list_store_append (store, &treeiter);
gtk_list_store_set (store, &treeiter, 0, siter->name, -1);
list = g_slist_next (list);
i++;
}
combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "socialpopup"));
g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (on_socialsite_changed), pd);
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
ui_common_setup_combo_text (combo, 0);
gtk_combo_box_set_active (combo, tmp);
/* ================== panel 4 "browser" ==================== */
/* set the inside browsing flag */
widget = liferea_dialog_lookup(pd->priv->dialog, "browseinwindow");
conf_get_bool_value(BROWSE_INSIDE_APPLICATION, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
/* set the javascript-disabled flag */
widget = liferea_dialog_lookup(pd->priv->dialog, "disablejavascript");
conf_get_bool_value(DISABLE_JAVASCRIPT, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
/* set the enable Plugins flag */
widget = liferea_dialog_lookup(pd->priv->dialog, "enableplugins");
conf_get_bool_value(ENABLE_PLUGINS, &bSetting);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
tmp = 0;
conf_get_str_value(BROWSER_ID, &configuredBrowser);
if(!strcmp(configuredBrowser, "manual"))
tmp = manual;
else
for(i=0, iter = browser_get_all (); iter->id != NULL; iter++, i++)
if(!strcmp(configuredBrowser, iter->id))
tmp = i;
gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserpopup")), tmp);
g_free(configuredBrowser);
conf_get_int_value (BROWSER_PLACE, &iSetting);
gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserlocpopup")), iSetting);
conf_get_str_value (BROWSER_COMMAND, &browser_command);
entry = liferea_dialog_lookup(pd->priv->dialog, "browsercmd");
gtk_entry_set_text(GTK_ENTRY(entry), browser_command);
g_free (browser_command);
gtk_widget_set_sensitive (GTK_WIDGET (entry), tmp == manual);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "manuallabel"), tmp == manual);
gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "urlhintlabel"), tmp == manual);
/* ================== panel 4 "GUI" ================ */
/* tool bar settings */
widget = liferea_dialog_lookup (pd->priv->dialog, "hidetoolbarbtn");
conf_get_bool_value(DISABLE_TOOLBAR, &bSetting);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);
/* select currently active toolbar style option */
conf_get_str_value (TOOLBAR_STYLE, &name);
for (i = 0; gui_toolbar_style_values[i] != NULL; ++i) {
if (strcmp (name, gui_toolbar_style_values[i]) == 0)
break;
}
g_free (name);
/* On invalid key value: revert to default */
if (gui_toolbar_style_values[i] == NULL)
i = 0;
/* create toolbar style menu */
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "toolbarCombo"),
gui_toolbar_style_options,
G_CALLBACK (on_gui_toolbar_style_changed),
i);
/* ================= panel 5 "proxy" ======================== */
conf_get_str_value (PROXY_HOST, &proxy_host);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), proxy_host);
g_free (proxy_host);
conf_get_int_value (PROXY_PORT, &proxy_port);
proxyport = g_strdup_printf ("%d", proxy_port);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), proxyport);
g_free (proxyport);
conf_get_bool_value (PROXY_USEAUTH, &enabled);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "useProxyAuth")), enabled);
conf_get_str_value (PROXY_USER, &proxy_user);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), proxy_user);
g_free (proxy_user);
conf_get_str_value (PROXY_PASSWD, &proxy_passwd);
gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), proxy_passwd);
g_free (proxy_passwd);
gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup(pd->priv->dialog, "proxyauthtable")), enabled);
conf_get_int_value (PROXY_DETECT_MODE, &i);
switch (i) {
default:
case 0: /* proxy auto detect */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), TRUE);
enabled = FALSE;
break;
case 1: /* no proxy */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), TRUE);
enabled = FALSE;
break;
case 2: /* manual proxy */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), TRUE);
enabled = TRUE;
break;
}
gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup (pd->priv->dialog, "proxybox")), enabled);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), "clicked", G_CALLBACK (on_proxyAutoDetect_clicked), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), "clicked", G_CALLBACK (on_noProxy_clicked), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), "clicked", G_CALLBACK (on_manualProxy_clicked), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), "changed", G_CALLBACK (on_proxyhostentry_changed), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), "changed", G_CALLBACK (on_proxyportentry_changed), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), "changed", G_CALLBACK (on_proxyusernameentry_changed), pd);
g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), "changed", G_CALLBACK (on_proxypasswordentry_changed), pd);
/* ================= panel 6 "Enclosures" ======================== */
/* menu for download tool */
conf_get_int_value (DOWNLOAD_TOOL, &iSetting);
ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "downloadToolCombo"),
enclosure_download_tool_options,
G_CALLBACK (on_enclosure_download_tool_changed),
iSetting);
/* set up list of configured enclosure types */
treestore = gtk_tree_store_new (FTS_LEN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
list = (GSList *)enclosure_mime_types_get ();
while (list) {
GtkTreeIter *newIter = g_new0 (GtkTreeIter, 1);
gtk_tree_store_append (treestore, newIter, NULL);
gtk_tree_store_set (treestore, newIter,
FTS_TYPE, (NULL != ((encTypePtr)(list->data))->mime)?((encTypePtr)(list->data))->mime:((encTypePtr)(list->data))->extension,
FTS_CMD, ((encTypePtr)(list->data))->cmd,
FTS_PTR, list->data,
-1);
list = g_slist_next (list);
}
widget = liferea_dialog_lookup (pd->priv->dialog, "enc_action_view");
gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (treestore));
column = gtk_tree_view_column_new_with_attributes (_("Type"), gtk_cell_renderer_text_new (), "text", FTS_TYPE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
gtk_tree_view_column_set_sort_column_id (column, FTS_TYPE);
column = gtk_tree_view_column_new_with_attributes (_("Program"), gtk_cell_renderer_text_new (), "text", FTS_CMD, NULL);
gtk_tree_view_column_set_sort_column_id (column, FTS_CMD);
gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)), GTK_SELECTION_SINGLE);
/* ================= panel 7 "Plugins" ======================== */
pd->priv->plugins_box = liferea_dialog_lookup (pd->priv->dialog, "plugins_box");
g_assert (pd->priv->plugins_box != NULL);
GtkWidget *alignment;
alignment = gtk_alignment_new (0., 0., 1., 1.);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
widget = peas_gtk_plugin_manager_new (NULL);
g_assert (widget != NULL);
gtk_container_add (GTK_CONTAINER (alignment), widget);
gtk_box_pack_start (GTK_BOX (pd->priv->plugins_box), alignment, TRUE, TRUE, 0);
g_signal_connect_object (pd->priv->dialog, "destroy", G_CALLBACK (preferences_dialog_destroy_cb), pd, 0);
gtk_widget_show_all (pd->priv->dialog);
gtk_window_present (GTK_WINDOW (pd->priv->dialog));
}
void
cb_ask_for_information (ScreenshooterJob *job,
GtkListStore *liststore,
const gchar *message,
gpointer unused)
{
GtkWidget *dialog;
GtkWidget *information_label;
GtkWidget *vbox, *main_alignment;
GtkWidget *table;
GtkWidget *user_entry, *password_entry, *title_entry, *comment_entry;
GtkWidget *user_label, *password_label, *title_label, *comment_label;
GtkTreeIter iter;
gint response;
g_return_if_fail (SCREENSHOOTER_IS_JOB (job));
g_return_if_fail (GTK_IS_LIST_STORE (liststore));
g_return_if_fail (message != NULL);
TRACE ("Create the dialog to ask for user information.");
/* Create the information dialog */
dialog =
xfce_titled_dialog_new_with_buttons (_("Details about the screenshot for ZimageZ"),
NULL,
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog)->vbox), 12);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "gtk-info");
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
/* Create the main alignment for the dialog */
main_alignment = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 6, 0, 12, 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0);
/* Create the main box for the dialog */
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_container_add (GTK_CONTAINER (main_alignment), vbox);
/* Create the information label */
information_label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (information_label), message);
gtk_misc_set_alignment (GTK_MISC (information_label), 0, 0);
gtk_container_add (GTK_CONTAINER (vbox), information_label);
/* Create the layout table */
table = gtk_table_new (4, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 12);
gtk_container_add (GTK_CONTAINER (vbox), table);
/* Create the user label */
user_label = gtk_label_new (_("User:"******"Your Zimagez user name, if you do not have one yet"
" please create one on the Web page linked above"));
gtk_entry_set_activates_default (GTK_ENTRY (user_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), user_entry, 1, 2, 0, 1);
/* Create the password label */
password_label = gtk_label_new (_("Password:"******"The password for the user above"));
gtk_entry_set_visibility (GTK_ENTRY (password_entry), FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (password_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), password_entry, 1, 2, 1, 2);
/* Create the title label */
title_label = gtk_label_new (_("Title:"));
gtk_misc_set_alignment (GTK_MISC (title_label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), title_label,
0, 1,
2, 3,
GTK_FILL, GTK_FILL,
0, 0);
/* Create the title entry */
title_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (title_entry,
_("The title of the screenshot, it will be used when"
" displaying the screenshot on ZimageZ"));
gtk_entry_set_activates_default (GTK_ENTRY (title_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), title_entry, 1, 2, 2, 3);
/* Create the comment label */
comment_label = gtk_label_new (_("Comment:"));
gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), comment_label,
0, 1,
3, 4,
GTK_FILL, GTK_FILL,
0, 0);
/* Create the comment entry */
comment_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (comment_entry,
_("A comment on the screenshot, it will be used when"
" displaying the screenshot on ZimageZ"));
gtk_entry_set_activates_default (GTK_ENTRY (comment_entry), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), comment_entry, 1, 2, 3, 4);
/* Set the values */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
gtk_entry_set_text (GTK_ENTRY (user_entry), field_value);
break;
case PASSWORD:
gtk_entry_set_text (GTK_ENTRY (password_entry), field_value);
break;
case TITLE:
gtk_entry_set_text (GTK_ENTRY (title_entry), field_value);
break;
case COMMENT:
gtk_entry_set_text (GTK_ENTRY (comment_entry), field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
gtk_widget_show_all (GTK_DIALOG(dialog)->vbox);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
{
exo_job_cancel (EXO_JOB (job));
}
else if (response == GTK_RESPONSE_OK)
{
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index, -1);
switch (field_index)
{
case USER:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (user_entry)),
-1);
break;
case PASSWORD:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (password_entry)),
-1);
break;
case TITLE:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (title_entry)),
-1);
break;
case COMMENT:
gtk_list_store_set (liststore, &iter,
1, gtk_entry_get_text (GTK_ENTRY (comment_entry)),
-1);
break;
default:
break;
}
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
}
gtk_widget_destroy (dialog);
}
void ColorICCSelector::init()
{
GtkWidget *t;
gint row = 0;
_updating = FALSE;
_dragging = FALSE;
t = gtk_table_new (5, 3, FALSE);
gtk_widget_show (t);
gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4);
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
//guint partCount = _cmsChannelsOf( icSigRgbData );
gchar const** names = 0;
gchar const** tips = 0;
getThings( cmsSigRgbData, names, tips, _fooScales );
#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
/* Create components */
row = 0;
_fixupBtn = gtk_button_new_with_label(_("Fix"));
g_signal_connect( G_OBJECT(_fixupBtn), "clicked", G_CALLBACK(_fixupHit), (gpointer)this );
gtk_widget_set_sensitive( _fixupBtn, FALSE );
gtk_widget_set_tooltip_text( _fixupBtn, _("Fix RGB fallback to match icc-color() value.") );
//gtk_misc_set_alignment( GTK_MISC (_fixupBtn), 1.0, 0.5 );
gtk_widget_show( _fixupBtn );
gtk_table_attach( GTK_TABLE (t), _fixupBtn, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD );
// Combobox and store with 2 columns : label (0) and full name (1)
GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
_profileSel = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (_profileSel), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (_profileSel), renderer, "text", 0, NULL);
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("<none>"), 1, _("<none>"), -1);
gtk_widget_show( _profileSel );
gtk_combo_box_set_active( GTK_COMBO_BOX(_profileSel), 0 );
gtk_table_attach( GTK_TABLE(t), _profileSel, 1, 2, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD );
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
_profChangedID = g_signal_connect( G_OBJECT(_profileSel), "changed", G_CALLBACK(_profileSelected), (gpointer)this );
#else
gtk_widget_set_sensitive( _profileSel, false );
#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
row++;
_fooCount = 4;
_fooAdj = new GtkAdjustment*[_fooCount];
_fooSlider = new GtkWidget*[_fooCount];
_fooBtn = new GtkWidget*[_fooCount];
_fooLabel = new GtkWidget*[_fooCount];
_fooMap = new guchar*[_fooCount];
for ( guint i = 0; i < _fooCount; i++ ) {
/* Label */
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
_fooLabel[i] = gtk_label_new_with_mnemonic( names[i] );
#else
_fooLabel[i] = gtk_label_new_with_mnemonic( "." );
#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
gtk_misc_set_alignment( GTK_MISC (_fooLabel[i]), 1.0, 0.5 );
gtk_widget_show( _fooLabel[i] );
gtk_table_attach( GTK_TABLE (t), _fooLabel[i], 0, 1, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD );
/* Adjustment */
gdouble step = static_cast<gdouble>(_fooScales[i]) / 100.0;
gdouble page = static_cast<gdouble>(_fooScales[i]) / 10.0;
gint digits = (step > 0.9) ? 0 : 2;
_fooAdj[i] = GTK_ADJUSTMENT( gtk_adjustment_new( 0.0, 0.0, _fooScales[i], step, page, page ) );
/* Slider */
_fooSlider[i] = sp_color_slider_new( _fooAdj[i] );
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
gtk_widget_set_tooltip_text( _fooSlider[i], tips[i] );
#else
gtk_widget_set_tooltip_text( _fooSlider[i], "." );
#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
gtk_widget_show( _fooSlider[i] );
gtk_table_attach( GTK_TABLE (t), _fooSlider[i], 1, 2, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)GTK_FILL, XPAD, YPAD );
_fooBtn[i] = gtk_spin_button_new( _fooAdj[i], step, digits );
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
gtk_widget_set_tooltip_text( _fooBtn[i], tips[i] );
#else
gtk_widget_set_tooltip_text( _fooBtn[i], "." );
#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
sp_dialog_defocus_on_enter( _fooBtn[i] );
gtk_label_set_mnemonic_widget( GTK_LABEL(_fooLabel[i]), _fooBtn[i] );
gtk_widget_show( _fooBtn[i] );
gtk_table_attach( GTK_TABLE (t), _fooBtn[i], 2, 3, row, row + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD );
_fooMap[i] = g_new( guchar, 4 * 1024 );
memset( _fooMap[i], 0x0ff, 1024 * 4 );
/* Signals */
g_signal_connect( G_OBJECT( _fooAdj[i] ), "value_changed", G_CALLBACK( _adjustmentChanged ), _csel );
g_signal_connect( G_OBJECT( _fooSlider[i] ), "grabbed", G_CALLBACK( _sliderGrabbed ), _csel );
g_signal_connect( G_OBJECT( _fooSlider[i] ), "released", G_CALLBACK( _sliderReleased ), _csel );
g_signal_connect( G_OBJECT( _fooSlider[i] ), "changed", G_CALLBACK( _sliderChanged ), _csel );
row++;
}
/* Label */
_label = gtk_label_new_with_mnemonic (_("_A:"));
gtk_misc_set_alignment (GTK_MISC (_label), 1.0, 0.5);
gtk_widget_show (_label);
gtk_table_attach (GTK_TABLE (t), _label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
/* Adjustment */
_adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 255.0, 1.0, 10.0, 10.0);
/* Slider */
_slider = sp_color_slider_new (_adj);
gtk_widget_set_tooltip_text (_slider, _("Alpha (opacity)"));
gtk_widget_show (_slider);
gtk_table_attach (GTK_TABLE (t), _slider, 1, 2, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)GTK_FILL, XPAD, YPAD);
sp_color_slider_set_colors( SP_COLOR_SLIDER( _slider ),
SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 0.0 ),
SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 0.5 ),
SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 1.0 ) );
/* Spinbutton */
_sbtn = gtk_spin_button_new (GTK_ADJUSTMENT (_adj), 1.0, 0);
gtk_widget_set_tooltip_text (_sbtn, _("Alpha (opacity)"));
sp_dialog_defocus_on_enter (_sbtn);
gtk_label_set_mnemonic_widget (GTK_LABEL(_label), _sbtn);
gtk_widget_show (_sbtn);
gtk_table_attach (GTK_TABLE (t), _sbtn, 2, 3, row, row + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD);
/* Signals */
g_signal_connect (G_OBJECT (_adj), "value_changed",
G_CALLBACK (_adjustmentChanged), _csel);
g_signal_connect (G_OBJECT (_slider), "grabbed",
G_CALLBACK (_sliderGrabbed), _csel);
g_signal_connect (G_OBJECT (_slider), "released",
G_CALLBACK (_sliderReleased), _csel);
g_signal_connect (G_OBJECT (_slider), "changed",
G_CALLBACK (_sliderChanged), _csel);
}
void
pidgin_xfer_dialog_update_xfer(PidginXferDialog *dialog,
PurpleXfer *xfer)
{
PidginXferUiData *data;
char *size_str, *remaining_str;
GtkTreeSelection *selection;
time_t current_time;
GtkTreeIter iter;
gboolean valid;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
if ((data = PIDGINXFER(xfer)) == NULL)
return;
if (data->in_list == FALSE)
return;
current_time = time(NULL);
if (((current_time - data->last_updated_time) == 0) &&
(!purple_xfer_is_completed(xfer)))
{
/* Don't update the window more than once per second */
return;
}
data->last_updated_time = current_time;
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
gtk_list_store_set(xfer_dialog->model, &data->iter,
COLUMN_PROGRESS, purple_xfer_get_progress(xfer),
COLUMN_SIZE, size_str,
COLUMN_REMAINING, remaining_str,
-1);
g_free(size_str);
g_free(remaining_str);
if (purple_xfer_is_completed(xfer))
{
GdkPixbuf *pixbuf;
pixbuf = gtk_widget_render_icon(dialog->window,
PIDGIN_STOCK_FILE_DONE,
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_REMAINING, _("Finished"),
-1);
g_object_unref(pixbuf);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(xfer_dialog->tree));
update_title_progress(dialog);
if (xfer == dialog->selected_xfer)
update_detailed_info(xfer_dialog, xfer);
if (purple_xfer_is_completed(xfer) && dialog->auto_clear)
pidgin_xfer_dialog_remove_xfer(dialog, xfer);
else
update_buttons(dialog, xfer);
/*
* If all transfers are finished, and the pref is set, then
* close the dialog. Otherwise just exit this function.
*/
if (dialog->keep_open)
return;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
while (valid)
{
GValue val;
PurpleXfer *next;
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
next = g_value_get_pointer(&val);
if (!purple_xfer_is_completed(next))
return;
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
}
/* If we got to this point then we know everything is finished */
pidgin_xfer_dialog_hide(dialog);
}
static gboolean
zimagez_upload_job (ScreenshooterJob *job, GArray *param_values, GError **error)
{
const gchar *encoded_data;
const gchar *image_path;
const gchar *last_user;
const gchar *proxy_uri;
/* For translators: the first wildcard is the date, the second one the time,
* e.g. "Taken on 12/31/99, at 23:13:48". */
gchar *comment = screenshooter_get_datetime (_("Taken on %x, at %X"));
gchar *data = NULL;
gchar *encoded_password = NULL;
gchar *file_name = NULL;
gchar *login_response = NULL;
gchar *online_file_name = NULL;
gchar *password = g_strdup ("");
gchar *title;
gchar *user;
gsize data_length;
gboolean response = FALSE;
const gchar *serverurl = "http://www.zimagez.com/apiXml.php";
const gchar *method_login = "******";
const gchar *method_logout = "apiXml.xmlrpcLogout";
const gchar *method_upload = "apiXml.xmlrpcUpload";
SoupSession *session;
SoupURI *soup_proxy_uri;
GError *tmp_error = NULL;
GtkTreeIter iter;
GtkListStore *liststore;
GValue response_value;
g_return_val_if_fail (SCREENSHOOTER_IS_JOB (job), FALSE);
g_return_val_if_fail (param_values != NULL, FALSE);
g_return_val_if_fail (param_values->len == 3, FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 0)), FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 1)), FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 2)), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
g_object_set_data (G_OBJECT (job), "jobtype", "zimagez");
if (exo_job_set_error_if_cancelled (EXO_JOB (job), error))
{
g_free (comment);
g_free (password);
return FALSE;
}
/* Get the last user */
last_user = g_value_get_string (&g_array_index (param_values, GValue, 1));
user = g_strdup (last_user);
if (user == NULL)
user = g_strdup ("");
if (!g_utf8_validate (user, -1, NULL))
{
g_free (user);
user = g_strdup ("");
}
g_object_set_data_full (G_OBJECT (job), "user",
g_strdup (user), (GDestroyNotify) g_free);
/* Get the default title */
title = g_strdup (g_value_get_string (&g_array_index (param_values, GValue, 2)));
if (title == NULL)
title = g_strdup ("");
if (!g_utf8_validate (title, -1, NULL))
{
g_free (title);
title = g_strdup ("");
}
/* Get the path of the image that is to be uploaded */
image_path = g_value_get_string (&g_array_index (param_values, GValue, 0));
/* Start the user soup session */
exo_job_info_message (EXO_JOB (job), _("Initialize the connection..."));
session = soup_session_sync_new ();
/* Set the proxy URI if any */
proxy_uri = g_getenv ("http_proxy");
if (proxy_uri != NULL)
{
soup_proxy_uri = soup_uri_new (proxy_uri);
g_object_set (session, "proxy-uri", soup_proxy_uri, NULL);
soup_uri_free (soup_proxy_uri);
}
TRACE ("Get the information liststore ready.");
liststore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
TRACE ("Append the user");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, USER,
1, user,
-1);
TRACE ("Append the password");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, PASSWORD,
1, password,
-1);
TRACE ("Append the title");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, TITLE,
1, title,
-1);
TRACE ("Append the comment");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, COMMENT,
1, comment,
-1);
TRACE ("Ask the user to fill the information items.");
screenshooter_job_ask_info (job, liststore,
_("Please fill the following fields with your "
"<a href=\"http://www.zimagez.com\">ZimageZ</a> \n"
"user name, passsword and details about the screenshot."));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
user = g_strdup (field_value);
break;
case PASSWORD:
password = g_strdup (field_value);
break;
case TITLE:
title = g_strdup (field_value);
break;
case COMMENT:
comment = g_strdup (field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
while (!response)
{
if (exo_job_set_error_if_cancelled (EXO_JOB (job), error))
{
soup_session_abort (session);
g_object_unref (session);
g_free (user);
g_free (password);
g_free (title);
g_free (comment);
if (encoded_password != NULL)
g_free (encoded_password);
TRACE ("The upload job was cancelled.");
return FALSE;
}
exo_job_info_message (EXO_JOB (job), _("Check the user information..."));
/* Test if one of the information fields is empty */
if (has_empty_field (liststore))
{
TRACE ("One of the fields was empty, let the user file it.");
screenshooter_job_ask_info (job, liststore,
_("<span weight=\"bold\" foreground=\"darkred\" "
"stretch=\"semiexpanded\">You must fill all the "
"fields.</span>"));
continue;
}
encoded_password = g_utf8_strreverse (rot13 (password), -1);
TRACE ("User: %s", user);
TRACE ("Encoded password: %s", encoded_password);
/* Start the user session */
TRACE ("Call the login method");
exo_job_info_message (EXO_JOB (job), _("Login on ZimageZ..."));
if (!do_xmlrpc (session, serverurl, method_login,
&tmp_error, &response_value,
G_TYPE_STRING, user,
G_TYPE_STRING, encoded_password,
G_TYPE_INVALID))
{
g_propagate_error (error, tmp_error);
soup_session_abort (session);
g_object_unref (session);
g_free (password);
g_free (title);
g_free (comment);
g_free (encoded_password);
return FALSE;
}
TRACE ("Read the login response");
/* If the response is a boolean, there was an error */
if (G_VALUE_HOLDS_BOOLEAN (&response_value))
{
response = g_value_get_boolean (&response_value);
}
/* Else we read the string response to get the session ID */
else if (G_VALUE_HOLDS_STRING (&response_value))
{
TRACE ("Read the session ID");
login_response = g_strdup (g_value_get_string (&response_value));
response = TRUE;
}
/* We received an unexpected reply */
else
{
GError *tmp_err =
g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"%s", _("An unexpected reply from ZimageZ was received."
" The upload of the screenshot failed."));
soup_session_abort (session);
g_object_unref (session);
g_free (user);
g_free (password);
g_free (title);
g_free (comment);
g_free (encoded_password);
g_propagate_error (error, tmp_err);
return FALSE;
}
g_value_unset (&response_value);
if (!response)
{
/* Login failed, erase the password and ask for the correct on to the
user */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, -1);
if (field_index == PASSWORD)
{
gtk_list_store_set (liststore, &iter, 1, g_strdup (""), -1);
break;
}
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
screenshooter_job_ask_info (job, liststore,
_("<span weight=\"bold\" foreground=\"darkred\" "
"stretch=\"semiexpanded\">The user and the "
"password you entered do not match. "
"Please retry.</span>"));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
user = g_strdup (field_value);
break;
case PASSWORD:
password = g_strdup (field_value);
break;
case TITLE:
title = g_strdup (field_value);
break;
case COMMENT:
comment = g_strdup (field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
}
}
g_object_set_data_full (G_OBJECT (job), "user",
g_strdup (user), (GDestroyNotify) g_free);
g_free (user);
g_free (password);
g_free (encoded_password);
/* Get the contents of the image file and encode it to base64 */
g_file_get_contents (image_path, &data, &data_length, NULL);
encoded_data = g_base64_encode ((guchar*)data, data_length);
g_free (data);
/* Get the basename of the image path */
file_name = g_path_get_basename (image_path);
exo_job_info_message (EXO_JOB (job), _("Upload the screenshot..."));
TRACE ("Call the upload method");
do_xmlrpc (session, serverurl, method_upload,
&tmp_error, &response_value,
G_TYPE_STRING, encoded_data,
G_TYPE_STRING, file_name,
G_TYPE_STRING, title,
G_TYPE_STRING, comment,
G_TYPE_STRING, login_response,
G_TYPE_INVALID);
g_free (title);
g_free (comment);
g_free (file_name);
if (tmp_error)
{
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_error);
return FALSE;
}
/* If the response is a boolean, there was an error */
if (G_VALUE_HOLDS_BOOLEAN (&response_value))
{
if (!g_value_get_boolean (&response_value))
{
GError *tmp_err =
g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
_("An error occurred while uploading the screenshot."));
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_err);
return FALSE;
}
}
/* Else we get the file name */
else if (G_VALUE_HOLDS_STRING (&response_value))
{
TRACE ("The screenshot has been uploaded, get the file name.");
online_file_name = g_strdup (g_value_get_string (&response_value));
}
/* We received un unexpected reply */
else
{
GError *tmp_err =
g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"%s", _("An unexpected reply from ZimageZ was received."
" The upload of the screenshot failed."));
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_err);
return FALSE;
}
g_value_unset (&response_value);
/* End the user session */
exo_job_info_message (EXO_JOB (job), _("Close the session on ZimageZ..."));
TRACE ("Closing the user session");
do_xmlrpc (session, serverurl, method_logout,
&tmp_error, &response_value,
G_TYPE_STRING, login_response,
G_TYPE_INVALID);
if (G_IS_VALUE (&response_value))
g_value_unset (&response_value);
/* Clean the soup session */
soup_session_abort (session);
g_object_unref (session);
g_free (login_response);
screenshooter_job_image_uploaded (job, online_file_name);
if (tmp_error)
{
g_propagate_error (error, tmp_error);
return FALSE;
}
return TRUE;
}
void
pidgin_xfer_dialog_add_xfer(PidginXferDialog *dialog, PurpleXfer *xfer)
{
PidginXferUiData *data;
PurpleXferType type;
GdkPixbuf *pixbuf;
char *size_str, *remaining_str;
char *lfilename, *utf8;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
purple_xfer_ref(xfer);
data = PIDGINXFER(xfer);
data->in_list = TRUE;
pidgin_xfer_dialog_show(dialog);
data->last_updated_time = 0;
type = purple_xfer_get_type(xfer);
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
pixbuf = gtk_widget_render_icon(dialog->window,
(type == PURPLE_XFER_RECEIVE
? PIDGIN_STOCK_DOWNLOAD
: PIDGIN_STOCK_UPLOAD),
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_append(dialog->model, &data->iter);
lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL);
g_free(lfilename);
lfilename = utf8;
gtk_list_store_set(dialog->model, &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_PROGRESS, 0.0,
COLUMN_FILENAME, (type == PURPLE_XFER_RECEIVE)
? purple_xfer_get_filename(xfer)
: lfilename,
COLUMN_SIZE, size_str,
COLUMN_REMAINING, _("Waiting for transfer to begin"),
COLUMN_DATA, xfer,
-1);
g_free(lfilename);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dialog->tree));
g_object_unref(pixbuf);
g_free(size_str);
g_free(remaining_str);
dialog->num_transfers++;
ensure_row_selected(dialog);
update_title_progress(dialog);
}
void prov_xdk_create_list (class prov_xdk_data *data)
{
iceb_clock sss(data->window);
GtkListStore *model=NULL;
GtkTreeIter iter;
SQLCURSOR cur;
char strsql[512];
int kolstr=0;
SQL_str row;
//printf("prov_xdk_create_list %d\n",data->snanomer);
data->kl_shift=0; //0-отжата 1-нажата
if(data->treeview != NULL)
gtk_widget_destroy(data->treeview);
data->treeview = gtk_tree_view_new();
gtk_container_add (GTK_CONTAINER (data->sw), data->treeview);
g_signal_connect(data->treeview,"row_activated",G_CALLBACK(prov_xdk_v_row),data);
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview));
gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE);
g_signal_connect(selection,"changed",G_CALLBACK(prov_xdk_vibor),data);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE);
model = gtk_list_store_new (NUM_COLUMNS+1,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_LONG,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
iceb_u_str zapros;
if(data->metka_r == 2)
sprintf(strsql,"select datp,sh,shk,kodkon,deb,kre,komen,ktoi,vrem,val,kekv \
from Prov where kto='%s' and pod=%d and nomd='%s' and \
datd='%04d-%02d-%02d' and oper='%s' and tz=%d order by datp asc",
data->metkasys,0,rec.nomdk.ravno_filtr(),
rec.gd,rec.md,rec.dd,rec.kodop.ravno_filtr(),rec.tipz);
if(data->metka_r == 0)
sprintf(strsql,"select datp,sh,shk,kodkon,deb,kre,komen,ktoi,vrem,val,kekv \
from Prov where kto='%s' and pod=%d and nomd='%s' and \
datd='%04d-%02d-%02d' and oper='%s' and tz=%d and deb <> 0. order by datp asc",
data->metkasys,0,rec.nomdk.ravno_filtr(),
rec.gd,rec.md,rec.dd,rec.kodop.ravno_filtr(),rec.tipz);
// data->metkasys,0,data->nomdok.ravno_filtr(),
// data->gd,data->md,data->dd,data->kodop.ravno_filtr(),data->tipz);
if(data->metka_r == 1)
sprintf(strsql,"select datp,sh,shk,kodkon,deb,kre,komen,ktoi,vrem,val,kekv \
from Prov where kto='%s' and pod=%d and nomd='%s' and \
datd='%04d-%02d-%02d' and oper='%s' and tz=%d and kre <> 0. order by datp asc",
data->metkasys,0,rec.nomdk.ravno_filtr(),
rec.gd,rec.md,rec.dd,rec.kodop.ravno_filtr(),rec.tipz);
// data->metkasys,0,data->nomdok.ravno_filtr(),
// data->gd,data->md,data->dd,data->kodop.ravno_filtr(),data->tipz);
data->zapros.new_plus(strsql);
if((kolstr=cur.make_cursor(&bd,data->zapros.ravno())) < 0)
{
iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),data->zapros.ravno(),data->window);
return;
}
//gtk_list_store_clear(model);
iceb_u_str ss[NUM_COLUMNS];
data->kolzap=0;
data->suma_deb=0.;
data->suma_kre=0.;
while(cur.read_cursor(&row) != 0)
{
// printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]);
// if(prov_xdk_prov_row(row,&data->rk,data->window) != 0)
// continue;
// if(iceb_u_SRAV(data->vvod.god.ravno(),row[0],0) == 0 && iceb_u_SRAV(data->vvod.shet.ravno(),row[1],0) == 0)
// data->snanomer=data->kolzap;
//Дата
ss[COL_DATA].new_plus(iceb_u_sqldata(row[0]));
//Счёт
ss[COL_SHET].new_plus(iceb_u_toutf(row[1]));
//Счёт корреспондент
ss[COL_SHET_KOR].new_plus(iceb_u_toutf(row[2]));
//Контрагент
ss[COL_KONTR].new_plus(iceb_u_toutf(row[3]));
//Дебет
ss[COL_DEBET].new_plus(iceb_u_toutf(row[4]));
data->suma_deb+=atof(row[4]);
//Кредит
ss[COL_KREDIT].new_plus(iceb_u_toutf(row[5]));
data->suma_kre+=atof(row[5]);
//Коментарий
ss[COL_KOMENT].new_plus(iceb_u_toutf(row[6]));
//Дата и время записи
ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[8])));
//Кто записал
ss[COL_KTO].new_plus(iceb_kszap(row[7],0,data->window));
if(atoi(row[10]) != 0)
ss[COL_KEKV].new_plus(row[10]);
else
ss[COL_KEKV].new_plus("");
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_DATA,ss[COL_DATA].ravno(),
COL_KEKV,ss[COL_KEKV].ravno(),
COL_SHET,ss[COL_SHET].ravno(),
COL_SHET_KOR,ss[COL_SHET_KOR].ravno(),
COL_KONTR,ss[COL_KONTR].ravno(),
COL_DEBET,ss[COL_DEBET].ravno(),
COL_KREDIT,ss[COL_KREDIT].ravno(),
COL_KOMENT,ss[COL_KOMENT].ravno(),
COL_DATA_VREM,ss[COL_DATA_VREM].ravno(),
COL_KTO,ss[COL_KTO].ravno(),
COL_VREM,atol(row[8]),
COL_KTOZ,atoi(row[7]),
COL_VAL,atoi(row[9]),
NUM_COLUMNS,data->kolzap,
-1);
data->kolzap++;
}
gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model));
g_object_unref (GTK_TREE_MODEL (model));
prov_xdk_add_columns (GTK_TREE_VIEW (data->treeview));
if(data->kolzap == 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна
}
else
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна
}
gtk_widget_show (data->treeview);
gtk_widget_show (data->sw);
iceb_snanomer(data->kolzap,&data->snanomer,data->treeview);
prov_xdk_sapka_menu(data);
gtk_widget_show(data->label_kolstr);
}
void
completion_populate_entry_completion(const gchar *filename, GtkEntryCompletion *completion)
{
GtkTreeModel *model;
GtkTreeIter iter;
char *path;
GFile *file;
GFileInputStream *stream;
gint column;
GError *err = NULL;
gchar buffer[block_size];
const gchar *ptr;
gssize size;
g_assert(filename != NULL);
g_assert(GTK_IS_ENTRY_COMPLETION(completion));
model = gtk_entry_completion_get_model(GTK_ENTRY_COMPLETION(completion));
column = gtk_entry_completion_get_text_column(GTK_ENTRY_COMPLETION(completion));
path = g_build_filename(pathbuilder_get_user_application_directory(), G_DIR_SEPARATOR_S, filename, NULL);
file = g_file_new_for_path(path);
/* load strings from file & append entries to GtkEntryCompletion's model */
g_debug("Trying to load strings list from: \"%s\"", path);
if(g_file_query_exists(file, NULL))
{
g_debug("Found file, reading content...");
if((stream = g_file_read(file, NULL, &err)))
{
model = gtk_entry_completion_get_model(GTK_ENTRY_COMPLETION(completion));
do
{
if((size = g_input_stream_read(G_INPUT_STREAM(stream), buffer, block_size, NULL, &err)) == block_size)
{
ptr = buffer + COMPLETION_COUNTER_SIZE;
g_debug("Found text: \"%s\"", ptr);
if(GTK_IS_LIST_STORE(model))
{
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, column, ptr, -1);
}
else
{
g_warning("gtk_entry_completion_get_model() is not GTK_LIST_STORE");
}
}
else
{
if(size)
{
g_warning("Invalid block size: %d", size);
}
break;
}
} while(!err && size);
g_debug("Closing file: \"%s\"", path);
g_input_stream_close(G_INPUT_STREAM(stream), NULL, &err);
g_object_unref(stream);
}
else
{
g_warning("Couldn't read file: \"%s\"", path);
}
}
if(err)
{
g_warning("%s", err->message);
g_error_free(err);
}
g_object_unref(file);
g_free(path);
}
static void
init_view_setup_providers( GtkTreeView *treeview, BaseWindow *window )
{
static const gchar *thisfn = "cact_providers_list_init_view_setup_providers";
CactApplication *application;
NAUpdater *updater;
GtkListStore *model;
const GList *providers;
const GList *iter;
GtkTreeIter row;
gchar *id, *libelle;
gboolean readable, readable_mandatory;
gboolean writable, writable_mandatory;
NAIOProvider *provider;
model = GTK_LIST_STORE( gtk_tree_view_get_model( treeview ));
application = CACT_APPLICATION( base_window_get_application( window ));
updater = cact_application_get_updater( application );
providers = na_io_provider_get_io_providers_list( NA_PIVOT( updater ));
for( iter = providers ; iter ; iter = iter->next ){
provider = NA_IO_PROVIDER( iter->data );
id = na_io_provider_get_id( provider );
libelle = na_io_provider_get_name( provider );
readable = na_io_provider_is_conf_readable( provider, NA_PIVOT( updater ), &readable_mandatory );
writable = na_io_provider_is_conf_writable( provider, NA_PIVOT( updater ), &writable_mandatory );
g_debug( "%s: id=%s, readable=%s (mandatory=%s), writable=%s (mandatory=%s)",
thisfn, id,
readable ? "True":"False", readable_mandatory ? "True":"False",
writable ? "True":"False", writable_mandatory ? "True":"False" );
if( !libelle || !g_utf8_strlen( libelle, -1 )){
g_free( libelle );
if( na_io_provider_is_available( provider )){
/* i18n: default name when the I/O providers doesn't provide one */
libelle = g_strdup_printf( "<%s: %s>", id, _( "no name" ));
} else {
/* i18n: name displayed when the corresponding I/O provider is unavailable at runtime */
libelle = g_strdup_printf( "<%s: %s>", id, _( "unavailable I/O provider" ));
}
}
gtk_list_store_append( model, &row );
gtk_list_store_set( model, &row,
PROVIDER_READABLE_COLUMN, readable,
PROVIDER_READABLE_MANDATORY_COLUMN, readable_mandatory,
PROVIDER_WRITABLE_COLUMN, writable,
PROVIDER_WRITABLE_MANDATORY_COLUMN, writable_mandatory,
PROVIDER_LIBELLE_COLUMN, libelle,
PROVIDER_ID_COLUMN, id,
PROVIDER_PROVIDER_COLUMN, iter->data,
-1 );
g_free( libelle );
g_free( id );
}
}
int add_interface(GtkWidget *button, gpointer data)
{
fwnet_interface_t *newinterface = NULL;
GtkWidget *cellview;
GdkPixbuf *connectimg;
char *ptr=NULL;
char *nettype=NULL;
char *iface=NULL;
GtkTreeIter iter;
GtkTreeModel *model;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(intercombo), &iter);
model = gtk_combo_box_get_model(GTK_COMBO_BOX(intercombo));
gtk_tree_model_get (model, &iter, 0, &iface, -1);
int i;
for(i=0;i<g_list_length(interfaceslist); i+=2)
{
if(!strcmp((char*)g_list_nth_data(interfaceslist, i), iface))
{
fwife_error("This interface has been already configured!");
return -1;
}
}
if((newinterface = (fwnet_interface_t*)malloc(sizeof(fwnet_interface_t))) == NULL)
return(-1);
memset(newinterface, 0, sizeof(fwnet_interface_t));
snprintf(newinterface->name, IF_NAMESIZE, iface);
nettype = ask_nettype();
if(nettype == NULL)
return -1;
if(strcmp(nettype, "lo"))
{
interfaceslist = g_list_append(interfaceslist, strdup(iface));
interfaceslist = g_list_append(interfaceslist, newinterface);
GtkTreeView *treeview = (GtkTreeView *)data;
model = gtk_tree_view_get_model (treeview);
cellview = gtk_cell_view_new ();
connectimg = gtk_widget_render_icon (cellview, GTK_STOCK_NETWORK,
GTK_ICON_SIZE_BUTTON, NULL);
gtk_widget_destroy (cellview);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_NET_IMAGE, connectimg, COLUMN_NET_NAME, iface, -1);
}
if(strcmp(nettype, "lo") && fwnet_is_wireless_device(iface))
{
switch(fwife_question(_("It seems that this network card has a wireless extension.\n\nConfigure your wireless now?")))
{
case GTK_RESPONSE_YES:
configure_wireless(newinterface);
break;
case GTK_RESPONSE_NO:
break;
}
}
if(!strcmp(nettype, "dhcp"))
{
ptr = fwife_entry(_("Set DHCP hostname"), _("Some network providers require that the DHCP hostname be\n"
"set in order to connect.\n If so, they'll have assigned a hostname to your machine.\n If you were"
"assigned a DHCP hostname, please enter it below.\n If you do not have a DHCP hostname, just"
"hit enter."), NULL);
if(strlen(ptr))
snprintf(newinterface->dhcp_opts, PATH_MAX, "-t 10 -h %s\n", ptr);
else
newinterface->dhcp_opts[0]='\0';
newinterface->options = g_list_append(newinterface->options, strdup("dhcp"));
gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_NET_IP, "dhcp", COLUMN_NET_NAMESERV, ptr, -1);
FREE(ptr);
}
else if(!strcmp(nettype, "static"))
{
configure_static(newinterface, iter);
}
return 0;
}
static int
fill_account_list (StockSplitInfo *info, Account *selected_account)
{
GtkTreeRowReference *reference = NULL;
GtkTreeView *view;
GtkListStore *list;
GtkTreeIter iter;
GtkTreePath *path;
GList *accounts;
GList *node;
gint rows = 0;
gchar *full_name;
view = GTK_TREE_VIEW(info->account_view);
list = GTK_LIST_STORE(gtk_tree_view_get_model(view));
gtk_list_store_clear (list);
accounts = gnc_account_get_descendants_sorted (gnc_get_current_root_account ());
for (node = accounts; node; node = node->next)
{
Account *account = node->data;
GNCPrintAmountInfo print_info;
const gnc_commodity *commodity;
gnc_numeric balance;
if (!xaccAccountIsPriced(account))
continue;
balance = xaccAccountGetBalance (account);
if (gnc_numeric_zero_p (balance))
continue;
if (xaccAccountGetPlaceholder (account))
continue;
commodity = xaccAccountGetCommodity (account);
full_name = gnc_account_get_full_name (account);
print_info = gnc_account_print_info (account, FALSE);
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
SPLIT_COL_ACCOUNT, account,
SPLIT_COL_FULLNAME, full_name,
SPLIT_COL_MNEMONIC, gnc_commodity_get_mnemonic(commodity),
SPLIT_COL_SHARES, xaccPrintAmount(balance, print_info),
-1);
if (account == selected_account)
{
path = gtk_tree_model_get_path(GTK_TREE_MODEL(list), &iter);
reference = gtk_tree_row_reference_new(GTK_TREE_MODEL(list), path);
gtk_tree_path_free(path);
}
g_free (full_name);
rows++;
}
g_list_free(accounts);
if (reference)
{
GtkTreeSelection* selection = gtk_tree_view_get_selection(view);
path = gtk_tree_row_reference_get_path(reference);
gtk_tree_row_reference_free(reference);
if (path)
{
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_scroll_to_cell(view, path, NULL, TRUE, 0.5, 0.0);
gtk_tree_path_free(path);
}
}
return rows;
}
static GtkWidget *
inner_auth_combo_init (EAPMethodPEAP *method,
NMConnection *connection,
NMSetting8021x *s_8021x,
gboolean secrets_only)
{
EAPMethod *parent = (EAPMethod *) method;
GtkWidget *combo;
GtkListStore *auth_model;
GtkTreeIter iter;
EAPMethodSimple *em_mschap_v2;
EAPMethodSimple *em_md5;
EAPMethodSimple *em_gtc;
guint32 active = 0;
const char *phase2_auth = NULL;
EAPMethodSimpleFlags simple_flags;
auth_model = gtk_list_store_new (2, G_TYPE_STRING, eap_method_get_type ());
if (s_8021x) {
if (nm_setting_802_1x_get_phase2_auth (s_8021x))
phase2_auth = nm_setting_802_1x_get_phase2_auth (s_8021x);
else if (nm_setting_802_1x_get_phase2_autheap (s_8021x))
phase2_auth = nm_setting_802_1x_get_phase2_autheap (s_8021x);
}
simple_flags = EAP_METHOD_SIMPLE_FLAG_PHASE2;
if (method->is_editor)
simple_flags |= EAP_METHOD_SIMPLE_FLAG_IS_EDITOR;
if (secrets_only)
simple_flags |= EAP_METHOD_SIMPLE_FLAG_SECRETS_ONLY;
em_mschap_v2 = eap_method_simple_new (method->sec_parent,
connection,
EAP_METHOD_SIMPLE_TYPE_MSCHAP_V2,
simple_flags);
gtk_list_store_append (auth_model, &iter);
gtk_list_store_set (auth_model, &iter,
I_NAME_COLUMN, _("MSCHAPv2"),
I_METHOD_COLUMN, em_mschap_v2,
-1);
eap_method_unref (EAP_METHOD (em_mschap_v2));
/* Check for defaulting to MSCHAPv2 */
if (phase2_auth && !strcasecmp (phase2_auth, "mschapv2"))
active = 0;
em_md5 = eap_method_simple_new (method->sec_parent,
connection,
EAP_METHOD_SIMPLE_TYPE_MD5,
simple_flags);
gtk_list_store_append (auth_model, &iter);
gtk_list_store_set (auth_model, &iter,
I_NAME_COLUMN, _("MD5"),
I_METHOD_COLUMN, em_md5,
-1);
eap_method_unref (EAP_METHOD (em_md5));
/* Check for defaulting to MD5 */
if (phase2_auth && !strcasecmp (phase2_auth, "md5"))
active = 1;
em_gtc = eap_method_simple_new (method->sec_parent,
connection,
EAP_METHOD_SIMPLE_TYPE_GTC,
simple_flags);
gtk_list_store_append (auth_model, &iter);
gtk_list_store_set (auth_model, &iter,
I_NAME_COLUMN, _("GTC"),
I_METHOD_COLUMN, em_gtc,
-1);
eap_method_unref (EAP_METHOD (em_gtc));
/* Check for defaulting to GTC */
if (phase2_auth && !strcasecmp (phase2_auth, "gtc"))
active = 2;
combo = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_combo"));
g_assert (combo);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (auth_model));
g_object_unref (G_OBJECT (auth_model));
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), active);
g_signal_connect (G_OBJECT (combo), "changed",
(GCallback) inner_auth_combo_changed_cb,
method);
return combo;
}
void admin_icebuser_create_list (class admin_icebuser_data *data)
{
class iceb_gdite_data gdite;
iceb_gdite(&gdite,0,data->window);
iceb_clock sss(data->window);
GtkListStore *model=NULL;
GtkTreeIter iter;
SQLCURSOR cur;
char strsql[512];
int kolstr=0;
SQL_str row;
//GdkColor color;
data->kl_shift=0; //0-отжата 1-нажата
if(data->treeview != NULL)
gtk_widget_destroy(data->treeview);
data->treeview = gtk_tree_view_new();
gtk_container_add (GTK_CONTAINER (data->sw), data->treeview);
g_signal_connect(data->treeview,"row_activated",G_CALLBACK(admin_icebuser_v_row),data);
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview));
gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE);
g_signal_connect(selection,"changed",G_CALLBACK(admin_icebuser_vibor),data);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE);
model = gtk_list_store_new (NUM_COLUMNS+1,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT);
sprintf(strsql,"select * from icebuser order by login asc");
if((kolstr=cur.make_cursor(&bd,strsql)) < 0)
{
iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window);
return;
}
//gtk_list_store_clear(model);
iceb_u_str ss[NUM_COLUMNS];
data->kolzap=0;
float kolstr1=0. ;
while(cur.read_cursor(&row) != 0)
{
// printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]);
iceb_pbar(gdite.bar,kolstr,++kolstr1);
if(iceb_u_SRAV(data->logtv.ravno(),row[0],0) == 0)
data->snanomer=data->kolzap;
//Логин
ss[COL_LOG].new_plus(iceb_u_toutf(row[0]));
//Фамилия
ss[COL_FIO].new_plus(iceb_u_toutf(row[1]));
/*Уникальный номер оператора*/
ss[COL_UN].new_plus(row[2]);
/*КОМЕНТАРИЙ*/
ss[COL_KOMENT].new_plus(iceb_u_toutf(row[3]));
/*Гланая книга*/
if(atoi(row[6]) == 0)
ss[COL_GK].new_plus("Y-");
else
ss[COL_GK].new_plus("N-");
if(atoi(row[7]) == 0)
ss[COL_GK].plus("Y-");
else
ss[COL_GK].plus("N-");
if(atoi(row[8]) == 0)
ss[COL_GK].plus("Y");
else
ss[COL_GK].plus("N");
/*Материальный учёт*/
if(atoi(row[9]) == 0)
ss[COL_MU].new_plus("Y-");
else
ss[COL_MU].new_plus("N-");
if(atoi(row[10]) == 0)
ss[COL_MU].plus("Y-");
else
ss[COL_MU].plus("N-");
if(atoi(row[11]) == 0)
ss[COL_MU].plus("Y");
else
ss[COL_MU].plus("N");
/*Платёжные документы*/
if(atoi(row[12]) == 0)
ss[COL_PD].new_plus("Y-");
else
ss[COL_PD].new_plus("N-");
if(atoi(row[13]) == 0)
ss[COL_PD].plus("Y-");
else
ss[COL_PD].plus("N-");
if(atoi(row[14]) == 0)
ss[COL_PD].plus("Y");
else
ss[COL_PD].plus("N");
/*Заработная плата*/
if(atoi(row[15]) == 0)
ss[COL_ZP].new_plus("Y-");
else
ss[COL_ZP].new_plus("N-");
if(atoi(row[16]) == 0)
ss[COL_ZP].plus("Y-");
else
ss[COL_ZP].plus("N-");
if(atoi(row[17]) == 0)
ss[COL_ZP].plus("Y");
else
ss[COL_ZP].plus("N");
/*Учёт основных средств*/
if(atoi(row[18]) == 0)
ss[COL_UOS].new_plus("Y-");
else
ss[COL_UOS].new_plus("N-");
if(atoi(row[19]) == 0)
ss[COL_UOS].plus("Y-");
else
ss[COL_UOS].plus("N-");
if(atoi(row[20]) == 0)
ss[COL_UOS].plus("Y");
else
ss[COL_UOS].plus("N");
/*Учёт услуг*/
if(atoi(row[21]) == 0)
ss[COL_UU].new_plus("Y-");
else
ss[COL_UU].new_plus("N-");
if(atoi(row[22]) == 0)
ss[COL_UU].plus("Y-");
else
ss[COL_UU].plus("N-");
if(atoi(row[23]) == 0)
ss[COL_UU].plus("Y");
else
ss[COL_UU].plus("N");
/*Учёт кассовых ордеров*/
if(atoi(row[24]) == 0)
ss[COL_UKO].new_plus("Y-");
else
ss[COL_UKO].new_plus("N-");
if(atoi(row[25]) == 0)
ss[COL_UKO].plus("Y-");
else
ss[COL_UKO].plus("N-");
if(atoi(row[26]) == 0)
ss[COL_UKO].plus("Y");
else
ss[COL_UKO].plus("N");
/*Учёт командировочных расходов*/
if(atoi(row[27]) == 0)
ss[COL_UKR].new_plus("Y-");
else
ss[COL_UKR].new_plus("N-");
if(atoi(row[28]) == 0)
ss[COL_UKR].plus("Y-");
else
ss[COL_UKR].plus("N-");
if(atoi(row[29]) == 0)
ss[COL_UKR].plus("Y");
else
ss[COL_UKR].plus("N");
/*Учёт путевых листов*/
if(atoi(row[30]) == 0)
ss[COL_UPL].new_plus("Y-");
else
ss[COL_UPL].new_plus("N-");
if(atoi(row[31]) == 0)
ss[COL_UPL].plus("Y-");
else
ss[COL_UPL].plus("N-");
if(atoi(row[32]) == 0)
ss[COL_UPL].plus("Y");
else
ss[COL_UPL].plus("N");
/*Реестр счет-фактур*/
if(atoi(row[33]) == 0)
ss[COL_RNN].new_plus("Y-");
else
ss[COL_RNN].new_plus("N-");
if(atoi(row[34]) == 0)
ss[COL_RNN].plus("Y-");
else
ss[COL_RNN].plus("N-");
if(atoi(row[35]) == 0)
ss[COL_RNN].plus("Y");
else
ss[COL_RNN].plus("N");
/*Учёт доверенностей*/
if(atoi(row[36]) == 0)
ss[COL_UD].new_plus("Y-");
else
ss[COL_UD].new_plus("N-");
if(atoi(row[37]) == 0)
ss[COL_UD].plus("Y-");
else
ss[COL_UD].plus("N-");
if(atoi(row[38]) == 0)
ss[COL_UD].plus("Y");
else
ss[COL_UD].plus("N");
//Дата и время записи
ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[5])));
//Кто записал
ss[COL_KTO].new_plus(iceb_u_kszap(row[4],0));
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_LOG,ss[COL_LOG].ravno(),
COL_UN,ss[COL_UN].ravno(),
COL_FIO,ss[COL_FIO].ravno(),
COL_KOMENT,ss[COL_KOMENT].ravno(),
COL_GK,ss[COL_GK].ravno(),
COL_MU,ss[COL_MU].ravno(),
COL_PD,ss[COL_PD].ravno(),
COL_ZP,ss[COL_ZP].ravno(),
COL_UOS,ss[COL_UOS].ravno(),
COL_UU,ss[COL_UU].ravno(),
COL_UKO,ss[COL_UKO].ravno(),
COL_UKR,ss[COL_UKR].ravno(),
COL_UPL,ss[COL_UPL].ravno(),
COL_RNN,ss[COL_RNN].ravno(),
COL_UD,ss[COL_UD].ravno(),
COL_DATA_VREM,ss[COL_DATA_VREM].ravno(),
COL_KTO,ss[COL_KTO].ravno(),
NUM_COLUMNS,data->kolzap,
-1);
data->kolzap++;
}
data->logtv.new_plus("");
gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model));
g_object_unref (GTK_TREE_MODEL (model));
admin_icebuser_add_columns (GTK_TREE_VIEW (data->treeview));
if(data->kolzap == 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),FALSE);//Недоступна
}
else
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),TRUE);//Доступна
}
gtk_widget_show (data->treeview);
gtk_widget_show (data->sw);
//Стать подсветкой стороки на нужный номер строки
iceb_snanomer(data->kolzap,&data->snanomer,data->treeview);
iceb_u_str stroka;
iceb_u_str zagolov;
zagolov.plus(gettext("Список операторов"));
sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap);
zagolov.plus(strsql);
gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf());
/*******************************
if(data->metka_poi == 1)
{
zagolov.new_plus(gettext("Поиск"));
zagolov.plus(" !!!");
iceb_str_poisk(&zagolov,data->poisk.kod.ravno(),gettext("Код"));
iceb_str_poisk(&zagolov,data->poisk.naim.ravno(),gettext("Наименование"));
gtk_label_set_text(GTK_LABEL(data->label_poisk),zagolov.ravno_toutf());
gtk_widget_show(data->label_poisk);
}
else
******************************/
gtk_widget_hide(data->label_poisk);
gtk_widget_show(data->label_kolstr);
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t));
dt_storage_facebook_gui_data_t *ui = self->gui_data;
ui->facebook_api = fb_api_init();
self->widget = gtk_vbox_new(FALSE, 0);
//create labels
ui->label_album_title = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label_album_summary = GTK_LABEL( gtk_label_new( _("summary") ) );
ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_misc_set_alignment(GTK_MISC(ui->label_album_title), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label_album_summary), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label_album_privacy), 0.0, 0.5);
//create entries
GtkListStore *model_username = gtk_list_store_new (COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); //text, token, id
ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
ui->entry_album_summary = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary));
//retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_hbox_new(FALSE, 0);
GtkListStore *model_album = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); //name, id
ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->comboBox_album,combobox_separator,ui->comboBox_album,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0);
ui->comboBox_privacy= GTK_COMBO_BOX(gtk_combo_box_text_new());
GtkListStore *list_store = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT);
GtkTreeIter iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1);
gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
//pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_hbox_new(FALSE,5);
GtkWidget *vbox_auth_labels=gtk_vbox_new(FALSE,0);
GtkWidget *vbox_auth_fields=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); //hide it by default
GtkWidget *vbox_album_labels=gtk_vbox_new(FALSE,0);
GtkWidget *vbox_album_fields=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0);
//connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
g_object_unref(list_store);
}
static GtkWidget *
zenity_forms_create_and_fill_list (
ZenityFormsData *forms_data, int list_number, gchar *header) {
GtkListStore *list_store;
GtkWidget *tree_view;
GtkWidget *scrolled_window;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GType *column_types = NULL;
gchar *list_values;
gchar *column_values;
gint i = 0;
/* If no column names available, default is one */
gint n_columns = 1;
gint column_index = 0;
tree_view = gtk_tree_view_new ();
if (forms_data->column_values) {
int columns_values_count =
g_slist_length (forms_data->column_values);
int column_number = 0;
if (list_number < columns_values_count) {
column_number = list_number;
}
column_values =
g_slist_nth_data (forms_data->column_values, column_number);
if (column_values) {
gchar **values = g_strsplit_set (column_values, "|", -1);
if (values) {
n_columns = g_strv_length (values);
column_types = g_new (GType, n_columns);
for (i = 0; i < n_columns; i++)
column_types[i] = G_TYPE_STRING;
for (i = 0; i < n_columns; i++) {
gchar *column_name = values[i];
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
column_name, renderer, "text", column_index, NULL);
gtk_tree_view_append_column (
GTK_TREE_VIEW (tree_view), column);
column_index++;
}
}
} else {
/* If no values available, add one with string type*/
column_types = g_new (GType, n_columns);
column_types[0] = G_TYPE_STRING;
}
}
list_store = g_object_new (GTK_TYPE_LIST_STORE, NULL);
gtk_list_store_set_column_types (list_store, n_columns, column_types);
if (forms_data->list_values) {
list_values = g_slist_nth_data (forms_data->list_values, list_number);
if (list_values) {
gchar **row_values = g_strsplit_set (list_values, "|", -1);
if (row_values) {
GtkTreeIter iter;
gchar *row = row_values[0];
gint position = -1;
i = 0;
while (row != NULL) {
if (position >= n_columns || position == -1) {
position = 0;
gtk_list_store_append (list_store, &iter);
}
gtk_list_store_set (list_store, &iter, position, row, -1);
position++;
row = row_values[++i];
}
g_strfreev (row_values);
}
g_free (list_values);
}
}
gtk_tree_view_set_model (
GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
// gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW
// (scrolled_window),
// GTK_WIDGET (tree_view));
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
gtk_tree_view_set_headers_visible (
GTK_TREE_VIEW (tree_view), forms_data->show_header);
return scrolled_window;
}
