/* Zustaendig fue alleswas auf der Telefonliste passiet. * mittels type wird ausgewaehlt was zu tun ist: * E_DEL loescht den momentan selektieren Eintrag in der * Telefonliste (nach einer Ja/Nein abfrage) * E_MOD zeigt einen Dialog zum bearbeitendes momentan * selektierten Eintrages und aendert ihn nach erfolgter * Eingabe * E_NEW Zeigt einen Dialog zum anlegen eines neuen * Eintrages und legt diesesn nach erfolgter Eingabe * an. * Nach allen 3 Operationen wird das Modell neu geladen * um Konsistent mit den Daten in der eigendlichen * Liste zu bleiben und die Liste als Bearbeitet markiert. * Args: * type .. E_DEL - Selektierten Eintrag loeschen * E_MOD - Selektieren Eintrag aendern * E_NEW - Neuen Eintag hinzufuegen * Ret: * Nichts * */ void modifyPhoneList(int type){ GtkEntry *nameField, *givenField, *phoneField; GtkTreeIter iter, listsIter; GtkTreeModel *model; char *name, *given, *phone, *listName, *labelString, *tmp; int oldNum, strSize; tList *list = NULL; GtkWidget *label, *dialog; if(gtk_tree_selection_get_selected (listsListSel, NULL, &listsIter)){ if(gtk_list_store_iter_is_valid(listsListStore, &listsIter)){ gtk_tree_model_get((GtkTreeModel*)listsListStore, &listsIter, NAME_LISTS_COLUMN, &listName, -1); list = getPhoneList(listName); if (type == E_MOD || type == E_DEL){ if( ! gtk_tree_selection_get_selected (phoneListSel, &model, &iter)){ return; } else { if( ! gtk_list_store_iter_is_valid((GtkListStore*)model, &iter)){ return; } } gtk_tree_model_get((GtkTreeModel*)model, &iter, PHONE_NAME_COLUMN, &name, PHONE_GIVEN_COLUMN, &given, PHONE_COLUMN, &phone, -1); } if (type == E_MOD || type == E_NEW){ nameField = (GtkEntry*)glade_xml_get_widget(xml,"nameField"); givenField = (GtkEntry*)glade_xml_get_widget(xml,"givenField"); phoneField = (GtkEntry*)glade_xml_get_widget(xml,"phoneField"); } if (type == E_MOD){ gtk_entry_set_text (nameField, name); gtk_entry_set_text (givenField, given); gtk_entry_set_text (phoneField, phone); } if (type == E_NEW){ gtk_entry_set_text (nameField, ""); gtk_entry_set_text (givenField, ""); gtk_entry_set_text (phoneField, ""); model = gtk_tree_view_get_model(GTK_TREE_VIEW(phoneView)); } if (type == E_MOD || type == E_NEW){ dialog = entryDialog; } else { strSize = strlen(name) + strlen(given) + strlen(phone) + 70; labelString = malloc(sizeof(char) *(strSize)); snprintf(labelString, strSize, "Den Eintrag von\n%s, %s\n(Tel: %s)\nwirklich loeschen?", name, given, phone); dialog = gtk_dialog_new_with_buttons ("Loeschen?", (GtkWindow*)main_app_window, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_YES, GTK_RESPONSE_ACCEPT, GTK_STOCK_NO, GTK_RESPONSE_REJECT, NULL); label = gtk_label_new (labelString); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label); gtk_widget_show(label); } if(GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))){ if (type == E_MOD || type == E_DEL){ oldNum = *((gint*)gtk_tree_path_get_indices(gtk_tree_model_get_path(model, &iter))); // g_print("Mod-Num: %d\n", oldNum); } if (type == E_MOD || type == E_DEL){ removeByIdx(list, oldNum); setPhoneListModified(listName, MODIFIED); } if (type == E_MOD || type == E_NEW){ tmp = (char*)gtk_entry_get_text (nameField); name = malloc(sizeof(char)*strlen(tmp)+2); strcpy(name, tmp); tmp = (char*)gtk_entry_get_text (givenField); given = malloc(sizeof(char)*strlen(tmp)+2); strcpy(given, tmp); tmp = (char*)gtk_entry_get_text (phoneField); phone = malloc(sizeof(char)*strlen(tmp)+2); strcpy(phone, tmp); insertEntrySorted(list, createEntry(name, given, phone)); setPhoneListModified(listName, MODIFIED); } refreshPhoneModel(GTK_LIST_STORE(model), list); } if (type == E_MOD || type == E_NEW){ gtk_widget_hide(entryDialog); } else { gtk_widget_destroy(dialog); free (labelString); } } } }
int buhrpzw_m(class buhrpzw_rr *rek_r, GtkWidget *wpredok) { class buhrpzw_m_data data; char strsql[512]; data.rk=rek_r; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Расчёт видов затрат по элементам")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(buhrpzw_m_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *label=gtk_label_new (gettext("Расчёт видов затрат по элементам")); gtk_box_pack_start (GTK_BOX (vbox),label,FALSE, FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkTooltips *tooltips_enter[KOLENTER]; sprintf(strsql,"%s",gettext("Дата начала")); data.knopka_enter[E_DATAN]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.knopka_enter[E_DATAN], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAN]),"clicked",GTK_SIGNAL_FUNC(buhrpzw_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAN]),(gpointer)E_DATAN); tooltips_enter[E_DATAN]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_DATAN],data.knopka_enter[E_DATAN],gettext("Выбор даты начала отчёта"),NULL); data.entry[E_DATAN] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.entry[E_DATAN], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAN]), "activate",GTK_SIGNAL_FUNC(buhrpzw_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAN]),data.rk->datan.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAN]),(gpointer)E_DATAN); sprintf(strsql,"%s",gettext("Дата конца")); data.knopka_enter[E_DATAK]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.knopka_enter[E_DATAK], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAK]),"clicked",GTK_SIGNAL_FUNC(buhrpzw_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAK]),(gpointer)E_DATAK); tooltips_enter[E_DATAK]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_DATAK],data.knopka_enter[E_DATAK],gettext("Выбор даты конца отчёта"),NULL); data.entry[E_DATAK] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.entry[E_DATAK], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAK]), "activate",GTK_SIGNAL_FUNC(buhrpzw_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAK]),data.rk->datak.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAK]),(gpointer)E_DATAK); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Расчёт")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчёт"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(buhrpzw_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введённой информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(buhrpzw_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F5 %s",gettext("Настройка")); data.knopka[FK5]=gtk_button_new_with_label(strsql); tooltips[FK5]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Настройка расчёта"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]),"clicked",GTK_SIGNAL_FUNC(buhrpzw_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK5], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Поиск не выполнять"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(buhrpzw_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
void filter_expression_save_dlg(gpointer data) { GtkWidget *main_vb, *main_filter_save_hb, *filter_save_frame, *filter_save_type_vb, *filter_save_type_hb, *entry_hb, *bbox, *ok_bt, *cancel_bt, *help_bt, *filter_text_box, *label_text_box; const char *expr; /* The filter requested */ expr = gtk_entry_get_text(GTK_ENTRY(data)); if (filter_save_frame_w != NULL) { /* There's already a "Filter Save" dialog box; reactivate it. */ reactivate_window(filter_save_frame_w); return; } filter_save_frame_w = dlg_window_new("Wireshark: Save Filter"); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(filter_save_frame_w), main_vb); gtk_widget_show(main_vb); /* */ main_filter_save_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), main_filter_save_hb); gtk_widget_show(main_filter_save_hb); /* Filter Save frame */ filter_save_frame = gtk_frame_new("Save Filter as..."); gtk_box_pack_start(GTK_BOX(main_filter_save_hb), filter_save_frame, TRUE, TRUE, 0); gtk_widget_show(filter_save_frame); filter_save_type_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(filter_save_type_vb), 3); gtk_container_add(GTK_CONTAINER(filter_save_frame), filter_save_type_vb); gtk_widget_show(filter_save_type_vb); /* filter_save type row */ filter_save_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(filter_save_type_vb), filter_save_type_hb); gtk_widget_show(filter_save_type_hb); /* filter_save row */ entry_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(filter_save_type_vb), entry_hb, FALSE, FALSE, 0); gtk_widget_show(entry_hb); filter_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(entry_hb), filter_text_box, TRUE, TRUE, 0); g_signal_connect(filter_text_box, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL); g_signal_connect(filter_text_box, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL); g_signal_connect(filter_save_frame_w, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL); gtk_entry_set_text(GTK_ENTRY(filter_text_box), expr); gtk_widget_show(filter_text_box); label_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(entry_hb), label_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(label_text_box), "Filter"); gtk_widget_show(label_text_box); /* Button row */ bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); g_signal_connect(ok_bt, "clicked", G_CALLBACK(filter_save_ok_cb), filter_save_frame_w); cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); g_signal_connect(cancel_bt, "clicked", G_CALLBACK(filter_save_close_cb), filter_save_frame_w); help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_FILTER_SAVE_DIALOG); g_object_set_data(G_OBJECT(filter_save_frame_w), E_FILTER_SAVE_EXPR_KEY, filter_text_box); g_object_set_data(G_OBJECT(filter_save_frame_w), E_FILTER_SAVE_LABEL_KEY, label_text_box); dlg_set_activate(label_text_box, ok_bt); /* Give the initial focus to the "offset" entry box. */ gtk_widget_grab_focus(label_text_box); g_signal_connect(filter_save_frame_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); g_signal_connect(filter_save_frame_w, "destroy", G_CALLBACK(filter_save_frame_destroy_cb), NULL); gtk_widget_show(filter_save_frame_w); window_present(filter_save_frame_w); }
int podzapusl(short dd,short md,short gd, //Дата документа int tipz, //1-приход 2-расход int podr, //Склад const char *nomdok, //Номер документа int kodzap, int metka_zap, int nom_zap, GtkWidget *wpredok) { class podzapusl_data data; char strsql[512]; SQL_str row; SQLCURSOR cur; data.dd=dd; data.md=md; data.gd=gd; data.tipz=tipz; data.podr=podr; data.nomdok.plus(nomdok); data.kodzap=kodzap; data.metka_zap=metka_zap; data.nom_zap=nom_zap; //Читаем нужные реквизиты sprintf(strsql,"select kolih,cena,ei,shetu from Usldokum1 where \ datd='%04d-%02d-%02d' and podr=%d and tp=%d and nomd='%s' and \ metka=%d and kodzap=%d and nz=%d", gd,md,dd,podr,tipz,nomdok,metka_zap,kodzap,nom_zap); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1) { iceb_menu_soob(gettext("Не найдена запись !"),wpredok); return(1); } data.kolih_dok=atof(row[0]); data.cena=atof(row[1]); data.ei.new_plus(row[2]); data.shetu.new_plus(row[3]); data.kolih_pod=readkoluw(dd,md,gd,podr,nomdok,tipz,metka_zap,kodzap,nom_zap,wpredok); if(fabs(data.kolih_dok- data.kolih_pod) < 0.00001) { iceb_menu_soob(gettext("Запись уже подтверждена !"),wpredok); return(1); } data.kolih.plus(data.kolih_dok-data.kolih_pod); if(data.kolih_pod == 0.) { sprintf(strsql,"%d.%d.%d",dd,md,gd); data.datap.plus(strsql); } else data.datap.plus(""); data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Подтверждение записи")); gtk_window_set_title (GTK_WINDOW (data.window),strsql); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(podzapusl_v_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *label=gtk_label_new(gettext("Подтверждение записи")); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxradio = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxradio); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); sprintf(strsql,"%s",gettext("Дата подтверждения")); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_DATAP] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_DATAP]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_DATAP]), data.entry[E_DATAP], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAP]), "activate",GTK_SIGNAL_FUNC(podzapusl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAP]),data.datap.ravno()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAP]),(gpointer)E_DATAP); label=gtk_label_new(gettext("Количество")); data.entry[E_KOLIH] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_KOLIH]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_KOLIH]), data.entry[E_KOLIH], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOLIH]), "activate",GTK_SIGNAL_FUNC(podzapusl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOLIH]),data.kolih.ravno()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOLIH]),(gpointer)E_KOLIH); GtkTooltips *tooltips[KOL_F_KL]; sprintf(strsql,"F2 %s",gettext("Запись")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введенной в меню информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(podzapusl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(podzapusl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(podzapusl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
static GtkWidget* gconf_dialog_create_proxy_widget (GConfDialog* self, const char* key, GError** error) { GtkWidget* result = NULL; GError * _inner_error_; GConfEntry* entry; GConfSchema* schema; const char* tooltip; GtkBox* row; GtkLabel* label; GtkWidget* action_widget; GtkWidget* render_widget; GConfEntry* _tmp10_; GtkButton* reset; GConfEntry* _tmp11_; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (key != NULL, NULL); _inner_error_ = NULL; entry = gconf_client_get_entry (self->priv->_default_client, key, NULL, TRUE, &_inner_error_); if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); return NULL; } schema = gconf_dialog_safely_get_schema (self, entry); tooltip = gconf_schema_get_long_desc (schema); row = (GtkBox*) g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0)); label = g_object_ref_sink ((GtkLabel*) gtk_label_new (gconf_schema_get_short_desc (schema))); gtk_label_set_justify (label, GTK_JUSTIFY_LEFT); gtk_widget_set_tooltip_text ((GtkWidget*) label, tooltip); action_widget = NULL; render_widget = NULL; switch (gconf_schema_get_type (schema)) { case GCONF_VALUE_BOOL: { GtkCheckButton* checkbox; gboolean _tmp0_; GtkWidget* _tmp1_; GtkWidget* _tmp2_; checkbox = g_object_ref_sink ((GtkCheckButton*) gtk_check_button_new ()); _tmp0_ = gconf_client_get_bool (self->priv->_default_client, entry->key, &_inner_error_); if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); _g_object_unref0 (checkbox); _g_object_unref0 (render_widget); _g_object_unref0 (action_widget); _g_object_unref0 (label); _g_object_unref0 (row); _gconf_schema_free0 (schema); _gconf_entry_unref0 (entry); return NULL; } gtk_toggle_button_set_active ((GtkToggleButton*) checkbox, _tmp0_); g_signal_connect_object ((GtkButton*) checkbox, "clicked", (GCallback) _gconf_dialog_onCheckButtonActivated_gtk_button_clicked, self, 0); gtk_container_add ((GtkContainer*) checkbox, (GtkWidget*) label); render_widget = (_tmp1_ = _g_object_ref0 ((GtkWidget*) checkbox), _g_object_unref0 (render_widget), _tmp1_); action_widget = (_tmp2_ = _g_object_ref0 (render_widget), _g_object_unref0 (action_widget), _tmp2_); _g_object_unref0 (checkbox); break; } case GCONF_VALUE_STRING: { GtkEntry* entrybox; GtkHBox* box; char* _tmp3_; char* _tmp4_; GtkWidget* _tmp5_; GtkWidget* _tmp6_; entrybox = g_object_ref_sink ((GtkEntry*) gtk_entry_new ()); box = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0)); _tmp3_ = gconf_client_get_string (self->priv->_default_client, entry->key, &_inner_error_); if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); _g_object_unref0 (box); _g_object_unref0 (entrybox); _g_object_unref0 (render_widget); _g_object_unref0 (action_widget); _g_object_unref0 (label); _g_object_unref0 (row); _gconf_schema_free0 (schema); _gconf_entry_unref0 (entry); return NULL; } gtk_entry_set_text (entrybox, _tmp4_ = _tmp3_); _g_free0 (_tmp4_); gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) label, FALSE, FALSE, (guint) 2); gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) entrybox, FALSE, FALSE, (guint) 2); action_widget = (_tmp5_ = _g_object_ref0 ((GtkWidget*) entrybox), _g_object_unref0 (action_widget), _tmp5_); render_widget = (_tmp6_ = _g_object_ref0 ((GtkWidget*) box), _g_object_unref0 (render_widget), _tmp6_); _g_object_unref0 (box); _g_object_unref0 (entrybox); break; } case GCONF_VALUE_INT: { GtkHBox* box; GtkSpinButton* spin; gint _tmp7_; GtkWidget* _tmp8_; GtkWidget* _tmp9_; box = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0)); spin = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) (-100), (double) 200, (double) 1)); _tmp7_ = gconf_client_get_int (self->priv->_default_client, entry->key, &_inner_error_); if (_inner_error_ != NULL) { g_propagate_error (error, _inner_error_); _g_object_unref0 (spin); _g_object_unref0 (box); _g_object_unref0 (render_widget); _g_object_unref0 (action_widget); _g_object_unref0 (label); _g_object_unref0 (row); _gconf_schema_free0 (schema); _gconf_entry_unref0 (entry); return NULL; } gtk_spin_button_set_value (spin, (double) _tmp7_); g_signal_connect_object (spin, "value-changed", (GCallback) _gconf_dialog_onSpinButtonValueChanged_gtk_spin_button_value_changed, self, 0); gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) label, FALSE, FALSE, (guint) 2); gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) spin, FALSE, FALSE, (guint) 2); action_widget = (_tmp8_ = _g_object_ref0 ((GtkWidget*) spin), _g_object_unref0 (action_widget), _tmp8_); render_widget = (_tmp9_ = _g_object_ref0 ((GtkWidget*) box), _g_object_unref0 (render_widget), _tmp9_); _g_object_unref0 (spin); _g_object_unref0 (box); break; } default: { result = (GtkWidget*) g_object_ref_sink ((GtkEventBox*) gtk_event_box_new ()); _g_object_unref0 (render_widget); _g_object_unref0 (action_widget); _g_object_unref0 (label); _g_object_unref0 (row); _gconf_schema_free0 (schema); _gconf_entry_unref0 (entry); return result; } } gtk_widget_set_tooltip_text (action_widget, tooltip); g_object_set_data_full ((GObject*) action_widget, "gconf-entry", (_tmp10_ = entry, (_tmp10_ == NULL) ? NULL : gconf_entry_ref (_tmp10_), _tmp10_), gconf_entry_unref); g_object_set_data_full ((GObject*) action_widget, "gconf-schema", gconf_schema_copy (schema), gconf_schema_free); reset = g_object_ref_sink ((GtkButton*) gtk_button_new_from_stock (GTK_STOCK_CLEAR)); gtk_widget_set_tooltip_text ((GtkWidget*) reset, _ ("Reset to the default value")); g_object_set_data_full ((GObject*) reset, "gconf-entry", (_tmp11_ = entry, (_tmp11_ == NULL) ? NULL : gconf_entry_ref (_tmp11_), _tmp11_), gconf_entry_unref); g_object_set_data_full ((GObject*) reset, "gconf-schema", gconf_schema_copy (schema), gconf_schema_free); g_object_set_data_full ((GObject*) reset, "target", _g_object_ref0 (action_widget), g_object_unref); g_signal_connect_object (reset, "clicked", (GCallback) _gconf_dialog_onResetButtonPressed_gtk_button_clicked, self, 0); gtk_box_pack_start (row, render_widget, FALSE, FALSE, (guint) 2); gtk_box_pack_end (row, (GtkWidget*) reset, FALSE, FALSE, (guint) 2); result = (GtkWidget*) row; _g_object_unref0 (reset); _g_object_unref0 (render_widget); _g_object_unref0 (action_widget); _g_object_unref0 (label); _gconf_schema_free0 (schema); _gconf_entry_unref0 (entry); return result; }
static void search_entry_clear_cb (GtkEntry *entry, gpointer user_data) { gtk_entry_set_text (entry, ""); }
/* Create an entry used to edit the given config key */ static GtkWidget* create_config_entry (GtkWidget *prefs_dialog, GConfClient *client, const gchar *config_key, gboolean focus) { GtkWidget *hbox; GtkWidget *entry; GtkWidget *label; char *str; hbox = gtk_hbox_new (FALSE, 5); label = gtk_label_new (config_key); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (hbox), entry, FALSE, FALSE, 0); /* this will print an error via default error handler * if the key isn't set to a string */ str = gconf_client_get_string (client, config_key, NULL); if (str) { gtk_entry_set_text (GTK_ENTRY (entry), str); g_free (str); } g_object_set_data (G_OBJECT (entry), "client", client); g_object_set_data_full (G_OBJECT (entry), "key", g_strdup (config_key), (GDestroyNotify) g_free); /* Commit changes if the user focuses out, or hits enter; we don't * do this on "changed" since it'd probably be a bit too slow to * round-trip to the server on every "changed" signal. */ g_signal_connect (G_OBJECT (entry), "focus_out_event", G_CALLBACK (config_entry_commit), NULL); g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (config_entry_commit), NULL); /* Set the entry insensitive if the key it edits isn't writable. * Technically, we should update this sensitivity if the key gets * a change notify, but that's probably overkill. */ gtk_widget_set_sensitive (entry, gconf_client_key_is_writable (client, config_key, NULL)); if (focus) gtk_widget_grab_focus (entry); return hbox; }
GtkWidget *plugin_configure(GtkDialog *dialog) { GtkWidget *vbox, *check_openuri, *check_tasks, *check_systray; GtkWidget *check_doclist, *vbox_doclist, *frame_doclist; GtkWidget *radio_doclist_name, *radio_doclist_occurrence; GtkWidget *check_bookmarklist, *check_markword, *frame_tasks, *vbox_tasks; GtkWidget *check_tasks_scan_mode, *entry_tasks_tokens, *label_tasks_tokens, *tokens_hbox; GtkWidget *check_blanklines, *check_xmltagging; vbox = gtk_vbox_new(FALSE, 6); check_doclist = gtk_check_button_new_with_label( _("Show toolbar item to show a list of currently open documents")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_doclist), ao_info->enable_doclist); g_signal_connect(check_doclist, "toggled", G_CALLBACK(ao_configure_doclist_toggled_cb), dialog); radio_doclist_name = gtk_radio_button_new_with_mnemonic(NULL, _("Sort documents by _name")); ui_widget_set_tooltip_text(radio_doclist_name, _("Sort the documents in the list by their filename")); radio_doclist_occurrence = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON(radio_doclist_name), _("Sort documents by _occurrence")); ui_widget_set_tooltip_text(radio_doclist_name, _("Sort the documents in the order of the document tabs")); if (ao_info->doclist_sort_mode == DOCLIST_SORT_BY_NAME) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_name), TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_occurrence), TRUE); vbox_doclist = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_name, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_occurrence, TRUE, TRUE, 3); frame_doclist = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_doclist), check_doclist); gtk_container_add(GTK_CONTAINER(frame_doclist), vbox_doclist); gtk_box_pack_start(GTK_BOX(vbox), frame_doclist, FALSE, FALSE, 3); check_openuri = gtk_check_button_new_with_label( /* TODO fix the string */ _("Show a 'Open URI' menu item in the editor menu")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_openuri), ao_info->enable_openuri); gtk_box_pack_start(GTK_BOX(vbox), check_openuri, FALSE, FALSE, 3); check_tasks = gtk_check_button_new_with_label( _("Show available Tasks in the Messages Window")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks), ao_info->enable_tasks); g_signal_connect(check_tasks, "toggled", G_CALLBACK(ao_configure_tasks_toggled_cb), dialog); check_tasks_scan_mode = gtk_check_button_new_with_label( _("Show tasks of all documents")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks_scan_mode), ao_info->tasks_scan_all_documents); ui_widget_set_tooltip_text(check_tasks_scan_mode, _("Whether to show the tasks of all open documents in the list or only those of the current document.")); entry_tasks_tokens = gtk_entry_new(); if (NZV(ao_info->tasks_token_list)) gtk_entry_set_text(GTK_ENTRY(entry_tasks_tokens), ao_info->tasks_token_list); ui_entry_add_clear_icon(GTK_ENTRY(entry_tasks_tokens)); ui_widget_set_tooltip_text(entry_tasks_tokens, _("Specify a semicolon separated list of search tokens.")); label_tasks_tokens = gtk_label_new_with_mnemonic(_("Search tokens:")); gtk_label_set_mnemonic_widget(GTK_LABEL(label_tasks_tokens), entry_tasks_tokens); tokens_hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(tokens_hbox), label_tasks_tokens, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(tokens_hbox), entry_tasks_tokens, TRUE, TRUE, 3); vbox_tasks = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_tasks), check_tasks_scan_mode, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_tasks), tokens_hbox, TRUE, TRUE, 3); frame_tasks = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_tasks), check_tasks); gtk_container_add(GTK_CONTAINER(frame_tasks), vbox_tasks); gtk_box_pack_start(GTK_BOX(vbox), frame_tasks, FALSE, FALSE, 3); check_systray = gtk_check_button_new_with_label( _("Show status icon in the Notification Area")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_systray), ao_info->enable_systray); gtk_box_pack_start(GTK_BOX(vbox), check_systray, FALSE, FALSE, 3); check_bookmarklist = gtk_check_button_new_with_label( _("Show defined bookmarks (marked lines) in the sidebar")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_bookmarklist), ao_info->enable_bookmarklist); gtk_box_pack_start(GTK_BOX(vbox), check_bookmarklist, FALSE, FALSE, 3); check_markword = gtk_check_button_new_with_label( _("Mark all occurrences of a word when double-clicking it")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_markword), ao_info->enable_markword); gtk_box_pack_start(GTK_BOX(vbox), check_markword, FALSE, FALSE, 3); check_blanklines = gtk_check_button_new_with_label( _("Strip trailing blank lines")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_blanklines), ao_info->strip_trailing_blank_lines); gtk_box_pack_start(GTK_BOX(vbox), check_blanklines, FALSE, FALSE, 3); check_xmltagging = gtk_check_button_new_with_label( _("XML tagging for selection")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_xmltagging), ao_info->enable_xmltagging); gtk_box_pack_start(GTK_BOX(vbox), check_xmltagging, FALSE, FALSE, 3); g_object_set_data(G_OBJECT(dialog), "check_doclist", check_doclist); g_object_set_data(G_OBJECT(dialog), "radio_doclist_name", radio_doclist_name); g_object_set_data(G_OBJECT(dialog), "radio_doclist_occurrence", radio_doclist_occurrence); g_object_set_data(G_OBJECT(dialog), "check_openuri", check_openuri); g_object_set_data(G_OBJECT(dialog), "check_tasks", check_tasks); g_object_set_data(G_OBJECT(dialog), "entry_tasks_tokens", entry_tasks_tokens); g_object_set_data(G_OBJECT(dialog), "check_tasks_scan_mode", check_tasks_scan_mode); g_object_set_data(G_OBJECT(dialog), "check_systray", check_systray); g_object_set_data(G_OBJECT(dialog), "check_bookmarklist", check_bookmarklist); g_object_set_data(G_OBJECT(dialog), "check_markword", check_markword); g_object_set_data(G_OBJECT(dialog), "check_blanklines", check_blanklines); g_object_set_data(G_OBJECT(dialog), "check_xmltagging", check_xmltagging); g_signal_connect(dialog, "response", G_CALLBACK(ao_configure_response_cb), NULL); ao_configure_tasks_toggled_cb(GTK_TOGGLE_BUTTON(check_tasks), dialog); ao_configure_doclist_toggled_cb(GTK_TOGGLE_BUTTON(check_doclist), dialog); gtk_widget_show_all(vbox); #if ! GTK_CHECK_VERSION(2, 10, 0) gtk_widget_hide(check_systray); #endif return vbox; }
static void gpk_log_startup_cb (GtkApplication *application, gpointer user_data) { g_autoptr(GError) error = NULL; GtkTreeSelection *selection; GtkWidget *widget; GtkWindow *window; guint retval; client = pk_client_new (); g_object_set (client, "background", FALSE, NULL); /* get UI */ builder = gtk_builder_new (); retval = gtk_builder_add_from_resource (builder, "/org/gnome/packagekit/gpk-log.ui", &error); if (retval == 0) { g_warning ("failed to load ui: %s", error->message); goto out; } window = GTK_WINDOW (gtk_builder_get_object (builder, "dialog_simple")); gtk_window_set_icon_name (window, GPK_ICON_SOFTWARE_LOG); gtk_window_set_application (window, application); /* set a size, as the screen allows */ gpk_window_set_size_request (window, 1200, 1200); /* if command line arguments are set, then setup UI */ if (filter != NULL) { widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); gtk_entry_set_text (GTK_ENTRY(widget), filter); } widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL); /* hit enter in the search box for filter */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL); /* autocompletion can be turned off as it's slow */ g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL); /* create list stores */ list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, 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_BOOLEAN); /* create transaction_id tree view */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple")); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (list_store)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); g_signal_connect (selection, "changed", G_CALLBACK (gpk_log_treeview_clicked_cb), NULL); /* add columns to the tree view */ pk_treeview_add_general_columns (GTK_TREE_VIEW (widget)); gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING); /* show */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple")); gtk_widget_show (widget); /* set the parent window if it is specified */ if (xid != 0) { g_debug ("Setting xid %i", xid); gpk_window_set_parent_xid (GTK_WINDOW (widget), xid); } /* get the update list */ gpk_log_refresh (); out: g_object_unref (list_store); g_object_unref (client); g_free (transaction_id); g_free (filter); if (transactions != NULL) g_ptr_array_unref (transactions); }
int iceb_l_subbal_v(class iceb_u_str *kod_gr,GtkWidget *wpredok) { class iceb_l_subbal_v_data data; char strsql[512]; iceb_u_str kikz; data.kod_gr.new_plus(kod_gr->ravno()); data.rk.clear_data(); if(data.kod_gr.getdlinna() > 1) { data.rk.kod.new_plus(data.kod_gr.ravno()); sprintf(strsql,"select * from Glksubbal where kod='%s'",data.kod_gr.ravno()); SQL_str row; SQLCURSOR cur; if(iceb_sql_readkey(strsql,&row,&cur,wpredok) < 1) { iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok); return(1); } data.rk.naim.new_plus(row[1]); kikz.plus(iceb_kikz(row[2],row[3],wpredok)); } else { sprintf(strsql,"%d",iceb_get_new_kod("Glksubbal",0,wpredok)); data.rk.kod.new_plus(strsql); } data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); GtkWidget *label=NULL; if(data.kod_gr.getdlinna() <= 1) { sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи")); label=gtk_label_new(gettext("Ввод новой записи")); } else { sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи")); iceb_u_str repl; repl.plus(gettext("Корректировка записи")); repl.ps_plus(kikz.ravno()); label=gtk_label_new(repl.ravno_toutf()); } gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(iceb_l_subbal_v_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); label=gtk_label_new(gettext("Код")); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0); data.entry[E_KOD] = gtk_entry_new_with_max_length (4); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(iceb_l_subbal_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); label=gtk_label_new(gettext("Наименование")); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0); data.entry[E_NAIM] = gtk_entry_new_with_max_length (100); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(iceb_l_subbal_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Запись")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введеной в меню информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(iceb_l_subbal_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы с меню без записи введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(iceb_l_subbal_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(data.voz == 0) kod_gr->new_plus(data.rk.kod.ravno()); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
void InsetDataInputSetValue (InsetData *inset, char *value) { gtk_entry_set_text (GTK_ENTRY (inset), value); }
static void run_add_edit_dialog (LogviewFilterManager *manager, LogviewFilter *filter) { int response; GError *error; gchar *name, *regex; const gchar *title; GtkWidget *dialog, *entry_name, *entry_regex, *radio_color; GtkWidget *radio_visible, *check_foreground, *check_background; GtkWidget *color_foreground, *color_background, *vbox_color; gboolean foreground_set, background_set, invisible; GtkTextTag *tag; GtkBuilder* builder; builder = manager->priv->builder; error = NULL; name = NULL; gtk_builder_add_from_file (builder, UI_FILE, &error); if (error) { g_warning ("Could not load filter ui: %s", error->message); g_error_free (error); return; } title = (filter != NULL ? _("Edit filter") : _("Add new filter")); dialog = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_filter")); entry_name = GTK_WIDGET (gtk_builder_get_object (builder, "entry_name")); entry_regex = GTK_WIDGET (gtk_builder_get_object (builder, "entry_regex")); radio_color = GTK_WIDGET (gtk_builder_get_object (builder, "radio_color")); radio_visible = GTK_WIDGET (gtk_builder_get_object (builder, "radio_visible")); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_color), gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_visible))); check_foreground = GTK_WIDGET (gtk_builder_get_object (builder, "check_foreground")); check_background = GTK_WIDGET (gtk_builder_get_object (builder, "check_background")); color_foreground = GTK_WIDGET (gtk_builder_get_object (builder, "color_foreground")); color_background = GTK_WIDGET (gtk_builder_get_object (builder, "color_background")); g_signal_connect (check_foreground, "toggled", G_CALLBACK (on_check_toggled), color_foreground); g_signal_connect (check_background, "toggled", G_CALLBACK (on_check_toggled), color_background); on_check_toggled (GTK_TOGGLE_BUTTON (check_foreground), color_foreground); on_check_toggled (GTK_TOGGLE_BUTTON (check_background), color_background); vbox_color = GTK_WIDGET (gtk_builder_get_object (builder, "vbox_color")); g_signal_connect (radio_color, "toggled", G_CALLBACK (on_check_toggled), vbox_color); on_check_toggled (GTK_TOGGLE_BUTTON (radio_color), vbox_color); if (filter) { g_object_get (filter, "name", &name, "regex", ®ex, "texttag", &tag, NULL); g_object_get (tag, "foreground-set", &foreground_set, "paragraph-background-set", &background_set, "invisible", &invisible, NULL); gtk_entry_set_text (GTK_ENTRY(entry_name), name); gtk_entry_set_text (GTK_ENTRY(entry_regex), regex); if (foreground_set) { GdkColor *foreground; g_object_get (tag, "foreground-gdk", &foreground, NULL); gtk_color_button_set_color (GTK_COLOR_BUTTON (color_foreground), foreground); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_foreground), TRUE); gdk_color_free (foreground); } if (background_set) { GdkColor *background; g_object_get (tag, "paragraph-background-gdk", &background, NULL); gtk_color_button_set_color (GTK_COLOR_BUTTON (color_background), background); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_background), TRUE); gdk_color_free (background); } if (background_set || foreground_set) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_color), TRUE); } else if (invisible) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_visible), TRUE); } g_free (regex); g_object_unref (tag); } g_object_set_data_full (G_OBJECT (manager), "old_name", name, g_free); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (on_dialog_add_edit_reponse), manager); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (manager)); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_widget_show (GTK_WIDGET (dialog)); }
static gint save_dialog (gint32 image_ID) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *spinbutton; GtkObject *adj; GtkWidget *entry; GtkWidget *toggle; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_export_dialog_new (_("HTML table"), PLUG_IN_BINARY, SAVE_PROC); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)), main_vbox, TRUE, TRUE, 0); if (gimp_image_width (image_ID) * gimp_image_height (image_ID) > 4096) { GtkWidget *eek; GtkWidget *label; GtkWidget *hbox; frame = gimp_frame_new (_("Warning")); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_add (GTK_CONTAINER (frame), hbox); eek = gtk_image_new_from_stock (GIMP_STOCK_WILBER_EEK, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), eek, FALSE, FALSE, 0); label = gtk_label_new (_("You are about to create a huge\n" "HTML file which will most likely\n" "crash your browser.")); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show_all (frame); } /* HTML Page Options */ frame = gimp_frame_new (_("HTML Page Options")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); toggle = gtk_check_button_new_with_mnemonic (_("_Generate full HTML document")); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.fulldoc); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If checked GTM will output a full HTML document " "with <HTML>, <BODY>, etc. tags instead of just " "the table html."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.fulldoc); gtk_widget_show (main_vbox); gtk_widget_show (frame); /* HTML Table Creation Options */ frame = gimp_frame_new (_("Table Creation Options")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (4, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); toggle = gtk_check_button_new_with_mnemonic (_("_Use cellspan")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 0, 1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.spantags); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If checked GTM will replace any rectangular " "sections of identically colored blocks with one " "large cell with ROWSPAN and COLSPAN values."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.spantags); toggle = gtk_check_button_new_with_mnemonic (_("Co_mpress TD tags")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 1, 2, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.tdcomp); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Checking this tag will cause GTM to leave no " "whitespace between the TD tags and the " "cellcontent. This is only necessary for pixel " "level positioning control."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.tdcomp); toggle = gtk_check_button_new_with_mnemonic (_("C_aption")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 2, 3, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.caption); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Check if you would like to have the table " "captioned."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.caption); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.captiontxt); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, 0, 0, 0); gtk_widget_show (entry); gimp_help_set_help_data (entry, _("The text for the table caption."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_caption_callback), NULL); g_object_bind_property (toggle, "active", entry, "sensitive", G_BINDING_SYNC_CREATE); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.cellcontent); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("C_ell content:"), 0.0, 0.5, entry, 1, FALSE); gtk_widget_show (entry); gimp_help_set_help_data (entry, _("The text to go into each cell."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_cellcontent_callback), NULL); gtk_widget_show (table); gtk_widget_show (frame); /* HTML Table Options */ frame = gimp_frame_new (_("Table Options")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (5, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); spinbutton = gimp_spin_button_new (&adj, gtmvals.border, 0, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Border:"), 0.0, 0.5, spinbutton, 1, TRUE); gimp_help_set_help_data (spinbutton, _("The number of pixels in the table border."), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), >mvals.border); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 60, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.clwidth); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("_Width:"), 0.0, 0.5, entry, 1, TRUE); gimp_help_set_help_data (entry, _("The width for each table cell. " "Can be a number or a percent."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_clwidth_callback), NULL); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 60, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.clheight); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("_Height:"), 0.0, 0.5, entry, 1, TRUE); gimp_help_set_help_data (entry, _("The height for each table cell. " "Can be a number or a percent."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_clheight_callback), NULL); spinbutton = gimp_spin_button_new (&adj, gtmvals.cellpadding, 0, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Cell-_padding:"), 0.0, 0.5, spinbutton, 1, TRUE); gimp_help_set_help_data (spinbutton, _("The amount of cell padding."), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), >mvals.cellpadding); spinbutton = gimp_spin_button_new (&adj, gtmvals.cellspacing, 0, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, _("Cell-_spacing:"), 0.0, 0.5, spinbutton, 1, TRUE); gimp_help_set_help_data (spinbutton, _("The amount of cell spacing."), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), >mvals.cellspacing); gtk_widget_show (table); gtk_widget_show (frame); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
void vnkb_show_preferences (Vnkb *vnkb) { GladeXML *xml; GtkWidget *dlg,*button,*w; GtkTreeViewColumn *col; GtkWidget *treeview; GtkListStore *store; GtkTreeIter iter; GtkCellRenderer *cell; GdkPixbuf *icon; xml = glade_xml_new (VNKB_GLADEDIR "/vnkb-preferences.glade", NULL, GETTEXT_PACKAGE); dlg = glade_xml_get_widget(xml,"vnkb_preferences_dialog"); vnkb->widget_text_enabled = w = glade_xml_get_widget(xml,"entry_enabled"); g_signal_connect(G_OBJECT(w),"changed", G_CALLBACK(entry_enabled_changed_cb), vnkb); if (vnkb->text_enabled) gtk_entry_set_text(GTK_ENTRY(w),vnkb->text_enabled); vnkb->widget_text_disabled = w = glade_xml_get_widget(xml,"entry_disabled"); g_signal_connect(G_OBJECT(w),"changed", G_CALLBACK(entry_disabled_changed_cb), vnkb); if (vnkb->text_disabled) gtk_entry_set_text(GTK_ENTRY(w),vnkb->text_disabled); //gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_RESPONSE_OK); treeview = glade_xml_get_widget(xml,"treeview_shortcut"); vnkb->store = store = gtk_list_store_new(2,G_TYPE_STRING,G_TYPE_POINTER); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview),GTK_TREE_MODEL(store)); col = gtk_tree_view_column_new_with_attributes(_("Function"), gtk_cell_renderer_text_new(), "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview),col); cell = (GtkCellRenderer *) g_object_new (EGG_TYPE_CELL_RENDERER_KEYS, "editable", TRUE, NULL); g_signal_connect(G_OBJECT(cell),"accel_edited", G_CALLBACK(shortcut_edited_cb), vnkb); col = gtk_tree_view_column_new_with_attributes(_("Shortcut"),cell,NULL); gtk_tree_view_column_set_cell_data_func (col, cell, accel_set_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview),col); gtk_list_store_append(store,&iter); gtk_list_store_set(store,&iter, 0,_("Enable Xvnkb"), 1,g_new0(KeyEntry,1), -1); switch (vnkb->label_mode) { case VNKB_LABEL_DEFAULT: w = glade_xml_get_widget (xml, "radio_use_default"); break; case VNKB_LABEL_CUSTOM: w = glade_xml_get_widget (xml, "radio_custom_text"); break; case VNKB_LABEL_IM: w = glade_xml_get_widget (xml, "radio_show_im"); break; } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w),TRUE); w = glade_xml_get_widget (xml, "radio_use_default"); g_signal_connect(G_OBJECT(w),"clicked", G_CALLBACK(radio_use_default_clicked_cb), vnkb); w = glade_xml_get_widget (xml, "radio_custom_text"); g_signal_connect(G_OBJECT(w),"clicked", G_CALLBACK(radio_custom_text_clicked_cb), vnkb); w = glade_xml_get_widget (xml, "radio_show_im"); g_signal_connect(G_OBJECT(w),"clicked", G_CALLBACK(radio_show_im_clicked_cb), vnkb); button = glade_xml_get_widget (xml, "colorbutton_enabled"); gtk_color_button_set_color(GTK_COLOR_BUTTON(button), &vnkb->color_enabled); g_signal_connect (button, "color-set", G_CALLBACK(colorbutton_enabled_set_cb), vnkb); button = glade_xml_get_widget (xml, "colorbutton_disabled"); gtk_color_button_set_color(GTK_COLOR_BUTTON(button), &vnkb->color_disabled); g_signal_connect (button, "color-set", G_CALLBACK(colorbutton_disabled_set_cb), vnkb); button = glade_xml_get_widget (xml, "fontbutton_enabled"); if (vnkb->font_enabled) gtk_font_button_set_font_name(GTK_FONT_BUTTON(button), vnkb->font_enabled); g_signal_connect (button, "font-set", G_CALLBACK(fontbutton_enabled_set_cb), vnkb); button = glade_xml_get_widget (xml, "button_disable_exit"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),vnkb->disable_on_exit); g_signal_connect (button, "toggled", G_CALLBACK(button_disable_exit_toggled_cb), vnkb); button = glade_xml_get_widget (xml, "fontbutton_disabled"); if (vnkb->font_disabled) gtk_font_button_set_font_name(GTK_FONT_BUTTON(button), vnkb->font_disabled); g_signal_connect (button, "font-set", G_CALLBACK(fontbutton_disabled_set_cb), vnkb); button = glade_xml_get_widget (xml, "button_close"); g_signal_connect_swapped (button, "clicked", (GCallback) gtk_widget_destroy, dlg); button = glade_xml_get_widget (xml, "radio_xvnkb"); g_signal_connect (button, "clicked", (GCallback) radio_xvnkb_clicked_cb, vnkb); button = glade_xml_get_widget (xml, "radio_unikey"); if (vnkb->driver == DRIVER_UNIKEY) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),TRUE); g_signal_connect (button, "clicked", (GCallback) radio_unikey_clicked_cb, vnkb); //gtk_window_set_screen (GTK_WINDOW (dlg), //gtk_widget_get_screen (GTK_WIDGET (fish))); button = glade_xml_get_widget(xml,"buton_unikey_macro_browse"); g_signal_connect(G_OBJECT(button),"clicked", (GCallback) button_unikey_macro_browse_clicked_cb, vnkb); icon = gtk_widget_render_icon (dlg, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, "vnkb_preferences_dialog"); gtk_window_set_icon (GTK_WINDOW (dlg), icon); //gtk_window_set_resizable (GTK_WINDOW (fish->preferences_dialog), FALSE); gtk_window_present (GTK_WINDOW (dlg)); g_object_unref (xml); }
static void _property_choice_callback(GtkMenuItem *item, gpointer user_data) { dt_lib_camera_t *lib = (dt_lib_camera_t *)user_data; gtk_entry_set_text(GTK_ENTRY(lib->gui.pname), gtk_menu_item_get_label(item)); }
static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data) { /* copied from interface.c */ GtkWidget *page; GtkWidget *frame33; GtkWidget *alignment36; GtkWidget *vbox30; GtkWidget *hbox10; GtkWidget *label203; PrintWidgets *w = user_data; gtk_print_operation_set_custom_tab_label(operation, _("Document Setup")); page = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(page), 5); w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers")); gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers); w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers")); gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers); w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header")); gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header); g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w); frame33 = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0); gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0); gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE); alignment36 = gtk_alignment_new(0, 0.5, 1, 1); gtk_container_add(GTK_CONTAINER(frame33), alignment36); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0); vbox30 = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(alignment36), vbox30); w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file")); gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename); hbox10 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0); label203 = gtk_label_new(_("Date format:")); gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0); w->entry_print_dateformat = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat)); gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function.")); gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt); on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w); gtk_widget_show_all(page); return page; }
GtkWidget *plugin_configure(GtkDialog *dialog) { GtkWidget *label_language, *label_dir, *vbox; GtkWidget *combo, *check_type, *check_on_open, *check_msgwin, *check_toolbar, *check_editor_menu; GtkWidget *vbox_interface, *frame_interface, *label_interface; GtkWidget *vbox_behavior, *frame_behavior, *label_behavior; #ifdef HAVE_ENCHANT_1_5 GtkWidget *entry_dir, *hbox, *button, *image; #endif vbox = gtk_vbox_new(FALSE, 6); check_toolbar = gtk_check_button_new_with_label( _("Show toolbar item to toggle spell checking")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_toolbar), sc_info->show_toolbar_item); check_editor_menu = gtk_check_button_new_with_label( _("Show editor menu item to show spelling suggestions")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_editor_menu), sc_info->show_editor_menu_item); check_msgwin = gtk_check_button_new_with_label( _("Print misspelled words and suggestions in the messages window")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_msgwin), sc_info->use_msgwin); vbox_interface = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_interface), check_toolbar, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_interface), check_editor_menu, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_interface), check_msgwin, TRUE, TRUE, 3); label_interface = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(label_interface), TRUE); gtk_label_set_markup(GTK_LABEL(label_interface), _("<b>Interface</b>")); frame_interface = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_interface), label_interface); gtk_container_add(GTK_CONTAINER(frame_interface), vbox_interface); gtk_box_pack_start(GTK_BOX(vbox), frame_interface, FALSE, FALSE, 3); check_type = gtk_check_button_new_with_label(_("Check spelling while typing")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_type), sc_info->check_while_typing); check_on_open = gtk_check_button_new_with_label(_("Check spelling when opening a document")); ui_widget_set_tooltip_text(check_on_open, _("Enabling this option will check every document after it is opened in Geany. " "Reloading a document will also trigger a re-check.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_on_open), sc_info->check_on_document_open); label_language = gtk_label_new(_("Language to use for the spell check:")); gtk_misc_set_alignment(GTK_MISC(label_language), 0, 0.5); combo = gtk_combo_box_text_new(); populate_dict_combo(GTK_COMBO_BOX(combo)); if (sc_info->dicts->len > 20) gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3); else if (sc_info->dicts->len > 10) gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 2); #ifdef HAVE_ENCHANT_1_5 label_dir = gtk_label_new_with_mnemonic(_("_Directory to look for dictionary files:")); gtk_misc_set_alignment(GTK_MISC(label_dir), 0, 0.5); entry_dir = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(entry_dir)); gtk_label_set_mnemonic_widget(GTK_LABEL(label_dir), entry_dir); ui_widget_set_tooltip_text(entry_dir, _("Read additional dictionary files from this directory. " "For now, this only works with myspell dictionaries.")); if (! EMPTY(sc_info->dictionary_dir)) gtk_entry_set_text(GTK_ENTRY(entry_dir), sc_info->dictionary_dir); button = gtk_button_new(); g_signal_connect(button, "clicked", G_CALLBACK(dictionary_dir_button_clicked_cb), entry_dir); image = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_container_add(GTK_CONTAINER(button), image); hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(hbox), entry_dir, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(dialog), "dict_dir", entry_dir); #endif vbox_behavior = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_behavior), check_type, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), check_on_open, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), label_language, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), combo, TRUE, TRUE, 3); #ifdef HAVE_ENCHANT_1_5 gtk_box_pack_start(GTK_BOX(vbox_behavior), label_dir, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), hbox, TRUE, TRUE, 3); #endif label_behavior = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(label_behavior), TRUE); gtk_label_set_markup(GTK_LABEL(label_behavior), _("<b>Behavior</b>")); frame_behavior = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_behavior), label_behavior); gtk_container_add(GTK_CONTAINER(frame_behavior), vbox_behavior); gtk_box_pack_start(GTK_BOX(vbox), frame_behavior, FALSE, FALSE, 3); g_object_set_data(G_OBJECT(dialog), "combo", combo); g_object_set_data(G_OBJECT(dialog), "check_type", check_type); g_object_set_data(G_OBJECT(dialog), "check_on_open", check_on_open); g_object_set_data(G_OBJECT(dialog), "check_msgwin", check_msgwin); g_object_set_data(G_OBJECT(dialog), "check_toolbar", check_toolbar); g_object_set_data(G_OBJECT(dialog), "check_editor_menu", check_editor_menu); g_signal_connect(dialog, "response", G_CALLBACK(configure_response_cb), NULL); gtk_widget_show_all(vbox); return vbox; }
static void op_configure(void) { GtkWidget *dev_vbox; GtkWidget *adevice_frame, *adevice_text, *adevice_vbox; GtkWidget *bbox, *ok, *cancel; if (configure_win) { gdk_window_raise(configure_win->window); return; } configure_win = gtk_window_new(GTK_WINDOW_DIALOG); gtk_signal_connect(GTK_OBJECT(configure_win), "destroy", GTK_SIGNAL_FUNC(configure_win_destroy), NULL); gtk_window_set_title(GTK_WINDOW(configure_win), _("sndio device")); gtk_window_set_policy(GTK_WINDOW(configure_win), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE); gtk_container_border_width(GTK_CONTAINER(configure_win), 10); dev_vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(configure_win), dev_vbox); gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5); adevice_frame = gtk_frame_new(_("Audio device:")); gtk_box_pack_start(GTK_BOX(dev_vbox), adevice_frame, FALSE, FALSE, 0); adevice_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(adevice_vbox), 5); gtk_container_add(GTK_CONTAINER(adevice_frame), adevice_vbox); adevice_text = gtk_label_new(_("(empty means default)")); gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_text); adevice_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(adevice_entry), audiodev); gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_entry); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(dev_vbox), bbox, FALSE, FALSE, 0); ok = gtk_button_new_with_label(_("OK")); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(configure_win_ok_cb), NULL); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_widget_grab_default(ok); cancel = gtk_button_new_with_label(_("Cancel")); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(configure_win_cancel_cb), GTK_OBJECT(configure_win)); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_widget_show_all(configure_win); }
/*! \brief gui_dispatcher() is a GTK+ timeout that runs 30 tiems per second checking for message on the dispatch queue which handles gui operations after a thread function runs, This will attempt to handle multiple messages at a time if the queue has multiple message queued up. \param data (gpointer) unused \returns TRUE */ gboolean gui_dispatcher(gpointer data) { gint len=0; gint i=0; UpdateFunction val = 0; gint count = 0; GtkWidget *widget = NULL; Io_Message *message = NULL; Text_Message *t_message = NULL; Widget_Update *w_update = NULL; QFunction *qfunc = NULL; extern volatile gboolean leaving; /*extern gint mem_view_style[];*/ if (!gui_dispatch_queue) /*queue not built yet... */ { g_cond_signal(gui_dispatch_cond); return TRUE; } /* Endless Loop, wait for message, processs and repeat... */ trypop: /*printf("gui_dispatch queue length is %i\n",g_async_queue_length(gui_dispatch_queue));*/ if (leaving) { g_cond_signal(gui_dispatch_cond); return TRUE; } message = g_async_queue_try_pop(gui_dispatch_queue); if (!message) { /* printf("no messages waiting, returning\n");*/ g_cond_signal(gui_dispatch_cond); return TRUE; } if (message->functions != NULL) { len = message->functions->len; for (i=0;i<len;i++) { if (leaving) { dealloc_message(message); g_cond_signal(gui_dispatch_cond); return TRUE; } val = g_array_index(message->functions,UpdateFunction, i); /*printf("gui_dispatcher\n");*/ switch ((UpdateFunction)val) { case UPD_LOGBAR: /*printf("logbar update\n");*/ t_message = (Text_Message *)message->payload; gdk_threads_enter(); update_logbar(t_message->view_name,t_message->tagname,t_message->msg,t_message->count,t_message->clear); gdk_threads_leave(); dealloc_textmessage(t_message); message->payload = NULL; break; case UPD_RUN_FUNCTION: /*printf("run function\n");*/ qfunc = (QFunction *)message->payload; gdk_threads_enter(); run_post_functions(qfunc->func_name); gdk_threads_leave(); dealloc_qfunction(qfunc); message->payload = NULL; break; case UPD_WIDGET: /*printf("widget update\n");*/ widget = NULL; w_update = (Widget_Update *)message->payload; switch (w_update->type) { case MTX_ENTRY: /*printf("entry\n");*/ if (NULL == (widget = lookup_widget(w_update->widget_name))) break; gdk_threads_enter(); gtk_entry_set_text(GTK_ENTRY(widget),w_update->msg); gdk_threads_leave(); break; case MTX_LABEL: /*printf("label\n");*/ if (NULL == (widget = lookup_widget(w_update->widget_name))) break; gdk_threads_enter(); gtk_label_set_text(GTK_LABEL(widget),w_update->msg); gdk_threads_leave(); break; case MTX_TITLE: /*printf("title\n");*/ gdk_threads_enter(); set_title(g_strdup(w_update->msg)); gdk_threads_leave(); break; case MTX_SENSITIVE: /*printf("sensitivity change\n");*/ if (NULL == (widget = lookup_widget(w_update->widget_name))) break; gdk_threads_enter(); gtk_widget_set_sensitive(GTK_WIDGET(widget),w_update->state); gdk_threads_leave(); break; default: break; } dealloc_w_update(w_update); message->payload = NULL; break; gdk_threads_enter(); reset_temps(OBJ_GET(global_data,"temp_units")); gdk_threads_leave(); /* case UPD_RAW_MEMORY: update_raw_memory_view(mem_view_style[message->offset],message->offset); break; */ } gdk_threads_enter(); while (gtk_events_pending()) { if (leaving) goto dealloc; gtk_main_iteration(); } gdk_threads_leave(); } } dealloc: dealloc_message(message); /*printf ("deallocation of dispatch message complete\n");*/ count++; /* try to handle up to 4 messages at a time. If this is * set too high, we can cause the timeout to hog the gui if it's * too low, things can fall behind. (GL redraw ;( ) * */ if ((count < 3) && (!leaving)) { /*printf("trying to handle another message\n");*/ goto trypop; } /*printf("returning\n");*/ g_cond_signal(gui_dispatch_cond); return TRUE; }
int imp_kr_m(class imp_kr_rek *rek_ras,GtkWidget *wpredok) { class imp_kr_m_data data; data.rk=rek_ras; char strsql[512]; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Импорт из подсистемы \"Учёт кассовых ордеров\"")); gtk_window_set_title (GTK_WINDOW (data.window),strsql); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(imp_kr_m_v_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } class iceb_u_str repl; repl.plus(gettext("Импорт из подсистемы \"Учёт кассовых ордеров\"")); //repl.ps_plus(data.rk->naim_oth.ravno()); GtkWidget *label=gtk_label_new(repl.ravno_toutf()); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); //GtkWidget *hboxradio = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); sprintf(strsql,"%s",gettext("Дата начала")); data.knopka_enter[E_DATAN]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.knopka_enter[E_DATAN], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAN]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAN]),(gpointer)E_DATAN); data.entry[E_DATAN] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.entry[E_DATAN], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAN]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAN]),data.rk->datan.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAN]),(gpointer)E_DATAN); sprintf(strsql,"%s",gettext("Дата конца")); data.knopka_enter[E_DATAK]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.knopka_enter[E_DATAK], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAK]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAK]),(gpointer)E_DATAK); data.entry[E_DATAK] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.entry[E_DATAK], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAK]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAK]),data.rk->datak.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAK]),(gpointer)E_DATAK); label=gtk_label_new(gettext("День записи")); gtk_box_pack_start (GTK_BOX (hbox[E_DENZ]), label, FALSE, FALSE, 0); data.entry[E_DENZ] = gtk_entry_new_with_max_length (2); gtk_box_pack_start (GTK_BOX (hbox[E_DENZ]), data.entry[E_DENZ], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DENZ]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DENZ]),data.rk->denz.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DENZ]),(gpointer)E_DENZ); sprintf(strsql,"%s",gettext("Код затрат")); data.knopka_enter[E_KOD_ZAT]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZAT]), data.knopka_enter[E_KOD_ZAT], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_ZAT]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_ZAT]),(gpointer)E_KOD_ZAT); data.entry[E_KOD_ZAT] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZAT]), data.entry[E_KOD_ZAT], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_ZAT]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_ZAT]),data.rk->kod_zat.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_ZAT]),(gpointer)E_KOD_ZAT); GtkTooltips *tooltips[KOL_F_KL]; sprintf(strsql,"F2 %s",gettext("Расчет")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчет"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
void clear_rek() { for(int i=0; i < KOLENTER; i++) gtk_entry_set_text(GTK_ENTRY(entry[i]),""); }
/** * Shows a dialog to edit the given connection (or create a new one, * if conn is NULL) */ static void edit_connection (gpointer *parent, StrongswanConnection *conn) { GtkWidget *dialog; dialog = gtk_dialog_new_with_buttons ( conn ? "Edit Connection" : "New Connection", GTK_WINDOW (parent), GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); GtkWidget *vbox = GTK_DIALOG (dialog)->vbox; GtkSizeGroup *group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); GtkWidget *name = hildon_entry_new (HILDON_SIZE_AUTO); hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (name), "Connection Name"); hildon_gtk_entry_set_input_mode (GTK_ENTRY (name), HILDON_GTK_INPUT_MODE_AUTOCAP | HILDON_GTK_INPUT_MODE_ALPHA | HILDON_GTK_INPUT_MODE_NUMERIC); GtkWidget *ncap = hildon_caption_new (group, "Name", name, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), ncap, TRUE, TRUE, 0); GtkWidget *host = hildon_entry_new (HILDON_SIZE_AUTO); hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (host), "Hostname / IP"); hildon_gtk_entry_set_input_mode (GTK_ENTRY (host), HILDON_GTK_INPUT_MODE_FULL); GtkWidget *hcap = hildon_caption_new (group, "Host", host, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), hcap, TRUE, TRUE, 0); GtkWidget *cert = hildon_button_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH, HILDON_BUTTON_ARRANGEMENT_VERTICAL); hildon_button_set_text (HILDON_BUTTON (cert), "Host or CA Certificate", "None"); hildon_button_set_alignment (HILDON_BUTTON (cert), 0, 0.5, 1, 1); g_signal_connect (cert, "clicked", G_CALLBACK (select_cert), dialog); GtkWidget *ccap = hildon_caption_new (group, "Certificate", cert, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), ccap, TRUE, TRUE, 0); GtkWidget *user = hildon_entry_new (HILDON_SIZE_AUTO); hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (user), "Username"); hildon_gtk_entry_set_input_mode (GTK_ENTRY (user), HILDON_GTK_INPUT_MODE_FULL); GtkWidget *ucap = hildon_caption_new (group, "Username", user, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), ucap, TRUE, TRUE, 0); if (conn) { gchar *c_name, *c_host, *c_cert, *c_user; g_object_get (conn, "name", &c_name, "host", &c_host, "cert", &c_cert, "user", &c_user, NULL); gtk_entry_set_text (GTK_ENTRY (name), c_name); gtk_entry_set_text (GTK_ENTRY (host), c_host); hildon_button_set_value (HILDON_BUTTON (cert), c_cert ? c_cert : "None"); gtk_entry_set_text (GTK_ENTRY (user), c_user); g_free (c_name); g_free (c_host); g_free (c_cert); g_free (c_user); } gtk_widget_show_all (dialog); gint retval = gtk_dialog_run (GTK_DIALOG (dialog)); if (retval == GTK_RESPONSE_OK) { const gchar *c_name, *c_cert; c_name = gtk_entry_get_text (GTK_ENTRY (name)); if (!conn) { conn = strongswan_connection_new (c_name); } c_cert = hildon_button_get_value (HILDON_BUTTON (cert)); c_cert = strcmp (c_cert, "None") ? c_cert : NULL; g_object_set (conn, "name", c_name, "host", gtk_entry_get_text (GTK_ENTRY (host)), "cert", c_cert, "user", gtk_entry_get_text (GTK_ENTRY (user)), NULL); strongswan_connections_save_connection (ListDialog.conns, conn); } gtk_widget_destroy (dialog); }
int l_xrnngvn_p(class l_xrnngvn_rek *rek_poi,GtkWidget *wpredok) { class l_xrnngvn_p_data data; char strsql[512]; data.rk=rek_poi; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Поиск")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_xrnngvn_p_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE,1); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE,1); GtkWidget *hboxknop = gtk_hbox_new (FALSE,1); gtk_container_add (GTK_CONTAINER (data.window), vbox); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkWidget *label=gtk_label_new(gettext("Код")); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE,1); data.entry[E_KOD] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE,1); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(l_xrnngvn_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk->kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); label=gtk_label_new(gettext("Наименование")); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE,1); data.entry[E_NAIM] = gtk_entry_new_with_max_length (80); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE,1); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(l_xrnngvn_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk->naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Поиск")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать поиск нужных записей"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(l_xrnngvn_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE,1); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введеноой информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(l_xrnngvn_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE,1); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Поиск не выполнять"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(l_xrnngvn_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE,1); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
int main(int argc, char* argv[]) { int persistent = 0; // wipe away any previous err file unlink("/tmp/err"); char histFile[256]; sprintf(histFile, "/home/%s/.obrun_history", getenv("USER")); // open history file FILE* logFp = fopen(histFile, "r"); gtk_init(NULL, NULL); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); // main window combo = gtk_combo_new(); // editable box with dropdown menu GList* histLines = NULL; char line[356]; gchar* newLine = NULL; int lc = 0; // add in the history items, if the file was found if (logFp != NULL) { while (fgets(line, sizeof(line), logFp) != NULL) // read a line { line[strlen(line)-1] = '\0'; // almighty null-terminator newLine = g_strdup(line); // g_list_append apparently cant just be run in a loop #if DEBUG printf("Adding line (%s) to lines...\n", newLine); #endif histLines = g_list_prepend(histLines, newLine); lc++; } histLines = g_list_prepend(histLines, ""); // empty to start with if (histLines != NULL) { #if DEBUG printf("%d histLines found\n", lc); #endif gtk_combo_set_popdown_strings(GTK_COMBO(combo), histLines); g_list_free(histLines); } } else { // just create it #if DEBUG printf("Creating new history file...\n"); #endif logFp = fopen(histFile, "w"); } g_free(newLine); // we're done with this file for now fclose(logFp); // how do we want to sort? sort_mode = "size"; if (argc > 1) { int ai; for (ai=0; ai<argc; ai++) { if (strcmp(argv[ai], "-a") == 0) { sort_mode = "alpha"; } if (strcmp(argv[ai], "-p") == 0) { persistent = 1; } } } gtk_window_set_title(GTK_WINDOW(window), "Run..."); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_add(GTK_CONTAINER(window), combo); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_widget_set_size_request(GTK_COMBO(combo)->entry, 200, 20); gtk_combo_disable_activate(GTK_COMBO(combo)); // don't show dropdown when enter // listen for X button g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(die), NULL); // listen for key up events: for typing g_signal_connect(window, "key_release_event", G_CALLBACK(check_key_up), NULL); // listen for key down events: for autocomplete, esc g_signal_connect(window, "key_press_event", G_CALLBACK(check_key_down), NULL); // listen for enter g_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->entry), "activate", G_CALLBACK(gtk_main_quit), NULL); G_START: gtk_widget_show_all(window); gtk_main(); gchar *orig_str = g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry))); gchar *exec_str = g_strdup_printf("%s 2> /tmp/err &", gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry))); if (strcmp(orig_str, "(null)") == 0 || strcmp(orig_str, "") == 0) // user didnt enter anything { die(); } g_printf("Executing %s...\n", exec_str); int result = system(exec_str); // before anything else, has this comand already been recorded? int already_present = in_file(histFile, orig_str, 0); if (!already_present) { // now lets check our error file for a bash error "command not found" char not_found_str[256]; sprintf(not_found_str, "sh: %s: command not found", orig_str); int not_found = in_file("/tmp/err", not_found_str, 1); #if DEBUG printf("already_present: %d\n", already_present); printf("not_found: %d\n", not_found); #endif if (not_found) { char* err_msg = malloc((strlen(orig_str) + strlen(": Command not found!") + 1) * sizeof(char)); sprintf(err_msg, "%s: Command not found!", orig_str); display_error_dialog(err_msg); // wipe out the entry field gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), ""); free(err_msg); goto G_START; // don't exit, move back up to where widgets are shown } if (result == 0 && !already_present && !not_found) { FILE* logFp = fopen(histFile, "a"); if (logFp == NULL) { logFp = fopen(histFile, "w"); } #if DEBUG printf("Adding %s to historyFile...\n", orig_str); #endif fprintf(logFp, "%s\n", orig_str); fclose(logFp); } } #if DEBUG printf("persistent: %d\n", persistent); #endif if (persistent == 1) { goto G_START; } g_free(orig_str); g_free(exec_str); g_list_free(matches); die(); return 0; }
void gui_init (dt_imageio_module_storage_t *self) { self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc0(sizeof(dt_storage_flickr_gui_data_t)); dt_storage_flickr_gui_data_t *ui= self->gui_data; self->widget = gtk_vbox_new(FALSE, 0); GtkWidget *hbox1=gtk_hbox_new(FALSE,5); GtkWidget *hbox0=gtk_hbox_new(FALSE,5); GtkWidget *vbox1=gtk_vbox_new(FALSE,0); GtkWidget *vbox2=gtk_vbox_new(FALSE,5); ui->label1 = GTK_LABEL( gtk_label_new( _("flickr user") ) ); ui->label3 = GTK_LABEL( gtk_label_new( _("photosets") ) ); ui->labelPerms = GTK_LABEL( gtk_label_new( _("visible to") ) ); ui->label4 = GTK_LABEL( gtk_label_new( NULL ) ); set_status(ui,_("click login button to start"), "#ffffff"); ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) ); ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) ); gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->labelPerms), 0.0, 0.9); gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.7); gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5); ui->entry1 = GTK_ENTRY( gtk_entry_new() ); ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry1)); dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry3)); dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry4)); /* gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL); */ GHashTable* table = dt_pwstorage_get("flickr"); gchar* _username = g_strdup( g_hash_table_lookup(table, "username")); g_hash_table_destroy(table); gtk_entry_set_text( ui->entry1, _username == NULL?"":_username ); gtk_entry_set_text( ui->entry3, _("my new photoset") ); gtk_entry_set_text( ui->entry4, _("exported from darktable") ); GtkWidget *albumlist=gtk_hbox_new(FALSE,0); ui->comboBox1 = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); // Available albums dt_ellipsize_combo(GTK_COMBO_BOX(ui->comboBox1)); ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) ); g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL); ui->button = GTK_BUTTON(gtk_button_new_with_label(_("login"))); g_object_set(G_OBJECT(ui->button), "tooltip-text", _("flickr login"), (char *)NULL); gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE); gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(ui->comboBox1), combobox_separator,ui->comboBox1,NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0); ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) ); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE); ui->permsComboBox = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); gtk_combo_box_text_append_text(ui->permsComboBox, _("you")); gtk_combo_box_text_append_text(ui->permsComboBox, _("friends")); gtk_combo_box_text_append_text(ui->permsComboBox, _("family")); gtk_combo_box_text_append_text(ui->permsComboBox, _("friends + family")); gtk_combo_box_text_append_text(ui->permsComboBox, _("everyone")); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->permsComboBox), 0); // Set default permission to private gtk_box_pack_start(GTK_BOX(self->widget), hbox0, TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->button ), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox1 ), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox1 ), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->labelPerms ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->permsComboBox ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0); // Create Album ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE); vbox1=gtk_vbox_new(FALSE,0); vbox2=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0); // Setup signals // add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1)); g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(flickr_album_changed), (gpointer)ui); /** dont' populate the combo on startup, save 3 second // If username and password is stored, let's populate the combo if( _username && _password ) { ui->user_token = _password; refresh_albums(ui); } */ if( _username ) g_free (_username); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox1), 0); }
static void sp_text_edit_dialog_read_selection ( GtkWidget *dlg, gboolean dostyle, gboolean docontent ) { if (g_object_get_data (G_OBJECT (dlg), "blocked")) return; g_object_set_data (G_OBJECT (dlg), "blocked", GINT_TO_POINTER (TRUE)); GtkWidget *notebook = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "notebook"); GtkWidget *textw = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "textw"); GtkWidget *fontsel = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "fontsel"); GtkWidget *preview = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "preview"); GtkWidget *apply = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "apply"); GtkWidget *def = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), "default"); GtkTextBuffer *tb = (GtkTextBuffer*)g_object_get_data (G_OBJECT (dlg), "text"); SPItem *text = sp_ted_get_selected_text_item (); Inkscape::XML::Node *repr; if (text) { guint items = sp_ted_get_selected_text_count (); if (items == 1) { gtk_widget_set_sensitive (textw, TRUE); } else { gtk_widget_set_sensitive (textw, FALSE); } gtk_widget_set_sensitive (apply, FALSE); gtk_widget_set_sensitive (def, TRUE); if (docontent) { gchar *str; str = sp_te_get_string_multiline (text); if (str) { int pos; pos = 0; if (items == 1) { gtk_text_buffer_set_text (tb, str, strlen (str)); gtk_text_buffer_set_modified (tb, FALSE); } sp_font_preview_set_phrase (SP_FONT_PREVIEW (preview), str); g_free (str); } else { gtk_text_buffer_set_text (tb, "", 0); sp_font_preview_set_phrase (SP_FONT_PREVIEW (preview), NULL); } } // end of if (docontent) repr = SP_OBJECT_REPR (text); } else { gtk_widget_set_sensitive (textw, FALSE); gtk_widget_set_sensitive (apply, FALSE); gtk_widget_set_sensitive (def, FALSE); } if (dostyle) { // create temporary style SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT); // query style from desktop into it. This returns a result flag and fills query with the style of subselection, if any, or selection //int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); int result_family = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY); int result_style = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE); int result_numbers = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); // If querying returned nothing, read the style from the text tool prefs (default style for new texts) // (Ok to not get a font specification - must just rely on the family and style in that case) if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING) { sp_style_read_from_prefs(query, "/tools/text"); } // FIXME: process result_family/style == QUERY_STYLE_MULTIPLE_DIFFERENT by showing "Many" in the lists // Get a font_instance using the font-specification attribute stored in SPStyle if available font_instance *font = font_factory::Default()->FaceFromStyle(query); if (font) { // the font is oversized, so we need to pass the true size separately sp_font_selector_set_font (SP_FONT_SELECTOR (fontsel), font, query->font_size.computed); sp_font_preview_set_font (SP_FONT_PREVIEW (preview), font, SP_FONT_SELECTOR(fontsel)); font->Unref(); font=NULL; } GtkWidget *b; if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_START) { if (query->text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY) { b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), "text_anchor_justify" ); } else { b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), "text_anchor_start" ); } } else if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) { b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), "text_anchor_middle" ); } else { b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), "text_anchor_end" ); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b), TRUE); if (query->writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB) { b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR ); } else { b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB ); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b), TRUE); GtkWidget *combo = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), "line_spacing" ); double height; if (query->line_height.normal) height = Inkscape::Text::Layout::LINE_HEIGHT_NORMAL; else if (query->line_height.unit == SP_CSS_UNIT_PERCENT) height = query->line_height.value; else height = query->line_height.computed; gchar *sstr = g_strdup_printf ("%d%%", (int) floor(height * 100 + 0.5)); gtk_entry_set_text ((GtkEntry *) ((GtkCombo *) (combo))->entry, sstr); g_free(sstr); sp_style_unref(query); } g_object_set_data (G_OBJECT (dlg), "blocked", NULL); }
/* Callback when a file is selected */ static gboolean item_event_file_selector (GooCanvasItem *item, GooCanvasItem *target, GdkEventButton *event, gchar *data) { if(!rootitem) return FALSE; switch (event->type) { case GDK_BUTTON_PRESS: if(!strcmp(data, "/ok/")) { /* Nothing selected, please cancel instead */ if(strcmp(gtk_entry_get_text(GTK_ENTRY(widget_entry)), "")==0) return FALSE; if(fileSelectorCallBack!=NULL) { gchar *result = NULL; gchar *file_type = NULL; if(mode==MODE_SAVE) { GtkTreeModel *model; GtkTreeIter iter; model = gtk_combo_box_get_model ((GtkComboBox *)gtk_combo_filetypes); if (gtk_combo_box_get_active_iter ((GtkComboBox *)gtk_combo_filetypes, &iter)) gtk_tree_model_get (model, &iter, 0, &file_type, -1); } else file_type = g_strdup(current_extension); result = g_strdup_printf("%s/%s%s", current_rootdir, gtk_entry_get_text(GTK_ENTRY(widget_entry)), (file_type ? file_type : "") ); /* Callback with the proper params */ fileSelectorCallBack(result, file_type, current_user_context); if(file_type) g_free(file_type); /* DO NOT FREE RESULT OR PYTHON SIDE WILL BE IN TROUBLE */ /* ADDENDUM: DOES NOT HURT ANYMORE, WHY ? */ if(result) g_free(result); } gc_selector_file_stop(); } else if(!strcmp(data, "/cancel/")) { gc_selector_file_stop(); } else { gchar *ext = g_strrstr(data, "."); gchar *file_wo_ext = g_strdup(data); if(ext) { gchar *ext2 = g_strrstr(file_wo_ext, "."); *ext2 = '\0'; } gtk_entry_set_text(GTK_ENTRY(widget_entry), g_path_get_basename(file_wo_ext)); g_free(file_wo_ext); if (current_extension && ext) { g_free(current_extension); current_extension = g_strdup(ext); } else if ( ext ) current_extension = g_strdup(ext); } break; default: break; } return FALSE; }
int zagotkl_m(class zagotkl_rr *rek_ras) { char strsql[512]; //iceb_poldan("Н.Д.С.",bros,"matnast.alx",NULL); //float pnds=iceb_u_atof(bros); float pnds=iceb_pnds(NULL); class zagotkl_data data; data.rk=rek_ras; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Распечатать заготовку для отчёта")); gtk_window_set_title (GTK_WINDOW (data.window),strsql); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(zagotkl_v_key_press),&data); GtkWidget *label=gtk_label_new(gettext("Распечатать заготовку для отчёта")); GtkWidget *vbox = gtk_vbox_new (FALSE, 1); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); //Вставляем радиокнопки GSList *group; data.radiobutton[0]=gtk_radio_button_new_with_label(NULL,gettext("Сортировать счет-склад-наименование материалла")); if(data.rk->metka_sort == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[0]),TRUE); //Устанавливем активной кнопку gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton[0], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.radiobutton[0]), "clicked",GTK_SIGNAL_FUNC(zagotkl_radio0),&data); //gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0"); group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton[0])); data.radiobutton[1]=gtk_radio_button_new_with_label(group,gettext("Сортировать счет-склад-группа-наименование материалла")); if(data.rk->metka_sort == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[1]),TRUE); //Устанавливем активной кнопку gtk_signal_connect(GTK_OBJECT(data.radiobutton[1]), "clicked",GTK_SIGNAL_FUNC(zagotkl_radio1),&data); gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton[1], TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkTooltips *tooltips_enter[KOLENTER]; sprintf(strsql,"%s",gettext("Дата начала")); data.knopka_enter[E_DATAO]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_DATAO]), data.knopka_enter[E_DATAO], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAO]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAO]),(gpointer)E_DATAO); tooltips_enter[E_DATAO]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_DATAO],data.knopka_enter[E_DATAO],gettext("Выбор даты"),NULL); data.entry[E_DATAO] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_DATAO]), data.entry[E_DATAO], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAO]), "activate",GTK_SIGNAL_FUNC(zagotkl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAO]),data.rk->datao.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAO]),(gpointer)E_DATAO); sprintf(strsql,"%s (,,)",gettext("Счёт")); data.knopka_enter[E_SHET]=gtk_button_new_with_label(strsql); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.knopka_enter[E_SHET], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHET]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHET]),(gpointer)E_SHET); tooltips_enter[E_SHET]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_SHET],data.knopka_enter[E_SHET],gettext("Выбор счёта в плане счетов"),NULL); //sprintf(strsql,"%s (,,)",gettext("Счет")); //label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_SHET] = gtk_entry_new_with_max_length (100); //gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.entry[E_SHET], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SHET]), "activate",GTK_SIGNAL_FUNC(zagotkl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHET]),data.rk->shet.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHET]),(gpointer)E_SHET); sprintf(strsql,"%s (,,)",gettext("Склад")); data.knopka_enter[E_SKLAD]=gtk_button_new_with_label(strsql); gtk_box_pack_start (GTK_BOX (hbox[E_SKLAD]), data.knopka_enter[E_SKLAD], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SKLAD]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SKLAD]),(gpointer)E_SKLAD); tooltips_enter[E_SKLAD]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_SKLAD],data.knopka_enter[E_SKLAD],gettext("Выбор склада"),NULL); //sprintf(strsql,"%s (,,)",gettext("Склад")); //label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_SKLAD] = gtk_entry_new_with_max_length (100); //gtk_box_pack_start (GTK_BOX (hbox[E_SKLAD]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_SKLAD]), data.entry[E_SKLAD], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SKLAD]), "activate",GTK_SIGNAL_FUNC(zagotkl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SKLAD]),data.rk->sklad.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SKLAD]),(gpointer)E_SKLAD); sprintf(strsql,"%s (,,)",gettext("Код группы материалла")); data.knopka_enter[E_KODGR]=gtk_button_new_with_label(strsql); gtk_box_pack_start (GTK_BOX (hbox[E_KODGR]), data.knopka_enter[E_KODGR], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KODGR]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KODGR]),(gpointer)E_KODGR); tooltips_enter[E_KODGR]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_KODGR],data.knopka_enter[E_KODGR],gettext("Выбор группы"),NULL); //sprintf(strsql,"%s (,,)",gettext("Код группы материалла")); //label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_KODGR] = gtk_entry_new_with_max_length (100); //gtk_box_pack_start (GTK_BOX (hbox[E_KODGR]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_KODGR]), data.entry[E_KODGR], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KODGR]), "activate",GTK_SIGNAL_FUNC(zagotkl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KODGR]),data.rk->grupa.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KODGR]),(gpointer)E_KODGR); sprintf(strsql,"%s (,,)",gettext("Код материалла")); data.knopka_enter[E_KODMAT]=gtk_button_new_with_label(strsql); gtk_box_pack_start (GTK_BOX (hbox[E_KODMAT]), data.knopka_enter[E_KODMAT], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KODMAT]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KODMAT]),(gpointer)E_KODMAT); tooltips_enter[E_KODMAT]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_KODMAT],data.knopka_enter[E_KODMAT],gettext("Выбор материалла"),NULL); //sprintf(strsql,"%s (,,)",gettext("Код материалла")); //label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_KODMAT] = gtk_entry_new_with_max_length (100); //gtk_box_pack_start (GTK_BOX (hbox[E_KODMAT]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_KODMAT]), data.entry[E_KODMAT], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KODMAT]), "activate",GTK_SIGNAL_FUNC(zagotkl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KODMAT]),data.rk->kodmat.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KODMAT]),(gpointer)E_KODMAT); sprintf(strsql,"%s (0,%.2f,+)",gettext("НДС"),pnds); label=gtk_label_new(iceb_u_toutf(strsql)); data.entry[E_NDS] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox[E_NDS]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_NDS]), data.entry[E_NDS], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NDS]), "activate",GTK_SIGNAL_FUNC(zagotkl_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NDS]),data.rk->nds.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NDS]),(gpointer)E_NDS); GtkTooltips *tooltips[KOL_F_KL]; sprintf(strsql,"F2 %s",gettext("Расчет")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчет"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F3 %s",gettext("Реквизиты")); data.knopka[FK3]=gtk_button_new_with_label(strsql); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Просмотр нужных реквизитов"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK3], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(zagotkl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); return(data.voz); }
/*----------------------------------------------------------------------------*/ void EnterNameDialogCreate(GtkWidget *parent) { if (window != NULL) { printf("window already created\n"); gtk_entry_set_text(GTK_ENTRY(name_entry), ""); gtk_entry_set_text(GTK_ENTRY(quote_entry), ""); gtk_widget_show (window); return; } GtkWidget *label; GtkWidget *button; GtkWidget *box1; GtkWidget *box2; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Enter Name Dialog"); gtk_window_set_modal(GTK_WINDOW (window), TRUE); gtk_window_set_transient_for(GTK_WINDOW (window), GTK_WINDOW (parent)); gtk_window_set_type_hint(GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width (GTK_CONTAINER (window), 6); box1 = gtk_vbox_new (FALSE, 12); box2 = gtk_hbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (window), box1); label = gtk_label_new("Congradulations you made the StackPack\n" "Hall of fame!"); gtk_label_set_justify (GTK_LABEL(label), GTK_JUSTIFY_CENTER); gtk_box_pack_start (GTK_BOX(box1), label, TRUE, TRUE, 6); gtk_widget_show (label); label = gtk_label_new("Enter in your name:"); gtk_box_pack_start (GTK_BOX(box1), label, FALSE, FALSE, 6); gtk_widget_show (label); name_entry = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY(name_entry), 31); gtk_box_pack_start (GTK_BOX(box1), name_entry, FALSE, FALSE, 6); gtk_widget_show (name_entry); label = gtk_label_new("Enter in your cool quote:"); gtk_box_pack_start (GTK_BOX(box1), label, FALSE, FALSE, 6); gtk_widget_show (label); quote_entry = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY(quote_entry), 31); gtk_box_pack_start (GTK_BOX(box1), quote_entry, FALSE, FALSE, 6); gtk_widget_show (quote_entry); button = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_end (GTK_BOX (box2), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (close_dialog), window); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), window); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_widget_show (box2); gtk_widget_show (box1); gtk_widget_show (window); }
void gui_animate_dialog(void) { gchar *tmp, *title; gpointer dialog; GtkWidget *window, *frame, *vbox, *hbox, *hbox2, *anim_box; GtkWidget *notebook, *page, *button, *label, *entry, *scale; GSList *group=NULL; struct model_pak *data; /* checks */ data = sysenv.active_model; if (!data) return; if (!data->animation) return; /* CURRENT */ /* anim_read_all_frames(data); */ /* prevent recording whilst in animation */ gui_mode_switch(FREE); /* dialog setup */ title = g_strdup_printf("Animation: %s", data->basename); dialog = dialog_request(ANIM, title, NULL, animate_cleanup, data); g_free(title); if (!dialog) return; window = dialog_window(dialog); /* notebook frame */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING); /* create notebook */ notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); gtk_container_add(GTK_CONTAINER(frame), notebook); gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), TRUE); /* page 1 */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Control"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* general animation stuff */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page),frame,FALSE,FALSE,0); /* create a vbox in the frame */ vbox = gtk_vbox_new(TRUE, PANEL_SPACING); gtk_container_add(GTK_CONTAINER(frame), vbox); /* num frames */ hbox = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), PANEL_SPACING); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("Number of frames:"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); tmp = g_strdup_printf("%9d", data->num_frames); label = gtk_label_new(tmp); g_free(tmp); gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0); /* desired delay */ gui_direct_spin("Animation delay", &data->anim_speed, 1.0, 40.0, 1.0, NULL, NULL, vbox); gui_direct_spin("Animation step size ", &data->anim_step, 1.0, data->num_frames, 1.0, NULL, NULL, vbox); gui_direct_check("Don't recalculate connectivity", &data->anim_fix, NULL, NULL, vbox); gui_direct_check("Don't recalculate scale", &data->anim_noscale, NULL, NULL, vbox); gui_direct_check("Loop", &data->anim_loop, NULL, NULL, vbox); /* page 2 */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Processing"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* cycle options */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page),frame,FALSE,FALSE,0); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING); /* actions at start of each cycle */ new_radio_group(0, vbox, FF); button = add_radio_button("Confine atoms to PBC", (gpointer) atom_pbc, data); if (data->anim_confine == PBC_CONFINE_ATOMS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Confine mols to PBC", (gpointer) mol_pbc, data); if (data->anim_confine == PBC_CONFINE_MOLS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); button = add_radio_button("Cell confinement off", (gpointer) no_pbc, data); if (data->anim_confine == PBC_CONFINE_NONE) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE); /* page 3 */ page = gtk_vbox_new(FALSE, PANEL_SPACING); label = gtk_label_new("Rendering"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* cycle options */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING); anim_box = gtk_vbox_new(TRUE, 0); gui_direct_check("Create movie", &sysenv.render.animate, anim_render, anim_box, vbox); gtk_box_pack_end(GTK_BOX(vbox), anim_box, TRUE, TRUE, 0); /* sensitive box */ vbox = gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(anim_box), vbox, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING); /* start off with a button */ button = gtk_radio_button_new_with_label (NULL, "Animated GIF"); g_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) button); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0); g_object_set_data(G_OBJECT(button), "id", (gpointer) ANIM_GIF); /* make a radio group */ group = gtk_radio_button_group(GTK_RADIO_BUTTON(button)); /* do the rest of the buttons */ button = gtk_radio_button_new_with_label(group, "MPEG"); g_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) button); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, TRUE, 0); g_object_set_data(G_OBJECT(button), "id", (gpointer) ANIM_MPEG); /* movie creation parameters */ gui_direct_spin("MPEG quality", &sysenv.render.mpeg_quality, 1, 100, 1, NULL, NULL, vbox); gui_direct_spin("Delay (ms)", &sysenv.render.delay, 0, 100, 5, NULL, NULL, vbox); /* file entry */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,0); label = gtk_label_new("Filename "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); entry = gtk_entry_new(); gtk_box_pack_end(GTK_BOX (hbox), entry, FALSE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(entry), sysenv.render.animate_file); /* update hook */ g_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(event_render_modify), (gpointer) entry); g_object_set_data(G_OBJECT(entry), "id", (gpointer) ANIM_NAME); /* misc options */ /* gui_direct_check("Create povray input files then stop", &sysenv.render.no_povray_exec, NULL, NULL, vbox); gui_direct_check("Delete intermediate input/image files", &sysenv.render.no_keep_tempfiles, NULL, NULL, vbox); */ /* set initial state */ if (!sysenv.render.animate) gtk_widget_set_sensitive(anim_box, FALSE); /* NEW - slider for current frame */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, PANEL_SPACING); gtk_container_add(GTK_CONTAINER(frame), vbox); scale = gui_direct_hscale(0, data->num_frames-1, 1, &data->cur_frame, select_frame, data, vbox); gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS); /* control buttons */ hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, PANEL_SPACING); hbox = gtk_hbox_new(TRUE, PANEL_SPACING); gtk_box_pack_start(GTK_BOX(hbox2), hbox, TRUE, FALSE, 0); gui_icon_button("GDIS_REWIND", NULL, anim_rewind, dialog, hbox); gui_icon_button("GDIS_STEP_BACKWARD", NULL, anim_step_backward, dialog, hbox); gui_icon_button("GDIS_PLAY", NULL, anim_start, dialog, hbox); gui_icon_button("GDIS_PAUSE", NULL, anim_stop, dialog, hbox); gui_icon_button("GDIS_STEP_FORWARD", NULL, anim_step_forward, dialog, hbox); gui_icon_button("GDIS_FASTFORWARD", NULL, anim_fastforward, dialog, hbox); gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog, GTK_DIALOG(window)->action_area); /* display the dialog */ gtk_widget_show_all(window); gui_relation_update(data); }