DisplayChangesGui::DisplayChangesGui(GtkWidget * box)
// Creates a GUI that displays changes on the screen.
// box: the parent box where it goes in.
{
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic("");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN);
textview = gtk_text_view_new();
gtk_widget_show(textview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), textview);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
// Create tags.
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
heavy_weight_tag = gtk_text_buffer_create_tag(textbuffer, NULL, "weight", PANGO_WEIGHT_HEAVY, "background", "hot pink", NULL);
strike_through_tag = gtk_text_buffer_create_tag(textbuffer, NULL, "strikethrough", TRUE, "background", "hot pink", NULL);
}
void EditorActionCreateNoteParagraph::apply (GtkTextTagTable * texttagtable, bool editable, EditorActionCreateParagraph * focused_paragraph, GtkWidget *& to_focus)
{
// Horizontal box to store the note.
hbox = gtk_hbox_new (false, 0);
gtk_widget_show (hbox);
gtk_box_pack_start(GTK_BOX(parent_vbox), hbox, false, false, 0);
// Eventbox to catch a few events on the caller of the note.
eventbox = gtk_event_box_new ();
gtk_widget_show (eventbox);
gtk_box_pack_start(GTK_BOX(hbox), eventbox, false, false, 0);
g_signal_connect ((gpointer) eventbox, "enter_notify_event", G_CALLBACK (on_caller_enter_notify_event), gpointer (this));
g_signal_connect ((gpointer) eventbox, "leave_notify_event", G_CALLBACK (on_caller_leave_notify_event), gpointer (this));
// The background of the caller is going to be grey.
// Courier font is chosen to make the spacing of the callers equal so they line up nicely.
label = gtk_label_new ("");
gtk_widget_show (label);
char *markup = g_markup_printf_escaped("<span background=\"grey\" size=\"x-small\"> </span><span background=\"grey\" face=\"Courier\">%s</span><span background=\"grey\" size=\"x-small\"> </span>", caller_text.c_str());
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_container_add (GTK_CONTAINER (eventbox), label);
// The textbuffer uses the text tag table.
textbuffer = gtk_text_buffer_new(texttagtable);
// Text view to view the text buffer.
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_widget_show(textview);
gtk_box_pack_start(GTK_BOX(hbox), textview, true, true, 0);
// Set some parameters of the view.
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), editable);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 5);
// Move the widget to the right position. To be calculated.
/*
vector <GtkWidget *> widgets = editor_get_widgets (parent_vbox);
gint new_paragraph_offset = 0;
if (focused_paragraph) {
for (unsigned int i = 0; i < widgets.size(); i++) {
if (focused_paragraph->textview == widgets[i]) {
new_paragraph_offset = i + 1;
break;
}
}
}
gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, new_paragraph_offset);
*/
// Let the newly created textview be earmarked to grab focus
// so that the user can type in it,
// and the internal Editor logic knows about it.
to_focus = textview;
}
void bug_information_window_new(GtkWidget * window)
{
GtkWidget *dialog;
GtkTextBuffer *buffer;
GtkWidget *scrolled_window, *text_view;
PangoTabArray *tab_array;
/* Basic dialog with a close button */
dialog = gtk_dialog_new_with_buttons(_("Bug information"),
(window) ? (GtkWindow *) playlist3_get_window() : NULL,
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CLOSE, GTK_RESPONSE_YES, NULL);
/* Set default window size */
gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 800);
/* The buffer that holds the "report" */
buffer = gtk_text_buffer_new(NULL);
bug_information_generate_message(buffer);
/* View to show the textbuffer */
text_view = gtk_text_view_new();
/* setup textview */
/* set tabarray */
tab_array = pango_tab_array_new_with_positions(1, TRUE, PANGO_TAB_LEFT, 500);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(text_view), TRUE);
gtk_text_view_set_tabs(GTK_TEXT_VIEW(text_view), tab_array);
pango_tab_array_free(tab_array);
/* not editable */
gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), FALSE);
/* set margins */
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_view), 12);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_view), 12);
/* Add the text buffer */
gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_view), buffer);
/* scrolled window, this allows the text view to scroll */
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
/* setup scrolled window */
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* add text view to scrolled_window */
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
/* add scrolled_window to dialog */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolled_window, TRUE, TRUE, 0);
/* Add dialogs response handler */
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
/* show dialog */
gtk_widget_show_all(dialog);
if (window == NULL)
{
gtk_dialog_run(GTK_DIALOG(dialog));
}
}
void
pragha_show_related_text_info_dialog (GtkWidget *widget,
const gchar *title_header,
const gchar *subtitle_header,
const gchar *text)
{
PraghaHeader *header;
GtkWidget *dialog, *vbox, *view, *scrolled;
GtkTextBuffer *buffer;
view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (view), FALSE);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_set_text (buffer, text, -1);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled), view);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_IN);
gtk_container_set_border_width (GTK_CONTAINER (scrolled), 8);
dialog = gtk_dialog_new_with_buttons (title_header,
GTK_WINDOW(widget),
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Ok"), GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size(GTK_WINDOW (dialog), 450, 350);
header = pragha_header_new ();
pragha_header_set_title (header, subtitle_header);
pragha_header_set_icon_name (header, "media-optical");
vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(header), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(dialog), "response",
G_CALLBACK(pragha_text_info_dialog_response), NULL);
gtk_widget_show_all(dialog);
}
static GtkWidget *get_text_panel(void)
{
GtkWidget *textview;
textview = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), TRUE);
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (textview), TRUE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), 2);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (textview), 2);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (textview), 2);
gtk_container_set_border_width(GTK_CONTAINER(textview), 5);
return textview;
}
void EditorActionCreateParagraph::apply (GtkTextTagTable * texttagtable, bool editable, EditorActionCreateParagraph * focused_paragraph, GtkWidget *& to_focus)
{
// The textbuffer uses the text tag table.
textbuffer = gtk_text_buffer_new(texttagtable);
// New text view to view the text buffer.
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_widget_show(textview);
// Add text view to the GUI.
gtk_box_pack_start(GTK_BOX(parent_vbox), textview, false, false, 0);
// Set some parameters of the view.
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), editable);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 5);
// Move the widget to the right position,
// which is next to the currently focused paragraph.
// This move is important since a new paragraph can be created anywhere among the current ones.
vector <GtkWidget *> widgets = editor_get_widgets (parent_vbox);
gint new_paragraph_offset = 0;
if (focused_paragraph) {
for (unsigned int i = 0; i < widgets.size(); i++) {
if (focused_paragraph->textview == widgets[i]) {
new_paragraph_offset = i + 1;
break;
}
}
}
gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, new_paragraph_offset);
// Let the newly created textview be earmarked to grab focus
// so that the user can type in it,
// and the internal Editor logic knows about it.
to_focus = textview;
}
//====================Main Window====================//
void mainWindowInit (void)
{
mw.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (mw.window), 500, 320);
gtk_window_set_title (GTK_WINDOW (mw.window), "Hello World!\n");
gtk_container_set_border_width (GTK_CONTAINER (mw.window), 10);
mw.button = gtk_button_new_with_label ("New Page.");
mw.textEditor[mw.tabCount] = gtk_text_view_new ();
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (mw.textEditor[mw.tabCount]), TRUE);
mw.notebook = gtk_notebook_new ();
gtk_notebook_append_page (GTK_NOTEBOOK (mw.notebook), mw.textEditor[mw.tabCount], NULL);
mw.overallPaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
mw.leftPaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
mw.rightPaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_set_position (GTK_PANED (mw.overallPaned), 50);
gtk_paned_set_position (GTK_PANED (mw.leftPaned), 50);
gtk_paned_set_position (GTK_PANED (mw.rightPaned), 50);
gtk_paned_pack1 (GTK_PANED (mw.rightPaned), mw.notebook, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (mw.rightPaned), mw.button, TRUE, TRUE);
gtk_paned_pack1 (GTK_PANED (mw.overallPaned), mw.leftPaned, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (mw.overallPaned), mw.rightPaned, TRUE, TRUE);
gtk_widget_set_size_request (mw.leftPaned, 50, -1);
gtk_widget_set_size_request (mw.rightPaned, 50, -1);
gtk_container_add (GTK_CONTAINER (mw.window), mw.overallPaned);
g_signal_connect (mw.button, "pressed", G_CALLBACK (mw.newDocument), NULL);
g_signal_connect (mw.window, "delete-event", G_CALLBACK (mw.cw.init), NULL);
g_signal_connect (mw.window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show_all (mw.window);
}
static void
create_gui(MathDisplay *display)
{
GtkWidget *info_view, *info_box, *main_box;
PangoFontDescription *font_desc;
int i;
GtkStyle *style;
main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(display), main_box);
g_signal_connect(display, "key-press-event", G_CALLBACK(key_press_cb), display);
display->priv->text_view = gtk_text_view_new_with_buffer(GTK_TEXT_BUFFER(display->priv->equation));
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(display->priv->text_view), GTK_WRAP_WORD);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(display->priv->text_view), FALSE);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(display->priv->text_view), 8);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(display->priv->text_view), 2);
/* TEMP: Disabled for now as GTK+ doesn't properly render a right aligned right margin, see bug #482688 */
/*gtk_text_view_set_right_margin(GTK_TEXT_VIEW(display->priv->text_view), 6);*/
gtk_text_view_set_justification(GTK_TEXT_VIEW(display->priv->text_view), GTK_JUSTIFY_RIGHT);
gtk_widget_ensure_style(display->priv->text_view);
font_desc = pango_font_description_copy(gtk_widget_get_style(display->priv->text_view)->font_desc);
pango_font_description_set_size(font_desc, 16 * PANGO_SCALE);
gtk_widget_modify_font(display->priv->text_view, font_desc);
pango_font_description_free(font_desc);
gtk_widget_set_name(display->priv->text_view, "displayitem");
atk_object_set_role(gtk_widget_get_accessible(display->priv->text_view), ATK_ROLE_EDITBAR);
//FIXME:<property name="AtkObject::accessible-description" translatable="yes" comments="Accessible description for the area in which results are displayed">Result Region</property>
g_signal_connect(display->priv->text_view, "key-press-event", G_CALLBACK(display_key_press_cb), display);
gtk_box_pack_start(GTK_BOX(main_box), display->priv->text_view, TRUE, TRUE, 0);
info_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(main_box), info_box, FALSE, TRUE, 0);
info_view = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(info_view), GTK_WRAP_WORD);
gtk_widget_set_can_focus(info_view, TRUE); // FIXME: This should be FALSE but it locks the cursor inside the main view for some reason
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(info_view), FALSE); // FIXME: Just here so when incorrectly gets focus doesn't look editable
gtk_text_view_set_editable(GTK_TEXT_VIEW(info_view), FALSE);
gtk_text_view_set_justification(GTK_TEXT_VIEW(info_view), GTK_JUSTIFY_RIGHT);
/* TEMP: Disabled for now as GTK+ doesn't properly render a right aligned right margin, see bug #482688 */
/*gtk_text_view_set_right_margin(GTK_TEXT_VIEW(info_view), 6);*/
gtk_box_pack_start(GTK_BOX(info_box), info_view, TRUE, TRUE, 0);
display->priv->info_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info_view));
display->priv->spinner = gtk_spinner_new();
gtk_box_pack_end(GTK_BOX(info_box), display->priv->spinner, FALSE, FALSE, 0);
style = gtk_widget_get_style(info_view);
for (i = 0; i < 5; i++) {
gtk_widget_modify_bg(GTK_WIDGET(display), i, &style->base[i]);
}
gtk_widget_show(info_box);
gtk_widget_show(info_view);
gtk_widget_show(display->priv->text_view);
gtk_widget_show(main_box);
g_signal_connect(display->priv->equation, "notify::status", G_CALLBACK(status_changed_cb), display);
status_changed_cb(display->priv->equation, NULL, display);
}
int main(int argc, char *argv[])
{
GError *error = NULL;
GdkPixbuf *icon_pixbuf = NULL;
char bar_buf[64]={0};
char nameBuffer[32]={0};
GtkWidget *window;
GtkWidget *fixed;
PangoFontDescription *pfd;
GdkColor color;
//g_setenv ("GTK_MODULES", "", TRUE);
//g_setenv ("GTK2_RC_FILES", "/dev/null", TRUE);
//gtk_disable_setlocale();
//g_setenv (LC_ALL, "utf8", FALSE);
//setlocale (LC_ALL, "utf8");
//setenv(LC_ALL,"C",0);
//gtk_rc_parse("rc/rc.txt");
#ifdef WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD(2, 2), &wsaData);
#endif
if(0)
{
char host_name[256];
int i = 0;
HOSTENT *host_entry;
gethostname(host_name,sizeof(host_name)); //获取本地主机名称
host_entry=gethostbyname(host_name); //从主机名数据库中得到对应的“主机”
for(i = 0; host_entry!= NULL && host_entry->h_addr_list[i]!= NULL; i++ )
//循环得出本地机器所有IP地址
{
const char *pszAddr=inet_ntoa (*(struct in_addr *)host_entry->h_addr_list[i]);
g_print("pszAddr = %s\n",pszAddr);
}
}
else
{
FILE *f=fopen("res/ip.txt","rb");
if(f)
{
int l;
fgets(ip,16,f);
l = strlen(ip);
if(l > 0 && (ip[l-1] == '\n' || ip[l-1] == '\r'))
{
ip[l-1] = 0;
}
l = strlen(ip);
if(l > 0 && (ip[l-1] == '\n' || ip[l-1] == '\r'))
{
ip[l-1] = 0;
}
g_print("ip = %s\n",ip);
fclose(f);
}
}
gtk_init (&argc, &argv);
setlocale (LC_ALL, "C");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
snprintf(bar_buf,64,"版权所有 2013-08-28");
gtk_window_set_title(GTK_WINDOW(window),bar_buf);
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(window),FALSE);
gtk_widget_set_size_request(window,800,400);
gtk_container_set_border_width(GTK_CONTAINER(window),10);
update_widget_bg(window,"res/bg.jpg");
icon_pixbuf = gdk_pixbuf_new_from_file("res/logo.jpg",&error);
if (icon_pixbuf)
{
gtk_window_set_icon(GTK_WINDOW(window), icon_pixbuf);
g_object_unref(icon_pixbuf);
}
else
{
printf("%s\n",error->message);
g_error_free(error);
}
g_signal_connect (G_OBJECT(window),"destroy",G_CALLBACK (destroy),NULL);
//======================================================================
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
//======================================================================
//button1
//======================================================================
button1 = gtk_button_new_with_label("发送");
gtk_widget_set_size_request(button1, 80, 50);
gtk_fixed_put(GTK_FIXED(fixed), button1, 680, 240+80);
gtk_widget_show(button1);
gtk_container_foreach (GTK_CONTAINER(button1), button_set_text, NULL);
g_signal_connect (G_OBJECT (button1), "clicked",G_CALLBACK (button_clicked),NULL);
//======================================================================
//button2
//======================================================================
button2 = gtk_button_new_with_label("清空");
gtk_widget_set_size_request(button2, 80, 50);
gtk_fixed_put(GTK_FIXED(fixed), button2, 560, 240+80);
gtk_widget_show(button2);
gtk_container_foreach (GTK_CONTAINER(button2), button_set_text, NULL);
g_signal_connect (G_OBJECT (button2), "clicked",G_CALLBACK (button_clicked1),NULL);
//======================================================================
//scroll
scrolled=gtk_scrolled_window_new(NULL,NULL); /*创建滚动窗口构件*/
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC/*GTK_POLICY_ALWAYS*/);
gtk_widget_show(scrolled);
gtk_widget_set_size_request(scrolled,760,100);
gtk_fixed_put(GTK_FIXED(fixed),scrolled, 6, 180);
//entry
//======================================================================
//entry = gtk_entry_new();
entry = gtk_text_view_new();
gtk_text_view_set_wrap_mode((GtkTextView *)entry,GTK_WRAP_CHAR);
gtk_text_view_set_accepts_tab((GtkTextView *)entry,FALSE);
/*将文本视图构件加入滚动窗口*/
//gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled),entry);
gtk_container_add(GTK_CONTAINER(scrolled), entry);
//gtk_widget_set_size_request(entry,760,100);
//gtk_entry_set_max_length (GTK_ENTRY (entry), 36);
snprintf(nameBuffer,32,"widget%d",0+1);
gtk_widget_set_name(entry, nameBuffer);
//g_signal_connect (G_OBJECT(entry),"activate",G_CALLBACK (enter_callback),entry);
//gtk_fixed_put(GTK_FIXED(fixed),entry, 6, 180);
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(entry),pfd);
pango_font_description_free(pfd);
//gtk_container_foreach (GTK_CONTAINER(entry), button_set_text1, NULL);
gdk_color_parse ("RED", &color);
gtk_widget_modify_fg (entry, GTK_STATE_NORMAL, &color);
gdk_color_parse ("RED", &color);
gtk_widget_modify_bg (entry, GTK_STATE_NORMAL, &color);
gdk_color_parse ("GRAY", &color);
gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &color);
gtk_widget_show(entry);
//======================================================================
//combo
//======================================================================
if(0)
{
combo = gtk_combo_box_text_new_with_entry();
gtk_widget_set_size_request(combo,600,50);
fill_cmbo(combo);
gtk_widget_show(combo);
gtk_fixed_put(GTK_FIXED(fixed), combo, 160, 60);
}
else
{
combo = create_combobox_with_model();
gtk_combo_box_set_active((GtkComboBox *)combo,0);
gtk_widget_set_size_request(combo,600,50);
gtk_widget_show(combo);
gtk_fixed_put(GTK_FIXED(fixed), combo, 160, 60);
}
lable11 = gtk_label_new ("包房号:");
//gtk_widget_set_size_request(lable11,160,50);
gtk_fixed_put(GTK_FIXED(fixed),lable11, 6, 60+15);
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(lable11),pfd);
pango_font_description_free(pfd);
gtk_widget_show(lable11);
lable12 = gtk_label_new ("信息发送:");
//gtk_widget_set_size_request(lable12,100,50);
gtk_fixed_put(GTK_FIXED(fixed),lable12, 6, 120+15);
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(lable12),pfd);
pango_font_description_free(pfd);
gtk_widget_show(lable12);
lable13 = gtk_label_new ("管理工具");
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(lable13),pfd);
pango_font_description_free(pfd);
gtk_fixed_put(GTK_FIXED(fixed),lable13, 0, 0);
gtk_widget_show(lable13);
lable14 = gtk_label_new (""/*"信息已经送出"*/);
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(lable14),pfd);
pango_font_description_free(pfd);
gdk_color_parse ("RED", &color);
gtk_widget_modify_fg (lable14, GTK_STATE_NORMAL, &color);
//gdk_color_parse ("GREEN", &color);
//gtk_widget_modify_bg (entry, GTK_STATE_NORMAL, &color);
//gdk_color_parse ("RED", &color);
//gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &color);
gtk_fixed_put(GTK_FIXED(fixed),lable14, 0, 240+10+80);
gtk_widget_show(lable14);
hseparator1 = gtk_hseparator_new ();
gtk_widget_set_size_request(hseparator1,800,1);
gtk_fixed_put(GTK_FIXED(fixed),hseparator1, 0, 120);
gtk_widget_show(hseparator1);
hseparator2 = gtk_hseparator_new ();
gtk_widget_set_size_request(hseparator2,800,1);
gtk_fixed_put(GTK_FIXED(fixed),hseparator2, 0, 50);
gtk_widget_show(hseparator2);
//======================================================================
//provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
//g_signal_connect (provider,"parsing-error",G_CALLBACK (show_parsing_error),
// gtk_text_view_get_buffer (GTK_TEXT_VIEW (combo)));
//apply_css (window, provider);
//show
//======================================================================
gtk_widget_show(fixed);
gtk_widget_show (window);
//======================================================================
gtk_main ();
return 0;
}
MergeDialog::MergeDialog(const ustring & text)
{
event_textbuffer = 0;
extern Settings *settings;
mergedialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(mergedialog), _("Merge"));
gtk_window_set_position(GTK_WINDOW(mergedialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(mergedialog), TRUE);
gtk_window_set_default_size(GTK_WINDOW(mergedialog), (int)(settings->genconfig.screen_width_get() * 0.8), (int)(settings->genconfig.screen_height_get() * 0.9));
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (mergedialog));
gtk_widget_show(dialog_vbox1);
label = gtk_label_new(_("The merge operation needs manual intervention. Each place that needs intervention shows two buttons with the two alternatives. Please press the buttons with the correct text."));
gtk_label_set_line_wrap(GTK_LABEL(label), true);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), label, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN);
textview = gtk_text_view_new();
gtk_widget_show(textview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), textview);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(mergedialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(mergedialog, NULL, NULL, NULL);
cancelbutton = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(mergedialog), cancelbutton, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true);
okbutton = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(mergedialog), okbutton, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton), true);
gtk_widget_set_sensitive(okbutton, false);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
g_signal_connect_after((gpointer) textbuffer, "changed", G_CALLBACK(on_textbuffer_changed), gpointer(this));
gtk_widget_grab_focus(textview);
gtk_widget_grab_default(okbutton);
load_text(text);
}
ProjectNoteDialog::ProjectNoteDialog(GtkWidget * parent, const vector < ustring > &projects_in, const ustring & project_in, const ustring & created_on, const ustring & created_by, const ustring & edited_on, const ustring & logbook)
{
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), _("Project note"));
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
gtk_widget_show(dialog_vbox1);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0);
label_note_project = gtk_label_new_with_mnemonic(_("Pro_ject"));
gtk_widget_show(label_note_project);
gtk_box_pack_start(GTK_BOX(vbox1), label_note_project, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_note_project), 0, 0.5);
combobox_note_project = gtk_combo_box_new_text();
gtk_widget_show(combobox_note_project);
gtk_box_pack_start(GTK_BOX(vbox1), combobox_note_project, FALSE, FALSE, 0);
label_note_created_on = gtk_label_new(_("Created on"));
gtk_widget_show(label_note_created_on);
gtk_box_pack_start(GTK_BOX(vbox1), label_note_created_on, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_note_created_on), 0, 0.5);
label_note_created_by = gtk_label_new(_("Created by"));
gtk_widget_show(label_note_created_by);
gtk_box_pack_start(GTK_BOX(vbox1), label_note_created_by, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_note_created_by), 0, 0.5);
label_note_edited_on = gtk_label_new(_("Edited on"));
gtk_widget_show(label_note_edited_on);
gtk_box_pack_start(GTK_BOX(vbox1), label_note_edited_on, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_note_edited_on), 0, 0.5);
label_note_logbook = gtk_label_new(_("Logbook"));
gtk_widget_show(label_note_logbook);
gtk_box_pack_start(GTK_BOX(vbox1), label_note_logbook, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_note_logbook), 0, 0.5);
textview_note_logbook = gtk_text_view_new();
gtk_widget_show(textview_note_logbook);
gtk_box_pack_start(GTK_BOX(vbox1), textview_note_logbook, TRUE, TRUE, 0);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview_note_logbook), FALSE);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview_note_logbook), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview_note_logbook), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview_note_logbook), FALSE);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(dialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(dialog, NULL, NULL, NULL);
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
okbutton1 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);
gtk_label_set_mnemonic_widget(GTK_LABEL(label_note_project), combobox_note_project);
g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this));
gtk_widget_grab_default(okbutton1);
combobox_set_strings(combobox_note_project, projects_in);
combobox_set_string(combobox_note_project, project_in);
gtk_label_set_text(GTK_LABEL(label_note_created_by), created_by.c_str());
gtk_label_set_text(GTK_LABEL(label_note_created_on), created_on.c_str());
gtk_label_set_text(GTK_LABEL(label_note_edited_on), edited_on.c_str());
GtkTextBuffer *textbuffer_logbook = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_note_logbook));
gtk_text_buffer_set_text(textbuffer_logbook, logbook.c_str(), -1);
}
/* This function returns a GtkEntry derived from field_id for a particular
* contact.
* Returns GtkWidget * on success, NULL on failure
* TODO: Lots of duplicated code here, perhaps add a few bits to utils?
*/
static GtkWidget *
contacts_edit_widget_new (EContact *contact, EVCardAttribute *attr,
gboolean multi_line, gboolean *changed)
{
GtkWidget *type_edit;
EContactChangeData *data;
const gchar *attr_name = e_vcard_attribute_get_name (attr);
/* Create data structure for changes */
data = g_new0 (EContactChangeData, 1);
data->contact = contact;
data->attr = attr;
data->changed = changed;
/* Create widget */
if (!e_vcard_attribute_is_single_valued (attr)) {
/* Handle structured fields */
GtkWidget *adr_table;
guint field;
GList *values = e_vcard_attribute_get_values (attr);
adr_table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (adr_table), 6);
gtk_table_set_row_spacings (GTK_TABLE (adr_table), 6);
gtk_container_set_border_width (GTK_CONTAINER (adr_table), 6);
/* Set widget that contains attribute data */
data->widget = adr_table;
/* Add type editor */
type_edit = contacts_type_edit_widget_new (attr, multi_line,
changed);
if (type_edit) {
GtkWidget *label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_markup (GTK_LABEL (label),
/* TODO: make nicer for i18n */
_("<b>Type:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
gtk_table_attach (GTK_TABLE (adr_table), label, 0, 1,
0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (adr_table), type_edit,
1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
gtk_widget_show (type_edit);
}
/* Create sub-fields */
for (field = 0; values; values = values->next, field++) {
/* If no information exists, assume field is
* single-lined.
* TODO: It may be more intelligent in the future
* to look at the value and search for new-line
* characters.
*/
gboolean multiline = FALSE;
GtkWidget *label = NULL, *entry;
const ContactsStructuredField *sfield =
contacts_get_structured_field (attr_name, field);
const gchar *string = (const gchar *)values->data;
/* If we have the information, label the field */
if (sfield) {
gchar *label_markup;
if (sfield->priority == 0)
continue;
label = gtk_label_new (NULL);
multiline = sfield->multiline;
gtk_label_set_use_markup (GTK_LABEL (label),
TRUE);
label_markup = g_strdup_printf (
/** Translators, the first
* argument is the field's
* name, ex. <b>Country:</b>
*/
_("<b>%s:</b>"),
gettext(sfield->subfield_name));
gtk_label_set_markup (GTK_LABEL (label),
label_markup);
g_free (label_markup);
gtk_label_set_justify (GTK_LABEL (label),
GTK_JUSTIFY_RIGHT);
if (!multiline)
gtk_misc_set_alignment (
GTK_MISC (label), 1, 0.5);
else
gtk_misc_set_alignment (
GTK_MISC (label), 1, 0);
gtk_table_attach (GTK_TABLE (adr_table), label,
0, 1, field + 1, field + 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
}
/* This code is pretty much a verbatim copy of the
* code below to handle single-valued fields
*/
if (multiline) {
GtkTextBuffer *buffer;
GtkTextView *view;
view = GTK_TEXT_VIEW (gtk_text_view_new ());
gtk_widget_set_name (GTK_WIDGET (view),
attr_name);
buffer = gtk_text_view_get_buffer (view);
gtk_text_buffer_set_text (buffer, string ?
string : "", -1);
gtk_text_view_set_editable (view, TRUE);
gtk_text_view_set_accepts_tab (view, FALSE);
entry = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (entry),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (entry),
GTK_WIDGET (view));
gtk_widget_show (GTK_WIDGET (view));
/* Connect signal for changes */
g_signal_connect (G_OBJECT (buffer), "changed",
G_CALLBACK
(contacts_entry_changed),
data);
} else {
entry = gtk_entry_new ();
gtk_widget_set_name (entry, attr_name);
gtk_entry_set_text (GTK_ENTRY (entry),
string ? string : "");
/* Connect signal for changes */
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK
(contacts_entry_changed),
data);
}
gtk_widget_show (entry);
/* Hide the label when the entry is hidden */
g_signal_connect_swapped (G_OBJECT (entry), "hide",
G_CALLBACK (gtk_widget_hide),
label);
gtk_table_attach (GTK_TABLE (adr_table), entry,
1, 2, field + 1, field + 2,
GTK_FILL | GTK_EXPAND, GTK_FILL,
0, 0);
}
} else if (multi_line) {
/* Handle single-valued fields that span multiple lines */
gchar *string = e_vcard_attribute_get_value (attr);
GtkWidget *container = NULL;
GtkTextView *view = GTK_TEXT_VIEW (gtk_text_view_new ());
GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
gtk_widget_set_name (GTK_WIDGET (view), attr_name);
gtk_text_buffer_set_text (buffer, string ? string : "", -1);
gtk_text_view_set_editable (view, TRUE);
gtk_text_view_set_accepts_tab (view, FALSE);
g_free (string);
container = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (
GTK_FRAME (container), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (container),
GTK_WIDGET (view));
gtk_widget_show (GTK_WIDGET (view));
/* if (type_edit) {
gtk_widget_show (type_edit);
gtk_widget_show (window);
container = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (container), type_edit,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (container), window,
TRUE, TRUE, 0);
}*/
/* Set widget that contains attribute data */
data->widget = container;
/* Connect signal for changes */
g_signal_connect (G_OBJECT (buffer), "changed", G_CALLBACK
(contacts_entry_changed), data);
} else {
/* Handle simple single-valued single-line fields */
gchar *string = e_vcard_attribute_get_value (attr);
GtkWidget *entry, *container = NULL;
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry),
string ? string : "");
gtk_widget_set_name (entry, attr_name);
g_free (string);
/* if (type_edit) {
gtk_widget_show (type_edit);
gtk_widget_show (entry);
container = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (container), type_edit,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (container), entry,
TRUE, TRUE, 0);
}*/
/* Set widget that contains attribute data */
data->widget = container ? container : entry;
/* Connect signal for changes */
g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK
(contacts_entry_changed), data);
}
/* Free change data structure on destruction */
g_signal_connect_swapped (G_OBJECT (data->widget), "destroy",
G_CALLBACK (g_free), data);
gtk_widget_set_name (data->widget, attr_name);
return data->widget;
}
Chattab *
ui_tab_create(const gchar *jid, const gchar *title, gint active)
{
Chattab *tab;
GtkWidget *evbox;
tab = g_malloc(sizeof(Chattab));
if(jid == NULL) {
tab->jid = NULL;
status_tab = tab;
}
else
tab->jid = g_strdup(jid);
tab->title = g_strdup(title);
/* setting up a place for a tab title */
evbox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(evbox), FALSE);
tab->label = gtk_label_new(tab->title);
gtk_container_add(GTK_CONTAINER(evbox), tab->label);
gtk_widget_show(tab->label);
g_signal_connect(G_OBJECT(evbox), "button-press-event",
G_CALLBACK(tab_label_click_cb), (gpointer)tab);
/* creating GtkTextView for status messages */
tab->tview = gtk_text_view_new();
tab->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tab->tview));
gtk_text_view_set_editable(GTK_TEXT_VIEW(tab->tview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(tab->tview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tab->tview), GTK_WRAP_WORD);
tab->mk = gtk_text_buffer_get_mark(tab->buffer, "insert");
/* we're putting this in a scrolled window */
tab->scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab->scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tab->scrolled),
tab->tview);
/* setting up the entry field */
if (jid) {
tab->entry = mlentry_new(tab_entry_handler, tab);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tab->entry), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(tab->entry), FALSE);
}
/* some vbox to put it together */
tab->vbox = gtk_vpaned_new();
/* this will help us finding Chattab struct by some of its properties */
g_object_set_data(G_OBJECT(tab->vbox), "chattab-data", tab);
/* now let's put it all together */
gtk_paned_pack1(GTK_PANED(tab->vbox), tab->scrolled, TRUE, FALSE);
if(jid) {
gtk_paned_pack2(GTK_PANED(tab->vbox), tab->entry, FALSE, FALSE);
}
gtk_widget_show_all(tab->vbox);
/* aaand, launch! */
gtk_notebook_append_page(GTK_NOTEBOOK(nbook), tab->vbox, evbox);
tabs = g_slist_prepend(tabs, tab);
if(active && jid) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(nbook),
gtk_notebook_page_num(GTK_NOTEBOOK(nbook),
tab->vbox));
gtk_widget_grab_focus(tab->entry);
}
return tab;
} /* ui_tab_create */
gint tag_edit_dialog(struct tags *otag, struct tags *ntag, gchar *file,
struct con_win *cwin)
{
GtkWidget *dialog;
GtkWidget *tag_table;
GtkWidget *label_title, *label_artist, *label_album, *label_genre, *label_tno, *label_year, *label_comment, *label_file;
GtkWidget *chk_title, *chk_artist, *chk_album, *chk_genre, *chk_tno, *chk_year, *chk_comment;
GtkWidget *entry_title, *entry_artist, *entry_album, *entry_genre, *entry_tno, *entry_year, *entry_comment, *entry_file;
GtkWidget *hbox_title, *hbox_artist, *hbox_album, *hbox_genre, *hbox_tno, *hbox_year, *hbox_comment;
GtkWidget *hbox_spins, *comment_view_scroll, *chk_alignment;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gpointer storage;
gint location_id, result, changed = 0;
struct musicobject *mobj = NULL;
gchar *uri = NULL;
/*Create table*/
tag_table = gtk_table_new(8, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(tag_table), 5);
gtk_table_set_row_spacings(GTK_TABLE(tag_table), 5);
gtk_container_set_border_width(GTK_CONTAINER(tag_table), 5);
/* Create labels */
label_title = gtk_label_new(_("Title"));
label_artist = gtk_label_new(_("Artist"));
label_album = gtk_label_new(_("Album"));
label_genre = gtk_label_new(_("Genre"));
label_tno = gtk_label_new(_("Track No"));
label_year = gtk_label_new(_("Year"));
label_comment = gtk_label_new(_("Comment"));
label_file = gtk_label_new(_("File"));
gtk_misc_set_alignment(GTK_MISC (label_title), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_artist), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_album), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_genre), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_tno), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_year), 1, 0.5);
gtk_misc_set_alignment(GTK_MISC (label_comment), 1, 0);
gtk_misc_set_alignment(GTK_MISC (label_file), 1, 0.5);
/* Create entry fields */
entry_title = gtk_entry_new();
entry_artist = gtk_entry_new();
entry_album = gtk_entry_new();
entry_genre = gtk_entry_new();
entry_tno = gtk_spin_button_new_with_range (0, 2030, 1);
entry_year = gtk_spin_button_new_with_range (0, 2030, 1);
entry_comment = gtk_text_view_new();
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (entry_comment), FALSE);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (entry_comment));
entry_file = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry_title), TAG_MAX_LEN);
gtk_entry_set_max_length(GTK_ENTRY(entry_artist), TAG_MAX_LEN);
gtk_entry_set_max_length(GTK_ENTRY(entry_album), TAG_MAX_LEN);
gtk_entry_set_max_length(GTK_ENTRY(entry_genre), TAG_MAX_LEN);
gtk_entry_set_completion(GTK_ENTRY(entry_artist), cwin->completion[0]);
gtk_entry_set_completion(GTK_ENTRY(entry_album), cwin->completion[1]);
gtk_entry_set_completion(GTK_ENTRY(entry_genre), cwin->completion[2]);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_title), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_artist), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_album), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_genre), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_file), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_DIRECTORY);
gtk_entry_set_icon_from_stock (GTK_ENTRY(entry_file), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_JUMP_TO);
gtk_entry_set_editable (GTK_ENTRY(entry_file), FALSE);
/* Create checkboxes */
chk_title = gtk_check_button_new();
chk_artist = gtk_check_button_new();
chk_album = gtk_check_button_new();
chk_genre = gtk_check_button_new();
chk_year = gtk_check_button_new();
chk_tno = gtk_check_button_new();
chk_comment = gtk_check_button_new();
hbox_title = gtk_hbox_new(FALSE, 0);
hbox_artist = gtk_hbox_new(FALSE, 0);
hbox_album = gtk_hbox_new(FALSE, 0);
hbox_genre = gtk_hbox_new(FALSE, 0);
hbox_year = gtk_hbox_new(FALSE, 0);
hbox_tno = gtk_hbox_new(FALSE, 0);
hbox_comment = gtk_hbox_new(FALSE, 0);
hbox_spins = gtk_hbox_new(FALSE, 5);
/* Create hobxs(ENTRY CHECHK) and attach in table */
gtk_box_pack_start(GTK_BOX(hbox_title),
entry_title,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_title),
chk_title,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_title,
0, 1, 0, 1,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_title,
1, 2, 0, 1,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_artist),
entry_artist,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_artist),
chk_artist,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_artist,
0, 1, 1, 2,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_artist,
1, 2, 1, 2,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_album),
entry_album,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_album),
chk_album,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_album,
0, 1, 2, 3,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_album,
1, 2, 2, 3,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_genre),
entry_genre,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_genre),
chk_genre,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_genre,
0, 1, 3, 4,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_genre,
1, 2, 3, 4,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
gtk_box_pack_start(GTK_BOX(hbox_tno),
entry_tno,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_tno),
chk_tno,
FALSE,
FALSE,
0);
gtk_box_pack_start(GTK_BOX(hbox_year),
label_year,
FALSE,
FALSE,
5);
gtk_box_pack_start(GTK_BOX(hbox_year),
entry_year,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_year),
chk_year,
FALSE,
FALSE,
0);
gtk_box_pack_start(GTK_BOX(hbox_spins),
hbox_tno,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_spins),
hbox_year,
TRUE,
TRUE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_tno,
0, 1, 4, 5,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_spins,
1, 2, 4, 5,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
comment_view_scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comment_view_scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(comment_view_scroll),
GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(comment_view_scroll), entry_comment);
chk_alignment = gtk_alignment_new(0.5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(chk_alignment), chk_comment);
gtk_box_pack_start(GTK_BOX(hbox_comment),
comment_view_scroll,
TRUE,
TRUE,
0);
gtk_box_pack_start(GTK_BOX(hbox_comment),
chk_alignment,
FALSE,
FALSE,
0);
gtk_table_attach(GTK_TABLE (tag_table), label_comment,
0, 1, 5, 7,
GTK_FILL, GTK_FILL|GTK_EXPAND,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), hbox_comment,
1, 2, 5, 7,
GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), label_file,
0, 1, 7, 8,
GTK_FILL, GTK_SHRINK,
0, 0);
gtk_table_attach(GTK_TABLE (tag_table), entry_file,
1, 2, 7, 8,
GTK_FILL|GTK_EXPAND, GTK_SHRINK,
0, 0);
/* The main edit dialog */
dialog = gtk_dialog_new_with_buttons(_("Edit tags"),
GTK_WINDOW(cwin->mainwindow),
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size(GTK_WINDOW (dialog), 450, -1);
/* Add to the dialog's main vbox */
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), tag_table);
/* Fill in initial entries */
if (otag->title)
gtk_entry_set_text(GTK_ENTRY(entry_title), otag->title);
if (otag->artist)
gtk_entry_set_text(GTK_ENTRY(entry_artist), otag->artist);
if (otag->album)
gtk_entry_set_text(GTK_ENTRY(entry_album), otag->album);
if (otag->genre)
gtk_entry_set_text(GTK_ENTRY(entry_genre), otag->genre);
if (otag->track_no > 0)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry_tno), (int)otag->track_no);
if (otag->year > 0)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry_year), (int)otag->year);
if (otag->comment)
gtk_text_buffer_set_text (buffer, otag->comment, -1);
if (file) {
gtk_entry_set_text(GTK_ENTRY(entry_file), file);
gtk_editable_set_position(GTK_EDITABLE(entry_file), strlen(file));
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Details"), GTK_RESPONSE_HELP);
}
else
gtk_widget_set_sensitive(GTK_WIDGET(entry_file), FALSE);
/* Connect to check the save changes when change the entry. */
g_signal_connect(G_OBJECT(entry_title),
"changed",
G_CALLBACK(check_entry),
chk_title);
g_signal_connect(G_OBJECT(entry_artist),
"changed",
G_CALLBACK(check_entry),
chk_artist);
g_signal_connect(G_OBJECT(entry_album),
"changed",
G_CALLBACK(check_entry),
chk_album);
g_signal_connect(G_OBJECT(entry_genre),
"changed",
G_CALLBACK(check_entry),
chk_genre);
g_signal_connect(G_OBJECT(entry_tno),
"changed",
G_CALLBACK(check_entry),
chk_tno);
g_signal_connect(G_OBJECT(entry_year),
"changed",
G_CALLBACK(check_entry),
chk_year);
g_signal_connect(G_OBJECT(buffer),
"changed",
G_CALLBACK(check_entry),
chk_comment);
/* Save changes when press enter. */
gtk_entry_set_activates_default (GTK_ENTRY(entry_title), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_artist), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_album), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_genre), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_tno), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY(entry_year), TRUE);
/* Connect to set clear check when click the icon. */
g_signal_connect (G_OBJECT(entry_title),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_artist),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_album),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_genre),
"icon-press",
G_CALLBACK (clear_pressed),
NULL);
g_signal_connect (G_OBJECT(entry_file),
"icon-press",
G_CALLBACK (directory_pressed),
file);
/* Genereate storage of gtk_entry and cwin,
* and add popup menu to copy selection to tags. */
storage = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_data(storage, "entry_title", entry_title);
g_object_set_data(storage, "entry_artist", entry_artist);
g_object_set_data(storage, "entry_album", entry_album);
g_object_set_data(storage, "entry_genre", entry_genre);
g_object_set_data(storage, "entry_comment", entry_comment);
g_object_set_data(storage, "entry_file", entry_file);
g_object_set_data(storage, "cwin", cwin);
g_signal_connect (G_OBJECT(entry_file),
"populate-popup",
G_CALLBACK (file_entry_populate_popup),
storage);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_widget_show_all(dialog);
while ((result = gtk_dialog_run (GTK_DIALOG (dialog))) &&
(result != GTK_RESPONSE_CANCEL) &&
(result != GTK_RESPONSE_OK) &&
(result != GTK_RESPONSE_DELETE_EVENT)) {
if(result == GTK_RESPONSE_HELP){
if (g_str_has_prefix(file, "cdda://"))
mobj = new_musicobject_from_cdda(cwin, otag->track_no);
else {
uri = sanitize_string_sqlite3(file);
if ((location_id = find_location_db(uri, cwin)))
mobj = new_musicobject_from_db(location_id, cwin);
else
mobj = new_musicobject_from_file(file);
}
track_properties(mobj, cwin);
}
}
switch (result)
{
case GTK_RESPONSE_OK:
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_tno))) {
ntag->track_no =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(entry_tno));
changed |= TAG_TNO_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_title))) {
ntag->title =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_title)));
changed |= TAG_TITLE_CHANGED;
}
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_artist))) {
ntag->artist =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_artist)));
changed |= TAG_ARTIST_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_album))) {
ntag->album =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_album)));
changed |= TAG_ALBUM_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_genre))) {
ntag->genre =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_genre)));
changed |= TAG_GENRE_CHANGED;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_year))) {
ntag->year =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(entry_year));
changed |= TAG_YEAR_CHANGED;
}
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chk_comment))) {
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
ntag->comment = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
changed |= TAG_COMMENT_CHANGED;
}
break;
case GTK_RESPONSE_DELETE_EVENT:
break;
case GTK_RESPONSE_CANCEL:
break;
default:
break;
}
gtk_widget_destroy(dialog);
if (mobj)
delete_musicobject(mobj);
g_free(uri);
return changed;
}
WindowMerge::WindowMerge(GtkWidget * parent_layout, GtkAccelGroup *accelerator_group, bool startup):
FloatingWindow(parent_layout, widMerge, _("Merge"), startup)
// Window for merging changes.
{
// Save and initialize variables.
load_gui_event_id = 0;
editors_changed_event_id = 0;
// Build GUI.
notebook1 = gtk_notebook_new();
gtk_widget_show(notebook1);
gtk_container_add(GTK_CONTAINER(vbox_client), notebook1);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook1), FALSE);
// Build merge GUI.
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(notebook1), vbox1);
label6 = gtk_label_new_with_mnemonic(_("M_aster project"));
gtk_widget_show(label6);
gtk_box_pack_start(GTK_BOX(vbox1), label6, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label6), 0, 0.5);
combobox_master = gtk_combo_box_new_text();
gtk_widget_show(combobox_master);
gtk_box_pack_start(GTK_BOX(vbox1), combobox_master, FALSE, FALSE, 0);
connect_focus_signals (combobox_master);
label7 = gtk_label_new_with_mnemonic(_("E_dited project"));
gtk_widget_show(label7);
gtk_box_pack_start(GTK_BOX(vbox1), label7, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label7), 0, 0.5);
combobox_edited = gtk_combo_box_new_text();
gtk_widget_show(combobox_edited);
gtk_box_pack_start(GTK_BOX(vbox1), combobox_edited, FALSE, FALSE, 0);
connect_focus_signals (combobox_edited);
label_info = gtk_label_new("");
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5);
display_changes_gui = new DisplayChangesGui (vbox1);
connect_focus_signals (display_changes_gui->textview);
hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, FALSE, 0);
button_previous = gtk_button_new();
gtk_widget_show(button_previous);
gtk_box_pack_start(GTK_BOX(hbox1), button_previous, FALSE, FALSE, 0);
connect_focus_signals (button_previous);
alignment2 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment2);
gtk_container_add(GTK_CONTAINER(button_previous), alignment2);
hbox2 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox2);
gtk_container_add(GTK_CONTAINER(alignment2), hbox2);
image6 = gtk_image_new_from_stock("gtk-go-back", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image6);
gtk_box_pack_start(GTK_BOX(hbox2), image6, FALSE, FALSE, 0);
label9 = gtk_label_new_with_mnemonic(_("_Previous"));
gtk_widget_show(label9);
gtk_box_pack_start(GTK_BOX(hbox2), label9, FALSE, FALSE, 0);
button_merge = gtk_button_new();
gtk_widget_show(button_merge);
gtk_box_pack_start(GTK_BOX(hbox1), button_merge, TRUE, TRUE, 0);
connect_focus_signals (button_merge);
alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment1);
gtk_container_add(GTK_CONTAINER(button_merge), alignment1);
hbox4 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox4);
gtk_container_add(GTK_CONTAINER(alignment1), hbox4);
image5 = gtk_image_new_from_stock("gtk-refresh", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image5);
gtk_box_pack_start(GTK_BOX(hbox4), image5, FALSE, FALSE, 0);
label8 = gtk_label_new_with_mnemonic(_("_Merge"));
gtk_widget_show(label8);
gtk_box_pack_start(GTK_BOX(hbox4), label8, FALSE, FALSE, 0);
button_next = gtk_button_new();
gtk_widget_show(button_next);
gtk_box_pack_start(GTK_BOX(hbox1), button_next, FALSE, FALSE, 0);
connect_focus_signals (button_next);
alignment3 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment3);
gtk_container_add(GTK_CONTAINER(button_next), alignment3);
hbox3 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox3);
gtk_container_add(GTK_CONTAINER(alignment3), hbox3);
label10 = gtk_label_new_with_mnemonic(_("_Next"));
gtk_widget_show(label10);
gtk_box_pack_start(GTK_BOX(hbox3), label10, FALSE, FALSE, 0);
image8 = gtk_image_new_from_stock("gtk-go-forward", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image8);
gtk_box_pack_start(GTK_BOX(hbox3), image8, FALSE, FALSE, 0);
// Build approve GUI.
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_container_add(GTK_CONTAINER(notebook1), vbox2);
label_approve = gtk_label_new("");
gtk_widget_show(label_approve);
gtk_box_pack_start(GTK_BOX(vbox2), label_approve, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_approve), 0, 0.5);
scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow2);
gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow2, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_SHADOW_IN);
textview_approval = gtk_text_view_new();
gtk_widget_show(textview_approval);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), textview_approval);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview_approval), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview_approval), GTK_WRAP_WORD);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview_approval), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview_approval), FALSE);
connect_focus_signals (textview_approval);
approve_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_approval));
button_ready = gtk_button_new();
gtk_widget_show(button_ready);
gtk_box_pack_start(GTK_BOX(vbox2), button_ready, FALSE, FALSE, 0);
connect_focus_signals (button_ready);
alignment6 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment6);
gtk_container_add(GTK_CONTAINER(button_ready), alignment6);
hbox7 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox7);
gtk_container_add(GTK_CONTAINER(alignment6), hbox7);
image11 = gtk_image_new_from_stock("gtk-ok", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image11);
gtk_box_pack_start(GTK_BOX(hbox7), image11, FALSE, FALSE, 0);
label19 = gtk_label_new_with_mnemonic(_("_Save"));
gtk_widget_show(label19);
gtk_box_pack_start(GTK_BOX(hbox7), label19, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label6), combobox_master);
gtk_label_set_mnemonic_widget(GTK_LABEL(label7), combobox_edited);
g_signal_connect((gpointer) combobox_master, "changed", G_CALLBACK(on_combobox_master_changed), gpointer(this));
g_signal_connect((gpointer) combobox_edited, "changed", G_CALLBACK(on_combobox_edited_changed), gpointer(this));
g_signal_connect((gpointer) button_previous, "clicked", G_CALLBACK(on_button_previous_clicked), gpointer(this));
g_signal_connect((gpointer) button_merge, "clicked", G_CALLBACK(on_button_merge_clicked), gpointer(this));
g_signal_connect((gpointer) button_next, "clicked", G_CALLBACK(on_button_next_clicked), gpointer(this));
g_signal_connect((gpointer) button_ready, "clicked", G_CALLBACK(on_button_ready_clicked), gpointer(this));
// Create signalling buttons.
editors_get_text_button = gtk_button_new();
new_reference_button = gtk_button_new();
save_editors_button = gtk_button_new();
reload_editors_button = gtk_button_new();
// Set buttons insensitive.
gtk_widget_set_sensitive(button_previous, false);
gtk_widget_set_sensitive(button_merge, false);
gtk_widget_set_sensitive(button_next, false);
// Main focused widget.
last_focused_widget = combobox_master;
gtk_widget_grab_focus (last_focused_widget);
}
