void text_export(struct _properties *properties, char *dataExport)
{
properties->textExport = false;
GtkWidget *window, *scrolled_win, *textview;
GtkTextBuffer *buffer;
time_t mytime;
struct tm *my_tm;
time(&mytime);
my_tm=localtime(&mytime);
char tstring[400] = { 0 };
char windowTitle[400] = { 0 };
strftime(tstring,sizeof(tstring),"%a %b %d %Y %H:%M:%S",my_tm);
sprintf(windowTitle,"%s Export %s @ %s", PACKAGE_NAME, option_algorithms[properties->modeltype].des, tstring);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), windowTitle);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (window, 1050, 300);
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("images/2.png"));
textview = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
gtk_text_buffer_set_text (buffer, dataExport, -1);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_win), textview);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (window), scrolled_win);
gtk_widget_show_all (window);
}
static void
display_text (gchar *title, gchar *text, gboolean editable)
{
GtkWidget *dialog, *scrolled_window, *text_view;
GtkTextBuffer *buffer;
GdkPixbuf *pixbuf;
dialog = gtk_dialog_new_with_buttons (title, NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 450);
g_signal_connect_swapped (dialog, "response",
G_CALLBACK (gtk_widget_destroy), dialog);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolled_window);
text_view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), editable);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), 8);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), 8);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_set_text (buffer, text, strlen (text));
pixbuf = gtk_widget_render_icon (dialog,
ICON_CLIPBOARD_DEFAULT,
(GtkIconSize)-1,
NULL);
gtk_window_set_icon (GTK_WINDOW (dialog), pixbuf);
g_object_unref(pixbuf);
gtk_widget_show_all (dialog);
}
void on_buttonCalendar_clicked( GtkWidget *widget, struct _properties *properties )
{
g_print ("on_buttonCalendar_clicked():\n");
gtk_window_set_title(GTK_WINDOW(properties->GtkInfo.dialogCalendar), "Select Date for Expr");
gtk_window_set_icon(GTK_WINDOW(properties->GtkInfo.dialogCalendar), create_pixbuf("images/2.png"));
int year;
int month;
int day;
int hour;
int minute;
int seconds;
properties->calendarSelected = 0;
decimal_date_to_real_dates(properties->data.t[properties->calendarSelected], &year, &month, &day, &hour, &minute, &seconds);
gtk_calendar_select_month(GTK_CALENDAR(properties->GtkInfo.calendar1), month, year);
gtk_calendar_select_day(GTK_CALENDAR(properties->GtkInfo.calendar1), day);
gtk_dialog_run(GTK_DIALOG(properties->GtkInfo.dialogCalendar));
}
GtkWidget*
hybrid_create_window(const gchar *title, GdkPixbuf *icon,
GtkWindowPosition pos, gboolean resizable)
{
GtkWidget *window;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if (!icon) {
icon = hybrid_create_default_icon(0);
} else {
g_object_ref(icon);
}
gtk_window_set_icon(GTK_WINDOW(window), icon);
gtk_window_set_resizable(GTK_WINDOW(window), resizable);
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_window_set_position(GTK_WINDOW(window), pos);
g_object_unref(icon);
return window;
}
void onFaviconChange(WebKitWebView *webview, GParamSpec *param, RuskWindow *rusk)
{
cairo_surface_t *favicon;
int width, height;
GdkPixbuf *pixbuf;
if((favicon = webkit_web_view_get_favicon(rusk->webview)) == NULL)
{
return;
}
width = cairo_image_surface_get_width(favicon);
height = cairo_image_surface_get_height(favicon);
if(width <= 0 || height <= 0)
{
return;
}
pixbuf = gdk_pixbuf_get_from_surface(favicon, 0, 0, width, height);
gtk_window_set_icon(rusk->window, pixbuf);
}
// initiate get name window
int initializeGetNameWindow(GtkWidget **window) {
// initialize window
*window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// set title
char buf[50];
sprintf(buf, "megasenha - type your name");
gtk_window_set_title(GTK_WINDOW(*window), buf);
// set size and position and connects close window with destroy function
gtk_window_set_default_size(GTK_WINDOW(*window), 397, 107);
gtk_container_set_border_width (GTK_CONTAINER (*window), 10);
gtk_window_move(GTK_WINDOW(*window), gdk_screen_width()/2 - 397/2, gdk_screen_height()*9/20);
// gtk_signal_connect (GTK_OBJECT(*window), "destroy", GTK_SIGNAL_FUNC (destroy), (gpointer) "1");
// sets and creates icons for windows and tell windows manager not to put them together
gtk_window_set_icon(GTK_WINDOW(*window), createPixbuf("info.jpg"));
gtk_window_set_wmclass(GTK_WINDOW (*window), "infoWindow", "megasenha");
gtk_widget_show_all(*window);
return 1;
}
entry_win_t login_create()
{
struct entry_win *c = calloc(1, sizeof(struct entry_win));
if (!c) {
perror("entry_win_create");
return NULL;
}
/*---�����´���---*/
c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/*---���ô��ڱ���---*/
gtk_window_set_title(GTK_WINDOW(c->win), WIN_TITLE);
/*---���ô���ͼ��---*/
gtk_window_set_icon(GTK_WINDOW(c->win), gdk_pixbuf_new_from_file(WIN_ICON, NULL));
/*---���ô���λ��---*/
gtk_window_set_position(GTK_WINDOW(c->win), GTK_WIN_POS_CENTER);
/*---���ô����Ƿ������---*/
gtk_window_set_resizable(GTK_WINDOW(c->win), FALSE);
/*---���ô��ڱ߿���---*/
gtk_container_set_border_width(GTK_CONTAINER(c->win), 0);
/*---�����˳��ź��봦����---*/
g_signal_connect(GTK_OBJECT(c->win), "destroy", G_CALLBACK(gtk_main_quit), NULL);
/*---���������ź��봦����---*/
g_signal_connect(G_OBJECT(c->win), "key_press_event", G_CALLBACK(key_press_func), c);
entry_win_draw_face(c);
gtk_widget_show_all(c->win);
return c;
}
int main( int argc,
char *argv[] )
{
PROGRAM_NAME = "DrumHero";
PROGRAM_VERSION = "0.03";
page = 0;
RecFlag = 0;
PlayFlag = 0;
duration = W;
gtk_init (&argc, &argv);
//Window here
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_events(window,GDK_BUTTON_PRESS_MASK);
gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
(GtkSignalFunc) button_press_event, NULL);
gtk_window_set_title (GTK_WINDOW (window), "Drum Studio");
gtk_widget_set_size_request(window,1024,768);
gtk_window_set_resizable(GTK_WINDOW(window),FALSE);
gtk_window_set_icon(GTK_WINDOW(window),load_pixbuf_from_file("mohnish/OpCover.jpg"));
g_signal_connect (window, "delete-event",
G_CALLBACK (delete_event), NULL);
//pageOne();
setWindow(window,"mohnish/OpCover.jpg");
pageOne();
pageTwo();
gtk_widget_show (window);
gtk_main();
return 0;
}
int main(int argc, char **argv)
{
GtkWidget *window, *vbox;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"Calc");
gtk_container_set_border_width(GTK_CONTAINER(window),15);
gtk_window_set_resizable(GTK_WINDOW(window),TRUE);
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("../img/calculator.png"));
/*gtk_widget_set_size_request(window,430,200);*/
g_signal_connect(G_OBJECT(window),"delete_event",G_CALLBACK(gtk_main_quit),NULL);
vbox = create_table();
gtk_container_add(GTK_CONTAINER(window),vbox);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void gui_show_window_with_text(gpointer signal)
{
GGaduSignal *sig = (GGaduSignal *) signal;
GtkWidget *dialog = NULL;
GtkWidget *gtv = NULL;
GtkTextBuffer *buf = NULL;
GtkWidget *sw = NULL;
GdkPixbuf *windowicon = NULL;
dialog = gtk_dialog_new_with_buttons("", NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
gtk_window_resize(GTK_WINDOW(dialog), 400, 400);
if ((windowicon = create_pixbuf(GGADU_DEFAULT_ICON_FILENAME)) != NULL)
{
gtk_window_set_icon(GTK_WINDOW(dialog), windowicon);
gdk_pixbuf_unref(windowicon);
}
buf = gtk_text_buffer_new(NULL);
gtk_text_buffer_set_text(buf, (gchar *) sig->data, -1);
gtv = gtk_text_view_new_with_buffer(buf);
gtk_text_view_set_editable(GTK_TEXT_VIEW(gtv), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(gtv), FALSE);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), sw);
gtk_container_add(GTK_CONTAINER(sw), gtv);
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), dialog);
gtk_widget_show_all(dialog);
}
GtkWidget *about_dialog_new(void)
{
const gchar *authors[] = {
"Dongsu Jang <*****@*****.**>",
"Jaeman Jang <*****@*****.**>",
NULL
};
const gchar *documenters[] = { NULL };
gchar *translators = _("translator_credits");
GtkWidget *dialog;
GdkPixbuf *logo_pixbuf;
GdkPixbuf *icon_pixbuf;
if (!strcmp(translators, "translator_credits"))
translators = NULL;
logo_pixbuf =
gdk_pixbuf_new_from_file(PKGDATADIR "/pixmaps/liteamp-logo.png", NULL);
dialog = gnome_about_new(PACKAGE, VERSION,
_("(C) 2002 Dongsu Jang"),
_("A Light-Weight Music Player for GNOME"),
authors, documenters, translators,
logo_pixbuf);
icon_pixbuf =
gdk_pixbuf_new_from_file(PKGDATADIR "/pixmaps/liteamp.png", NULL);
if (icon_pixbuf) {
gtk_window_set_icon(GTK_WINDOW(dialog), icon_pixbuf);
gdk_pixbuf_unref(icon_pixbuf);
}
return dialog;
}
int main(int argc, char *argv[]) {
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
gint pid = new_lock_file();
if (pid > 0) {
if (kill(pid, WAKE_UP_SIGNAL) == 0) {
exit(0); // 进程确已存在,则退出新进程
} else { // 否则,重新创建锁定文件
remove_lock_file();
new_lock_file();
}
}
signal(WAKE_UP_SIGNAL, wake_up);
signal(SIGINT, exit_clean);
gtk_init(&argc, &argv);
shot = gtk_shot_new();
shot->quit = quit;
shot->dblclick = save_to_clipboard;
gtk_window_set_title(GTK_WINDOW(shot), GTK_SHOT_NAME);
GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data((const char**)gtkshot_xpm);
gtk_window_set_icon(GTK_WINDOW(shot), icon);
g_object_unref(icon);
gtk_shot_show(shot, TRUE);
gtk_main();
return 0;
}
void
SetupUI::create_main_ui ()
{
GtkWidget *hpaned1;
GtkWidget *scrolledwindow1;
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *frame1;
GtkWidget *hbox1;
GtkWidget *ok_button;
GtkWidget *exit_button;
GtkWidget *vseparator1;
GdkPixbuf *icon;
GtkCellRenderer *module_list_cell;
GtkTreeViewColumn *module_list_column;
// Create main window.
m_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (m_main_window), _("SCIM Input Method Setup"));
gtk_window_set_position (GTK_WINDOW (m_main_window), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (m_main_window), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (m_main_window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (m_main_window), TRUE);
// Set the window icon
icon = gdk_pixbuf_new_from_file (SCIM_TRADEMARK_ICON_FILE, NULL);
if (icon) {
gtk_window_set_icon (GTK_WINDOW (m_main_window), icon);
g_object_unref (icon);
}
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (m_main_window), vbox1);
// Create paned window.
hpaned1 = gtk_hpaned_new ();
gtk_widget_show (hpaned1);
gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hpaned1), 4);
// Create statusbar.
m_status_bar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (m_status_bar), TRUE);
gtk_widget_show (m_status_bar);
gtk_box_pack_start (GTK_BOX (vbox1), m_status_bar, FALSE, FALSE, 0);
// Create scrollwindow for module list.
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow1);
gtk_paned_pack1 (GTK_PANED (hpaned1), scrolledwindow1, FALSE, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1),
GTK_SHADOW_ETCHED_IN);
// Create module list view.
m_module_list_view = gtk_tree_view_new ();
gtk_widget_show (m_module_list_view);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), m_module_list_view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (m_module_list_view), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (m_module_list_view), FALSE);
// Get module list selection.
m_module_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_module_list_view));
gtk_tree_selection_set_mode (m_module_list_selection, GTK_SELECTION_BROWSE);
// Create module list column.
module_list_cell = gtk_cell_renderer_text_new ();
module_list_column = gtk_tree_view_column_new_with_attributes (
NULL, module_list_cell, "text", MODULE_LIST_LABEL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (m_module_list_view), module_list_column);
// Create vbox for work area and button area.
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, FALSE);
// Create frame for work area.
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox2), frame1, TRUE, TRUE, 0);
m_work_area = gtk_vbox_new (FALSE, 0);
gtk_widget_show (m_work_area);
gtk_container_add (GTK_CONTAINER (frame1), m_work_area);
// Create hbox for button area.
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_end (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 8);
ok_button = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (ok_button);
gtk_box_pack_end (GTK_BOX (hbox1), ok_button, FALSE, FALSE, 4);
exit_button = gtk_button_new_from_stock ("gtk-quit");
gtk_widget_show (exit_button);
gtk_box_pack_end (GTK_BOX (hbox1), exit_button, FALSE, FALSE, 4);
vseparator1 = gtk_vseparator_new ();
gtk_widget_show (vseparator1);
gtk_box_pack_end (GTK_BOX (hbox1), vseparator1, FALSE, FALSE, 4);
m_apply_button = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (m_apply_button);
gtk_box_pack_end (GTK_BOX (hbox1), m_apply_button, FALSE, FALSE, 4);
GTK_WIDGET_SET_FLAGS (m_apply_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive (m_apply_button, FALSE);
m_restore_button = gtk_button_new_from_stock ("gtk-revert-to-saved");
gtk_widget_show (m_restore_button);
gtk_box_pack_end (GTK_BOX (hbox1), m_restore_button, FALSE, FALSE, 4);
gtk_widget_set_sensitive (m_restore_button, FALSE);
g_signal_connect ((gpointer) ok_button, "clicked",
G_CALLBACK (SetupUI::ok_button_clicked_callback),
this);
g_signal_connect ((gpointer) exit_button, "clicked",
G_CALLBACK (SetupUI::exit_button_clicked_callback),
this);
g_signal_connect ((gpointer) m_apply_button, "clicked",
G_CALLBACK (SetupUI::apply_button_clicked_callback),
this);
g_signal_connect ((gpointer) m_restore_button, "clicked",
G_CALLBACK (SetupUI::restore_button_clicked_callback),
this);
g_signal_connect (G_OBJECT (m_main_window), "delete_event",
G_CALLBACK (main_window_delete_callback),
this);
g_signal_connect (G_OBJECT (m_module_list_selection), "changed",
G_CALLBACK (module_list_selection_changed_callback),
this);
gtk_widget_grab_default (m_apply_button);
}
int main(int argc, char** argv)
{
GtkWidget *window;
GtkWidget *frame;
GtkWidget *plus;
GtkWidget *minus;
GtkWidget *table;
GtkWidget *label, *label1, *label2, *label3, *label4, *label5, *label6, *label7, *label8;
GtkWidget *scale;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 300,200);
gtk_window_set_title(GTK_WINDOW(window), "Boost Converter Controller");
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("icon.png"));
//creates icon from file, has to be in the same directie as the exe also good if its a png
gtk_container_set_border_width(GTK_CONTAINER(window), 5);
table = gtk_table_new(5, 4, FALSE); //creates a 4x4 widget, non homogenous
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);//sets spcaing between rows and columns
label = gtk_label_new("Voltage Setpoint");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1 );
label1 = gtk_label_new("ADC Value");
gtk_table_attach_defaults(GTK_TABLE(table), label1, 0, 1, 1, 2 );
label2 = gtk_label_new("Output Voltage");
gtk_table_attach_defaults(GTK_TABLE(table), label2, 0, 1, 2, 3 );
label3 = gtk_label_new("Output Current");
gtk_table_attach_defaults(GTK_TABLE(table), label3, 0, 1, 3, 4 );
label4 = gtk_label_new("Input Voltage");
gtk_table_attach_defaults(GTK_TABLE(table), label4, 0, 1, 4, 5 );
scale = gtk_hscale_new_with_range( 0, 15, 0.1);
gtk_table_attach_defaults(GTK_TABLE(table), scale, 1, 4, 0, 1 );
sprintf(buff, "%3.1f", adc);
gtk_label_set_text(GTK_LABEL(label), buff);
label5 = gtk_label_new(buff);
gtk_table_attach_defaults(GTK_TABLE(table), label5, 1, 4, 1, 2);
v_out = adc *
label6 = gtk_label_new(buff);
gtk_table_attach_defaults(GTK_TABLE(table), label6, 1, 4, 1, 2);
label7 = gtk_label_new(buff);
gtk_table_attach_defaults(GTK_TABLE(table), label7, 1, 4, 1, 2);
label8 = gtk_label_new(buff);
gtk_table_attach_defaults(GTK_TABLE(table), label8, 1, 4, 1, 2);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_widget_show_all(window);
g_signal_connect (G_OBJECT(scale), "value-changed", G_CALLBACK (scale_mov), label5);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_main();
return 0;
}
void fx_proxy_initialize(FxProxy *fxproxy)
{
GtkBox *vbox = NULL;
GtkBox *action_area = NULL;
GtkWidget *hostLabel = NULL;
GtkWidget *portLabel = NULL;
GtkWidget *userLabel = NULL;
GtkWidget *passLabel = NULL;
GtkWidget *fixed = NULL;
GtkWidget *okBtn = NULL;
GtkWidget *cancelBtn = NULL;
GdkPixbuf *pb = NULL;
char text[128];
Proxy *proxy = fxproxy->fxlogin->proxy;
fxproxy->dialog = gtk_dialog_new();
gtk_widget_set_usize(fxproxy->dialog , 350 , 220);
gtk_window_set_resizable(GTK_WINDOW(fxproxy->dialog) , FALSE);
gtk_window_set_title(GTK_WINDOW(fxproxy->dialog) , _("Set HTTP Proxy"));
pb = gdk_pixbuf_new_from_file(SKIN_DIR"proxy.png" , NULL);
gtk_window_set_icon(GTK_WINDOW(fxproxy->dialog) , pb);
vbox = GTK_BOX(GTK_DIALOG(fxproxy->dialog)->vbox);
action_area = GTK_BOX(GTK_DIALOG(fxproxy->dialog)->action_area);
fixed = gtk_fixed_new();
fxproxy->enableBtn = gtk_check_button_new_with_label(_("Trun on HTTP proxy"));
g_signal_connect(fxproxy->enableBtn , "toggled"
, G_CALLBACK(fx_proxy_enable_toggled) , fxproxy);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->enableBtn , 20 , 20);
fxproxy->errorLabel = gtk_label_new(NULL);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->errorLabel , 180 , 22);
hostLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(hostLabel) , _("<b>Proxy host</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , hostLabel , 20 , 55);
portLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(portLabel) , _("<b>Port</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , portLabel , 190 , 55);
fxproxy->hostEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->hostEntry , 140 , 25);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->hostEntry , 20 , 75);
fxproxy->portEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->portEntry , 140 , 25);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->portEntry , 190 , 75);
userLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(userLabel) , _("<b>Uesrname</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , userLabel , 20 , 110);
passLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(passLabel) , _("<b>Password</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , passLabel , 190 , 110);
fxproxy->userEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->userEntry , 140 , 25);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->userEntry , 20 , 130);
fxproxy->passEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->passEntry , 140 , 25);
gtk_entry_set_visibility(GTK_ENTRY(fxproxy->passEntry) , FALSE);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->passEntry , 190 , 130);
okBtn = gtk_button_new_with_label(_("OK"));
g_signal_connect(okBtn , "clicked"
, G_CALLBACK(fx_proxy_on_ok_clicked) , fxproxy);
cancelBtn = gtk_button_new_with_label(_("Cancel"));
g_signal_connect(cancelBtn , "clicked"
, G_CALLBACK(fx_proxy_on_cancel_clicked) , fxproxy);
gtk_box_pack_start_defaults(vbox , fixed);
gtk_box_pack_start_defaults(action_area , okBtn);
gtk_box_pack_start_defaults(action_area , cancelBtn);
/* bind data*/
if(proxy != NULL && proxy->proxyEnabled)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxproxy->enableBtn) , TRUE);
fx_proxy_set_sensitive(fxproxy , TRUE);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxproxy->enableBtn) , FALSE);
fx_proxy_set_sensitive(fxproxy , FALSE);
}
if(proxy != NULL)
{
gtk_entry_set_text(GTK_ENTRY(fxproxy->hostEntry) , proxy->proxyHost);
snprintf(text, sizeof(text) - 1 , "%d" , proxy->proxyPort);
gtk_entry_set_text(GTK_ENTRY(fxproxy->portEntry) , text);
gtk_entry_set_text(GTK_ENTRY(fxproxy->userEntry) , proxy->proxyUser);
gtk_entry_set_text(GTK_ENTRY(fxproxy->passEntry) , proxy->proxyPass);
}
/* show widgets*/
gtk_widget_show_all(fxproxy->dialog);
}
int main(int argc, char** argv) {
currentPlayingTime = 0.0;
startVideoAfter = 0.0;
airframeID = 1;
currentMode = MODE_REPLAY;
replayMode = MANUAL_REPLAY;
ml = g_main_loop_new(NULL, FALSE);
g_timeout_add(1000 , __timeout_func , ml);
IvyInit("Video Synchronizer", "Video Synchronizer READY", NULL, NULL, NULL, NULL);
IvyBindMsg(on_Message, NULL, "^time(\\S*) (\\S*)");
IvyBindMsg(on_Message_Video, NULL, "^(\\S*) VIDEO_SYNC(\\S*) (\\S*)");
IvyBindMsg(on_Airframe_ID, NULL, "^replay(\\S*) PONG(\\S*) (\\S*)");
#ifdef __APPLE__
IvyStart("224.255.255.255");
#else
IvyStart("127.255.255.255");
#endif
/* Ugly because remove every possibility of translation.
* But needed to prevent the use of the comma as float separator.
*/
gtk_disable_setlocale();
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Video synchronizer");
g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(on_quit), NULL);
GtkNotebook *tab = (GtkNotebook*)gtk_notebook_new();
g_signal_connect(GTK_OBJECT(tab), "switch-page", G_CALLBACK(on_change_mode), NULL);
GtkNotebook *tabReplay = (GtkNotebook*)gtk_notebook_new();
g_signal_connect(GTK_OBJECT(tabReplay), "switch-page", G_CALLBACK(on_change_replay), NULL);
//Manual mode
//create a box to align the widgets
//false -> unheaven sizes; 0 space between widgets
GtkWidget *box = gtk_hbox_new(FALSE, 0);
//add a label to explain the values to enter
GtkWidget *label = gtk_label_new("How long the video must be started \nafter the log file (may be negative) : ");
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
//add a spinbutton (to enter the value of the video synchronisation)
//startValue, lower, upper, step_increment, page_increment, page_size
GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0, -999999999999.99, 999999999999.99, 0.1, 1.0, 0.0);
spinButton = gtk_spin_button_new(adj, 0.1, 1);
g_signal_connect(GTK_OBJECT(adj), "value_changed", G_CALLBACK(on_video_sync_changed), NULL);
gtk_box_pack_start(GTK_BOX(box), spinButton, TRUE, TRUE, 0);
gtk_widget_show(spinButton);
//add the unit label at the end of the window
label = gtk_label_new("s");
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_notebook_append_page(tabReplay, box, gtk_label_new("Manual"));
//Auto mode
//create a box to align the widgets
//false -> unheaven sizes; 0 space between widgets
GtkWidget *boxAuto = gtk_hbox_new(FALSE, 0);
//add a label to explain the values to enter
label = gtk_label_new("At what time is the clap in the video : ");
gtk_box_pack_start(GTK_BOX(boxAuto), label, FALSE, FALSE, 0);
gtk_widget_show(label);
//add a spinbutton (to enter the value of the video synchronisation)
//startValue, lower, upper, step_increment, page_increment, page_size
GtkAdjustment *adjAuto = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.00, 999999999999.99, 0.1, 1.0, 0.0);
spinButtonVideo = gtk_spin_button_new(adjAuto, 0.1, 1);
g_signal_connect(GTK_OBJECT(adjAuto), "value_changed", G_CALLBACK(on_video_time_tag_changed), NULL);
gtk_box_pack_start(GTK_BOX(boxAuto), spinButtonVideo, TRUE, TRUE, 0);
gtk_widget_show(spinButtonVideo);
//add the unit label at the end of the window
label = gtk_label_new("s");
gtk_box_pack_start(GTK_BOX(boxAuto), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_notebook_append_page(tabReplay, boxAuto, gtk_label_new("Auto"));
//create the capture page
GtkWidget *captureBox = gtk_hbox_new(FALSE, 0);
GtkWidget *button = gtk_button_new_with_label("sync");
gtk_box_pack_start(GTK_BOX(captureBox), button, FALSE, FALSE, 0);
g_signal_connect(GTK_OBJECT(button), "clicked", G_CALLBACK(on_sync_clicked), NULL);
gtk_widget_show(button);
gtk_notebook_append_page(tab, (GtkWidget*)tabReplay, gtk_label_new("Replay"));
gtk_notebook_append_page(tab, (GtkWidget*)captureBox, gtk_label_new("Capture"));
gtk_container_add(GTK_CONTAINER(window), (GtkWidget*)tab);
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("data/pictures/penguin_icon_vid.png"));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static SyncDialog *sync_dialog_new(void)
{
SyncDialog *sd;
GtkWidget *dialog;
GtkWidget *dialog1_vbox;
GtkWidget *scrolledwindow2;
GtkWidget *treeview2;
GtkWidget *dialog1_action_area;
GtkWidget *button8;
GtkWidget *button7;
GtkWidget *button6;
GtkWidget *label;
GtkWidget *hbox;
GtkTreeViewColumn *column;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *cr_text, *cr_toggle;
sd = g_new0(SyncDialog, 1);
sd->sna = sync_dialog_netarea_new();
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater");
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_icon(GTK_WINDOW(dialog),
icon_cache_get_pixbuf("syncmanager.png"));
gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260);
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_container_set_border_width(GTK_CONTAINER(dialog), 5);
dialog1_vbox = GTK_DIALOG(dialog)->vbox;
gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5);
gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4);
gtk_widget_show(dialog1_vbox);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(LABEL_SYNC_DEFAULT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox),
icon_cache_get_image("syncmanager.png"),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_widget_show_all(hbox);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE,
0);
scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow2);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE,
0);
gtk_widget_set_size_request(scrolledwindow2, -1, 200);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW
(scrolledwindow2), GTK_SHADOW_IN);
store =
gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_POINTER);
model = GTK_TREE_MODEL(store);
treeview2 = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE);
gtk_widget_show(treeview2);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column);
cr_toggle = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(column, cr_toggle, FALSE);
g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model);
gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0);
cr_text = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, cr_text, TRUE);
gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1);
populate_store(store);
dialog1_action_area = GTK_DIALOG(dialog)->action_area;
gtk_widget_show(dialog1_action_area);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area),
GTK_BUTTONBOX_END);
button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_widget_show(button8);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8,
GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT);
button7 = gtk_button_new_with_mnemonic("_Synchronize");
gtk_widget_show(button7);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7,
GTK_RESPONSE_ACCEPT);
GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT);
button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect(G_OBJECT(button6), "clicked",
(GCallback) close_clicked, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6,
GTK_RESPONSE_ACCEPT);
GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT);
sd->dialog = dialog;
sd->button_sync = button7;
sd->button_cancel = button8;
sd->button_close = button6;
sd->scroll_box = scrolledwindow2;
sd->label = label;
return sd;
}
int main(int argc, char **argv){
gtk_init (&argc, &argv);
GtkWidget *p_window;
GdkPixbuf *Pixbuf;
GError *error=NULL;
/* Creation de la fenetre principale de notre application */
p_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(p_window), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(p_window),"Face Identifier Project");
gtk_window_set_default_size(GTK_WINDOW(p_window),800,500);
Pixbuf = gdk_pixbuf_new_from_file("logo.jpeg",&error);
gtk_window_set_icon(GTK_WINDOW(p_window),Pixbuf);
GdkGeometry hints;
hints.min_width = 800;
hints.max_width = 800;
hints.min_height = 500;
hints.max_height = 500;
gtk_window_set_geometry_hints(
GTK_WINDOW(p_window),
p_window,
&hints,
(GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
/* Creation des buttons */
GtkWidget *p_button1= gtk_button_new_with_label("Search");
gtk_widget_set_size_request(p_button1,120,90);
GtkWidget *p_button2= gtk_button_new_with_label("Identify");
gtk_widget_set_size_request(p_button2,120,90);
GtkWidget *p_button3= gtk_button_new_with_label("Add");
gtk_widget_set_size_request(p_button3,120,90);
/* Insertion des boutons */
g_signal_connect (G_OBJECT (p_button1), "clicked", G_CALLBACK (cb_open), NULL);
g_signal_connect (G_OBJECT (p_button2), "clicked", G_CALLBACK (face_detection), NULL);
g_signal_connect (G_OBJECT (p_button3), "clicked", G_CALLBACK (cb_add), NULL);
layout = gtk_layout_new(NULL, NULL);
GtkWidget *backgrd = gtk_image_new_from_file("backgroundUI.jpg");
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
GtkWidget *scrollbar = gtk_scrolled_window_new(NULL, NULL);
DIR* FD = opendir ("./DataBase");
struct dirent* in_file;
GtkWidget *ImgScr;
GdkPixbuf *Pbx;
GtkWidget *Label;
if (NULL != FD)
{
while ((in_file =readdir(FD)))
{
if (!strcmp (in_file->d_name, "."))
continue;
if (!strcmp (in_file->d_name, ".."))
continue;
Pbx = gdk_pixbuf_new_from_file_at_scale (concat("DataBase/",in_file->d_name),220,150,TRUE,NULL);
ImgScr = gtk_image_new_from_pixbuf(Pbx);
Label = gtk_label_new (remove_after_dot(in_file->d_name));
g_object_unref (Pbx);
gtk_box_pack_start(GTK_BOX(box), ImgScr, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(box), Label, FALSE, FALSE, 3);
}
(void) closedir (FD);
}
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollbar),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_set_size_request(scrollbar, 253,398);
gtk_container_add(GTK_CONTAINER(scrollbar), box);
gtk_layout_put(GTK_LAYOUT(layout), backgrd, 0, 0);
gtk_container_add(GTK_CONTAINER(p_window), layout);
gtk_layout_put(GTK_LAYOUT (layout), scrollbar, 548,0);
gtk_layout_put (GTK_LAYOUT (layout), p_button1, 250, 405);
gtk_layout_put (GTK_LAYOUT (layout), p_button2, 100, 405);
gtk_layout_put (GTK_LAYOUT (layout), p_button3, 400, 405);
g_signal_connect(G_OBJECT(p_window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
/* Affichage de la fenetre principale */
gtk_widget_show_all (p_window);
/* Lancement de la boucle principale */
gtk_main ();
return EXIT_SUCCESS;
return 0;
}
/* Called when About is selected from right-click menu */
static void show_about_dialog(GtkMenuItem *menu_item, gpointer user_data) {
/* This helps prevent multiple instances */
if (!gtk_grab_get_current()) {
const gchar* authors[] = {"Cristian Henzel <*****@*****.**>\n"
"Gilberto \"Xyhthyx\" Miralla <*****@*****.**>\n"
"Eugene Nikolsky <*****@*****.**>", NULL};
const gchar* license =
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program. If not, see <http://www.gnu.org/licenses/>.";
/* Create the about dialog */
GtkWidget* about_dialog = gtk_about_dialog_new();
gtk_window_set_icon((GtkWindow*)about_dialog,
gtk_widget_render_icon(about_dialog, GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU, NULL));
gtk_about_dialog_set_name((GtkAboutDialog*)about_dialog, "ClipIt");
#ifdef HAVE_CONFIG_H
gtk_about_dialog_set_version((GtkAboutDialog*)about_dialog, VERSION);
#endif
gtk_about_dialog_set_comments((GtkAboutDialog*)about_dialog,
_("Lightweight GTK+ clipboard manager."));
gtk_about_dialog_set_website((GtkAboutDialog*)about_dialog,
"http://clipit.rspwn.com/");
gtk_about_dialog_set_copyright((GtkAboutDialog*)about_dialog, "Copyright (C) 2010-2012 Cristian Henzel");
gtk_about_dialog_set_authors((GtkAboutDialog*)about_dialog, authors);
gtk_about_dialog_set_translator_credits ((GtkAboutDialog*)about_dialog,
"Guido Tabbernuk <*****@*****.**>\n"
"Miloš Koutný <*****@*****.**>\n"
"Kim Jensen <*****@*****.**>\n"
"Eckhard M. Jäger <*****@*****.**>\n"
"Michael Stempin <*****@*****.**>\n"
"Benjamin 'sphax3d' Danon <*****@*****.**>\n"
"Németh Tamás <*****@*****.**>\n"
"Davide Truffa <*****@*****.**>\n"
"Jiro Kawada <*****@*****.**>\n"
"Øyvind Sæther <*****@*****.**>\n"
"pankamyk <*****@*****.**>\n"
"Tomasz Rusek <*****@*****.**>\n"
"Phantom X <*****@*****.**>\n"
"Ovidiu D. Niţan <*****@*****.**>\n"
"Alexander Kazancev <*****@*****.**>\n"
"Daniel Nylander <*****@*****.**>\n"
"Hedef Türkçe <*****@*****.**>\n"
"Lyman Li <*****@*****.**>\n"
"Gilberto \"Xyhthyx\" Miralla <*****@*****.**>");
gtk_about_dialog_set_license((GtkAboutDialog*)about_dialog, license);
gtk_about_dialog_set_logo_icon_name((GtkAboutDialog*)about_dialog, GTK_STOCK_PASTE);
/* Run the about dialog */
gtk_dialog_run((GtkDialog*)about_dialog);
gtk_widget_destroy(about_dialog);
} else {
/* A window is already open, so we present it to the user */
GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
gtk_window_present((GtkWindow*)toplevel);
}
}
gint
main (gint argc, gchar *argv[])
{
Window root;
//gettext
bindtextdomain( "gamine", LOCALDIR );
textdomain( "gamine" );
gamine_t cb;
GtkWidget *window;
GdkWindow *gdkwindow;
GtkWindow *gtkwindow;
GdkScreen *screen;
GdkPixbuf *cursor_pixbuf;
GdkPixbuf *icon_pixbuf;
GdkCursor *cursor;
GdkColor bg_color;
gchar *cursorfile;
gchar *iconfile;
cb.is_cairo = FALSE;
gtk_init (&argc, &argv);
gst_init (&argc, &argv);
gconf_init(argc, argv, NULL);
gst_play_background (cb.bus,
"BachJSBrandenburgConcertNo2inFMajorBWV1047mvmt1.ogg", TRUE);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* Create the drawing area and configuration */
cb.da = gtk_drawing_area_new ();
bg_color.red = 65535;
bg_color.green = 65535;
bg_color.blue = 65535;
gtk_widget_modify_bg (cb.da, GTK_STATE_NORMAL, &bg_color);
gtk_container_add (GTK_CONTAINER (window), cb.da);
cb.gc = gconf_client_get_default();
gtkwindow = GTK_WINDOW(window);
gtk_window_set_title (gtkwindow, "Gamine");
gtk_window_set_wmclass(gtkwindow, "gamine", "Gamine");
gtk_container_set_border_width (GTK_CONTAINER (gtkwindow), 0);
/* Event signals */
g_signal_connect (gtkwindow, "destroy",
G_CALLBACK (gtk_main_quit), >kwindow);
g_signal_connect (G_OBJECT (cb.da), "expose-event",
G_CALLBACK (display_help), &cb);
g_signal_connect (cb.da, "motion_notify_event",
G_CALLBACK (draw_line), &cb);
g_signal_connect (cb.da, "button_press_event",
G_CALLBACK (draw_star), &cb);
g_signal_connect (gtkwindow, "key-press-event",
G_CALLBACK (gamine_on_key), &cb);
gtk_widget_set_events (cb.da, gtk_widget_get_events (cb.da)
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
/* Set fullscreen, grab mouse/keyboard, ...*/
gtk_widget_show_all (GTK_WIDGET(gtkwindow));
gdkwindow = GDK_WINDOW(GTK_WIDGET(gtkwindow)->window);
screen = gtk_widget_get_screen (cb.da);
gtk_window_present (gtkwindow);
gtk_window_stick(gtkwindow);
//gtk_window_set_keep_above (gtkwindow), True);
//gtk_window_set_transient_for (gtkwindow, NULL);
//set fullscreen
gdk_window_fullscreen (gdkwindow);
gtk_window_fullscreen (gtkwindow);
gdk_window_raise (gdkwindow);
//set full screen without window manager
XMoveResizeWindow(GDK_WINDOW_XDISPLAY(gdkwindow), GDK_WINDOW_XID(gdkwindow),
0, 0, gdk_screen_get_width (screen), gdk_screen_get_height (screen));
root = DefaultRootWindow(GDK_WINDOW_XDISPLAY (gdkwindow));
XGrabPointer(GDK_WINDOW_XDISPLAY (gdkwindow), root, True, PointerMotionMask,
GrabModeAsync, GrabModeAsync, root, None, CurrentTime);
XGrabKeyboard(GDK_WINDOW_XDISPLAY (gdkwindow), root, True,
GrabModeAsync, GrabModeAsync, CurrentTime);
//remove keyboard repeat
XAutoRepeatOff(GDK_WINDOW_XDISPLAY (gdkwindow));
gtk_window_has_toplevel_focus (gtkwindow);
/*cursor*/
cursorfile = g_build_filename(DATADIR, "pencil.png", NULL);
if (!g_file_test (cursorfile, G_FILE_TEST_EXISTS)) {
printf(gettext("*** error: %s does not exists***\n"), cursorfile);
} else {
cursor_pixbuf = gdk_pixbuf_new_from_file(cursorfile, NULL);
cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(),
cursor_pixbuf, 0, 38);
gdk_window_set_cursor(gdkwindow, cursor);
gdk_cursor_unref(cursor);
gdk_pixbuf_unref(cursor_pixbuf);
}
g_free(cursorfile);
/*Set icon*/
iconfile = g_build_filename(DATADIR, "gamine.png", NULL);
if (!g_file_test (iconfile, G_FILE_TEST_EXISTS))
printf(gettext("*** error: %s does not exists***\n"), iconfile);
else {
icon_pixbuf = gdk_pixbuf_new_from_file(iconfile, NULL);
gtk_window_set_icon (gtkwindow, icon_pixbuf);
gdk_pixbuf_unref (icon_pixbuf);
}
g_free(iconfile);
load_conf(&cb);
gtk_main ();
//set keyboard repeat
XAutoRepeatOn(GDK_WINDOW_XDISPLAY (gdkwindow));
XCloseDisplay(GDK_WINDOW_XDISPLAY (gdkwindow));
return 0;
}
MidiogreApp *midiogre_app_init(void)
{
MidiogreApp *app;
GtkWidget *header;
GtkWidget *separator;
GtkWidget *scrolled;
GtkWidget *label,*frame;
GtkWidget *button;
GtkBox *box;
gint i;
GError *err;
/* Allocate app */
app = calloc(1, sizeof(MidiogreApp));
/* Setup window */
app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400);
g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL);
gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err));
/* Setup header bar */
header = gtk_header_bar_new();
gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre");
gtk_window_set_titlebar(app->window, header);
/* Setup close button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window);
/* Add seperator */
separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator);
/* Setup folder button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window);
/* Global horizontal box */
app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box));
/* Scroll container for sidepanel */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0);
/* Sidepanel box */
app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box));
gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10);
/* Frame with favorit info */
frame = gtk_frame_new("Favorite");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box));
/* Current favorite */
app->fav_title_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_title_label, 20);
gtk_label_set_width_chars(app->fav_title_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0);
app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!"));
gtk_label_set_max_width_chars(app->fav_artist_label, 20);
gtk_label_set_width_chars(app->fav_artist_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0);
app->fav_album_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_album_label, 20);
gtk_label_set_width_chars(app->fav_album_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0);
/* Frame with search criteria widgets */
frame = gtk_frame_new("Search");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10));
gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box));
/* Title entry */
frame = gtk_frame_new("Title");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0);
/* Artist entry */
frame = gtk_frame_new("Artist");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->artist_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0);
/* Album entry */
frame = gtk_frame_new("Album");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->album_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0);
/* Instrument class buttons */
frame = gtk_frame_new("Instrument Classes");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
app->instr_grid = GTK_GRID(gtk_grid_new());
#if GTK_MINOR_VERSION >= 12
gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10);
#else
gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10);
#endif
gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid));
for (i = 0; i < INSTR_CLASSES; i++) {
label = gtk_label_new(instrument_classes[i]);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1);
app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END);
gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1);
}
/* Result spinbutton */
frame = gtk_frame_new("Max result");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1));
gtk_spin_button_set_value(app->result_spinbutton, 25);
gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0);
/* Search button */
app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search"));
gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0);
g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app);
/* Songboxes notebook (Tabsview) */
app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE);
gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0);
/* Add song boxes */
app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical");
app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint");
app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match");
app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity");
app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest");
/* Show all widgets */
gtk_widget_show_all(GTK_WIDGET(app->window));
/* Allocate song queue */
app->songs[SONGBOX_ALPHA] = g_queue_new();
app->songs[SONGBOX_FPRNT] = g_queue_new();
app->songs[SONGBOX_BEST] = g_queue_new();
app->songs[SONGBOX_POP] = g_queue_new();
app->songs[SONGBOX_NEW] = g_queue_new();
return app;
}
CAboutDlg::CAboutDlg(GtkWindow *pParent)
{
float x;
char buf[2048];
GtkWidget *tbox, *label, *scrolled_window, *text_view;
// Dialog with buttons
m_pDlg = gtk_dialog_new_with_buttons("About Muniwin", pParent,
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR),
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
// Dialog icon
gchar *icon = get_icon_file("about");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// Notebook
m_Notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), m_Notebook, TRUE, TRUE, 0);
gtk_widget_set_size_request(m_Notebook, 400, 240);
// Page "General"
tbox = gtk_table_new(4, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(tbox), 8);
gtk_table_set_row_spacings(GTK_TABLE(tbox), 8);
gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), tbox, gtk_label_new("General"));
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), "<span size=\"xx-large\" weight=\"bold\">Muniwin</span>");
gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 0, 1);
label = gtk_label_new(NULL);
sprintf(buf, "<span size=\"x-large\" weight=\"bold\">Stable version %s</span>", VERSION);
gtk_label_set_markup(GTK_LABEL(label), buf);
gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 1, 2);
label = gtk_label_new(NULL);
sprintf(buf, "<span size=\"large\">%s</span>", ProjectDescription);
gtk_label_set_markup(GTK_LABEL(label), buf);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 2, 3);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), "<span size=\"x-large\" underline=\"single\" foreground=\"blue\">http://c-munipack.sourceforge.net</span>");
gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 3, 4);
// Page "Versions"
tbox = gtk_table_new(5, 2, false);
gtk_container_set_border_width(GTK_CONTAINER(tbox), 8);
gtk_table_set_row_spacings(GTK_TABLE(tbox), 8);
gtk_table_set_col_spacings(GTK_TABLE(tbox), 16);
gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), tbox, gtk_label_new("Versions"));
AddVersion(GTK_TABLE(tbox), 0, g_AppTitle, VERSION);
AddVersion(GTK_TABLE(tbox), 1, "C-Munipack", cmpack_versionid());
sprintf(buf, "%.03f", ffvers(&x));
AddVersion(GTK_TABLE(tbox), 2, "CFITSIO", buf);
AddVersion(GTK_TABLE(tbox), 3, "Expat", XML_ExpatVersion());
sprintf(buf, "%d.%d.%d", gtk_major_version, gtk_minor_version, gtk_micro_version);
AddVersion(GTK_TABLE(tbox), 4, "GTK+", buf);
sprintf(buf, "%d.%d.%d", glib_major_version, glib_minor_version, glib_micro_version);
AddVersion(GTK_TABLE(tbox), 5, "GLib", buf);
#if HAVE_LIBGSTREAMER_0_10
gchar *gstver = gst_version_string();
AddVersion(GTK_TABLE(tbox), 6, "GStreamer", gstver);
free(gstver);
#endif
// Page "License"
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), scrolled_window, gtk_label_new("License"));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_SHADOW_ETCHED_IN);
text_view = gtk_text_view_new_with_buffer(NULL);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), false);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text_view), false);
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)),
CopyrightText, -1);
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
// Page "Credits"
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), scrolled_window, gtk_label_new("Credits"));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_SHADOW_ETCHED_IN);
text_view = gtk_text_view_new_with_buffer(NULL);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), false);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text_view), false);
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)),
CreditsText, -1);
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox);
}
void create_mainwindow(void)
{
char *imagename;
GtkWidget *vbox_gs;
GtkWidget *menu;
GtkWidget *hbox25;
GtkWidget *tab_button_icon;
GtkWidget *label;
#ifndef USE_WEBKIT2
GtkWidget *scrolledwindow;
#endif
GtkWidget *box_book;
GdkPixbuf *pixbuf;
/*
GTK_SHADOW_NONE
GTK_SHADOW_IN
GTK_SHADOW_OUT
GTK_SHADOW_ETCHED_IN
GTK_SHADOW_ETCHED_OUT
*/
settings.shadow_type = GTK_SHADOW_IN;
XI_print(("%s xiphos-%s\n", "Starting", VERSION));
XI_print(("%s\n\n", "Building Xiphos interface"));
widgets.studypad_dialog = NULL;
/* A rough scektch of the main window (widgets.app) and it's children
* widgets.app
* |
* vbox_gs
* |
* +--|----+
* | |
* menu hbox25
* |
* widgets.epaned
* |
* widgets.vboxMain
* | |
* widgets.hboxtb widgets.page
* | |
* widgets.hpaned nav_toolbar
* | |
* widgets.vpaned---+ +----------------------------widgets.vpaned2---------------+
* | | | |
* widgets.vbox_previewer widgets.vbox_text widgets.notebook_comm_book widgets.box_dict
* | | |
* widgets.notebook_bible_parallel widgets.box_comm box_book
* |
* widgets.notebook_text
*
*/
// The toplevel Xiphos window
widgets.app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(widgets.app), _("Xiphos - Bible Study Software"));
g_object_set_data(G_OBJECT(widgets.app), "widgets.app", widgets.app);
gtk_widget_set_size_request(widgets.app, 680, 425);
gtk_widget_set_can_focus(widgets.app, 1);
gtk_window_set_resizable(GTK_WINDOW(widgets.app), TRUE);
// The app icon.
// FIXME:: This should be a big copy of the logo because GTK does the scaling (GTK 3.16?)
imagename = image_locator("gs2-48x48.png");
pixbuf = gdk_pixbuf_new_from_file(imagename, NULL);
g_free(imagename);
gtk_window_set_icon(GTK_WINDOW(widgets.app), pixbuf);
// The main box for our toplevel window.
UI_VBOX(vbox_gs, FALSE, 0);
gtk_widget_show(vbox_gs);
gtk_container_add(GTK_CONTAINER(widgets.app), vbox_gs);
// Add the main menu.
menu = gui_create_main_menu();
gtk_box_pack_start(GTK_BOX(vbox_gs), menu, FALSE, TRUE, 0);
// Another box
UI_HBOX(hbox25, FALSE, 0);
gtk_widget_show(hbox25);
gtk_box_pack_start(GTK_BOX(vbox_gs), hbox25, TRUE, TRUE, 0);
// widgets.epaned
widgets.epaned = UI_HPANE();
gtk_widget_show(widgets.epaned);
#ifndef HAVE_GTK_314
gtk_container_set_border_width(GTK_CONTAINER(widgets.epaned), 4);
#endif
gtk_box_pack_start(GTK_BOX(hbox25), widgets.epaned, TRUE, TRUE, 0);
// Another box
UI_VBOX(widgets.vboxMain, FALSE, 0);
gtk_widget_show(widgets.vboxMain);
gtk_paned_pack2(GTK_PANED(widgets.epaned), widgets.vboxMain, TRUE, TRUE);
#ifndef HAVE_GTK_314
gtk_container_set_border_width(GTK_CONTAINER(widgets.vboxMain), 2);
#endif
/*
* Notebook to have separate passages opened at once the passages are not
* actually open but are switched between similar to bookmarks
*/
UI_HBOX(widgets.hboxtb, FALSE, 0);
if (settings.browsing)
gtk_widget_show(widgets.hboxtb);
gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.hboxtb, FALSE, FALSE, 0);
widgets.button_new_tab = gtk_button_new();
// Don't show button here in case !settings.browsing
#ifdef HAVE_GTK_310
tab_button_icon = gtk_image_new_from_icon_name("tab-new-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
#else
tab_button_icon = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR);
#endif
gtk_widget_show(tab_button_icon);
gtk_container_add(GTK_CONTAINER(widgets.button_new_tab), tab_button_icon);
gtk_button_set_relief(GTK_BUTTON(widgets.button_new_tab), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.button_new_tab, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(widgets.button_new_tab, _("Open a new tab"));
widgets.notebook_main = gtk_notebook_new();
gtk_widget_show(widgets.notebook_main);
gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.notebook_main, TRUE, TRUE, 0);
gtk_widget_set_size_request(widgets.notebook_main, -1, 25);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(widgets.notebook_main), TRUE);
gtk_notebook_popup_enable(GTK_NOTEBOOK(widgets.notebook_main));
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_main), FALSE);
// Main passage tabbed notebook end
// Another box
UI_VBOX(widgets.page, FALSE, 0);
gtk_widget_show(widgets.page);
gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.page, TRUE, TRUE, 0);
//nav toolbar
nav_toolbar = gui_navbar_versekey_new();
gtk_box_pack_start(GTK_BOX(widgets.page), nav_toolbar, FALSE, FALSE, 0);
// widgets.hpaned
widgets.hpaned = UI_HPANE();
gtk_widget_show(widgets.hpaned);
gtk_box_pack_start(GTK_BOX(widgets.page), widgets.hpaned, TRUE, TRUE, 0);
// widgets.vpaned
widgets.vpaned = UI_VPANE();
gtk_widget_show(widgets.vpaned);
gtk_widget_set_size_request(widgets.vpaned, 50, -1);
gtk_paned_pack1(GTK_PANED(widgets.hpaned), widgets.vpaned, TRUE, FALSE);
// widgets.vpaned2
widgets.vpaned2 = UI_VPANE();
gtk_widget_show(widgets.vpaned2);
gtk_widget_set_size_request(widgets.vpaned2, 50, -1);
gtk_paned_pack2(GTK_PANED(widgets.hpaned), widgets.vpaned2, TRUE, FALSE);
// widgets.vbox_text
UI_VBOX(widgets.vbox_text, FALSE, 0);
gtk_widget_show(widgets.vbox_text);
gtk_paned_pack1(GTK_PANED(widgets.vpaned), widgets.vbox_text, TRUE, TRUE);
// Bible/parallel notebook
widgets.notebook_bible_parallel = gtk_notebook_new();
gtk_widget_show(widgets.notebook_bible_parallel);
gtk_box_pack_start(GTK_BOX(widgets.vbox_text), widgets.notebook_bible_parallel, TRUE, TRUE, 0);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_bible_parallel), GTK_POS_BOTTOM);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_bible_parallel), TRUE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_bible_parallel), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_bible_parallel), 1);
g_signal_connect(G_OBJECT(widgets.notebook_bible_parallel), "change-current-page", G_CALLBACK(on_notebook_bible_parallel_switch_page), NULL);
// Text notebook (The bible text show in the standard view)
widgets.notebook_text = gui_create_bible_pane();
gtk_container_add(GTK_CONTAINER(widgets.notebook_bible_parallel), widgets.notebook_text);
label = gtk_label_new(_("Standard View"));
gtk_widget_show(label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_bible_parallel), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_bible_parallel), 0), label);
// Another box (For the previewer?)
UI_VBOX(widgets.vbox_previewer, FALSE, 0);
gtk_widget_show(widgets.vbox_previewer);
gtk_paned_pack2(GTK_PANED(widgets.vpaned), widgets.vbox_previewer, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.vbox_previewer), 2);
#ifndef USE_WEBKIT2
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *) scrolledwindow, settings.shadow_type);
#endif
widgets.html_previewer_text = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, VIEWER_TYPE));
gtk_widget_show(widgets.html_previewer_text);
#ifdef USE_WEBKIT2
gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), widgets.html_previewer_text, TRUE, TRUE, 0);
#else
gtk_container_add(GTK_CONTAINER(scrolledwindow), widgets.html_previewer_text);
#endif
// Commentary/book notebook
widgets.notebook_comm_book = gtk_notebook_new();
gtk_widget_show(widgets.notebook_comm_book);
gtk_paned_pack1(GTK_PANED(widgets.vpaned2), widgets.notebook_comm_book, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_comm_book), 1);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_comm_book), GTK_POS_BOTTOM);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_comm_book), TRUE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_comm_book), FALSE);
// Commentary pane
widgets.box_comm = gui_create_commentary_pane();
gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), widgets.box_comm);
label = gtk_label_new(_("Commentary View"));
gtk_widget_show(label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 0), label);
// Book pane
box_book = gui_create_book_pane();
gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), box_book);
label = gtk_label_new(_("Book View"));
gtk_widget_show(label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 1), label);
// Dict/lex
widgets.box_dict = gui_create_dictionary_pane();
gtk_paned_pack2(GTK_PANED(widgets.vpaned2), widgets.box_dict, TRUE, TRUE);
// Statusbar
widgets.appbar = gtk_statusbar_new();
if (settings.statusbar) {
gtk_widget_show(widgets.appbar);
}
#ifndef USE_GTK_3
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(widgets.appbar), TRUE);
#endif
gtk_box_pack_start(GTK_BOX(vbox_gs), widgets.appbar, FALSE, TRUE, 0);
gui_set_statusbar(_("Welcome to Xiphos"));
g_signal_connect((gpointer)vbox_gs, "key_press_event", G_CALLBACK(on_vbox1_key_press_event), NULL);
g_signal_connect((gpointer)vbox_gs, "key_release_event", G_CALLBACK(on_vbox1_key_release_event), NULL);
g_signal_connect(G_OBJECT(widgets.notebook_comm_book), "switch_page", G_CALLBACK(on_notebook_comm_book_switch_page), NULL);
g_signal_connect(G_OBJECT(widgets.app), "delete_event", G_CALLBACK(delete_event), NULL);
g_signal_connect((gpointer)widgets.app, "configure_event", G_CALLBACK(on_configure_event), NULL);
g_signal_connect(G_OBJECT(widgets.epaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"epaned");
g_signal_connect(G_OBJECT(widgets.vpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned");
g_signal_connect(G_OBJECT(widgets.vpaned2), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned2");
g_signal_connect(G_OBJECT(widgets.hpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"hpaned1");
gtk_widget_grab_focus(navbar_versekey.lookup_entry);
gtk_window_set_default_size((GtkWindow *)widgets.app, settings.gs_width, settings.gs_height);
main_window_created = TRUE;
}
int main(int argc, char *argv[])
{
GdkPixbuf *icon;
/* Redirect standard output to a file - printing to the Windows terminal slows operation down way too much */
#ifdef __WIN32__
gchar *tmp;
FILE *log_file;
tmp = g_strconcat(g_get_home_dir(), G_DIR_SEPARATOR_S, LOG_FILE, NULL);
log_file = g_fopen(tmp, "wt");
g_free(tmp);
if (log_file != NULL)
g_log_set_default_handler(&default_log_handler, log_file);
#endif
// Force GLib 2.32+ to print info and debug messages like older versions did, unless this variable is already set.
// No effect on earlier GLib versions.
g_setenv("G_MESSAGES_DEBUG", "all", /* overwrite = */ FALSE);
/* Init the tilp core */
tilp_init(&argc, &argv);
/* Init GTK+ */
gtk_init(&argc, &argv);
add_pixmap_directory(inst_paths.pixmap_dir);
add_pixmap_directory(inst_paths.icon_dir);
splash_screen_start();
/*
Get rid of glib, gdk, gtk warnings when compiled in Release mode
*/
#if !defined(_DEBUG)
g_log_set_handler ("GLib",
G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG,
my_blackhole_log_handler, NULL);
g_log_set_handler ("Gdk",
G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG,
my_blackhole_log_handler, NULL);
g_log_set_handler ("Gtk",
G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG,
my_blackhole_log_handler, NULL);
g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,
my_blackhole_log_handler, NULL);
#endif
/* Init the GUI-independent functions */
tilp_gif_set_gtk();
tilp_update_set_gtk();
/* Create the main window */
if(!(working_mode & MODE_CMD))
{
#if WITH_KDE
splash_screen_set_label(_("Initializing KDE..."));
sp_kde_init(argc, argv, "tilp", _("TiLP"), VERSION, _("Tilp Is a Linking Program"), "Copyright (c) 1999-2008 Romain Lievin", "http://lpg.ticalc.org/prj_tilp/", "*****@*****.**");
atexit(sp_kde_finish);
// Not needed unless we want to add a DCOP interface.
// g_timeout_add(26, sp_kde_process_qt_events, NULL);
#endif
splash_screen_set_label(_("Loading GUI..."));
main_wnd = display_tilp_dbox();
}
/* Do a local directory list */
g_free(local.cwdir);
local.cwdir = g_get_current_dir();
/* Update the local view (not visible yet) */
if(!(working_mode & MODE_CMD))
{
clist_refresh();
labels_refresh();
}
/* Inits are done ! */
working_mode &= ~MODE_INI;
tilp_err(0); // pop errors (display console mode)
/* In cmdline, does not display the entire window, only the pbar */
if(!(working_mode & MODE_CMD))
{
gtk_widget_show(main_wnd);
toolbar_refresh_buttons();
icon = create_pixbuf("tilp.xpm");
gtk_window_set_icon(GTK_WINDOW(main_wnd), icon);
gdk_window_set_icon_name(main_wnd->window, _("TiLP2"));
}
/*
If variables have been passed on the command line in GUI mode then
send them
*/
if((working_mode & MODE_GUI) && (working_mode & MODE_CMD))
{
splash_screen_set_label(_("Command line..."));
if(local.selection0 || local.selection2 || local.selection5)
on_tilp_send("");
else if(local.selection4)
tilp_cmdline_send();
}
/* GTK main loop */
splash_screen_stop();
if(!(working_mode & MODE_CMD))
gtk_main();
tilp_exit();
return 0;
}
int main (int argc, char *argv[])
{
int i;
const char *commandLine_File = NULL;
GtkWidget *pVBox;
GtkWidget *pMenuBar;
GtkWidget *pMenu, *pSubMenu;
GtkWidget *pMenuItem, *pSubMenuItem;
GtkAccelGroup * accel_group;
if(argc == 2) commandLine_File = argv[1];
#ifdef DEBUG
LogStart();
#endif
gtk_init(&argc, &argv);
SDL_Init(SDL_INIT_VIDEO);
desmume_init();
dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size);
for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE;
CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL);
Read_ConfigFile();
/* Creation de la fenetre */
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume");
gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE);
gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm));
g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL);
g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL);
/* Creation de la GtkVBox */
pVBox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
accel_group = gtk_accel_group_new();
action_group = gtk_action_group_new("dui");
gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow);
{
GList * list = gtk_action_group_list_actions(action_group);
g_list_foreach(list, dui_set_accel_group, accel_group);
}
gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE);
/**** Creation du menu ****/
pMenuBar = gtk_menu_bar_new();
/** Menu "Fichier" **/
pMenu = gtk_menu_new();
gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open")));
gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen")));
gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit")));
pMenuItem = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
/** Menu "Emulation" **/
GtkWidget *mEmulation;
GtkWidget *mFrameskip;
GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP];
GtkWidget *mGraphics;
GtkWidget *mSize;
GtkWidget *mSize_Radio[MAX_SCREENCOEFF];
GtkWidget *mLayers;
GtkWidget *mLayers_Radio[10];
mEmulation = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Emulation");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run")));
gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause")));
gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset")));
mFrameskip = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Frameskip");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip);
gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
for(i = 0; i < MAX_FRAMESKIP; i++) {
char frameskipRadio_buf[16];
sprintf(frameskipRadio_buf, "%d", i);
if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf);
else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf);
g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
mGraphics = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Graphics");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics);
gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
// TODO: Un jour, peut être... ><
mSize = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Size");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize);
gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
for(i = 1; i < MAX_SCREENCOEFF; i++) {
char sizeRadio_buf[16];
sprintf(sizeRadio_buf, "x%d", i);
if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf);
else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf);
g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
mLayers = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Layers");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers);
gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
for(i = 0; i < 10; i++) {
mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]);
g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]);
gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE);
}
/** Menu "Options" **/
GtkWidget *mConfig = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Config");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("Edit controls");
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
#if 0
GtkWidget *mFirmware;
mFirmware = gtk_menu_new();
pMenuItem = gtk_menu_item_new_with_label("Firmware");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware);
gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("Select...");
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0);
gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("Config");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
#endif
/** Menu "Outils" **/
pMenu = gtk_menu_new();
for(i = 0; i < dTools_list_size; i++)
{
pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name);
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
}
pMenuItem = gtk_menu_item_new_with_label("Tools");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
/** Menu "?" **/
pMenu = gtk_menu_new();
#if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6))
pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
#else
pMenuItem = gtk_menu_item_new_with_label("About");
#endif
g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
pMenuItem = gtk_menu_item_new_with_label("?");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
/* Ajout du menu a la fenetre */
gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);
/* Création de la Toolbar */
pToolbar = gtk_toolbar_new();
gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1);
gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1);
/* Création de l'endroit pour l'affichage des écrans */
pDrawingArea= gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384);
gtk_widget_set_usize (pDrawingArea, 256, 384);
gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK );
g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL);
g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL);
g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL);
g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ;
g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ;
gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0);
/* Création de la barre d'état */
pStatusBar = gtk_statusbar_new();
pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global");
pStatusBar_Change("Desmume");
gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0);
gtk_widget_show_all(pWindow);
//LoadFirmware("fw.bin");
/* Vérifie la ligne de commandes */
if(commandLine_File)
{
if(Open(commandLine_File) >= 0)
{
Launch();
}
else
{
GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow),
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"Unable to load :\n%s", commandLine_File);
gtk_dialog_run(GTK_DIALOG(pDialog));
gtk_widget_destroy(pDialog);
}
}
/* Boucle principale */
// gtk_idle_add(&EmuLoop, pWindow);
// g_idle_add(&EmuLoop, pWindow);
gtk_main();
desmume_free();
#ifdef DEBUG
LogStop();
#endif
SDL_Quit();
Write_ConfigFile();
return EXIT_SUCCESS;
}
static GtkWidget *create_dialog(void)
{
GtkWidget *dialog;
GtkWidget *header_image;
GtkWidget *header_label;
GtkWidget *label_info;
GtkWidget *codename_label;
GtkWidget *builddate_label;
GtkWidget *url_button;
GtkWidget *cop_label;
GtkWidget *label;
GtkWidget *license_textview;
GtkWidget *notebook;
GtkWidget *box;
GtkWidget *credits_scrollwin;
GtkWidget *table;
GtkWidget *license_scrollwin;
GtkWidget *info_box;
GtkWidget *header_hbox;
GtkWidget *header_eventbox;
GdkPixbuf *icon;
GtkTextBuffer* tb;
gchar *license_text = NULL;
gchar buffer[512];
gchar buffer2[128];
guint i, row = 0;
dialog = gtk_dialog_new();
/* configure dialog */
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);
/* create header */
header_eventbox = gtk_event_box_new();
gtk_widget_show(header_eventbox);
header_hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
gtk_widget_show(header_hbox);
gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
header_image = gtk_image_new();
gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
header_label = gtk_label_new(NULL);
gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
/* print the subversion revision generated by ./configure if it is available */
g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
gtk_label_set_markup(GTK_LABEL(header_label), buffer);
gtk_widget_show(header_label);
gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
header_eventbox_style_set(header_eventbox);
header_label_style_set(header_label);
g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);
/* set image */
icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
gtk_window_set_icon(GTK_WINDOW(dialog), icon);
g_object_unref(icon); /* free our reference */
/* create notebook */
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
/* create "Info" tab */
info_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
gtk_widget_show(info_box);
label_info = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
gtk_label_set_markup(GTK_LABEL(label_info), buffer);
gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);
/* Codename label */
codename_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
gtk_widget_show(codename_label);
gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);
/* build date label */
builddate_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
gtk_widget_show(builddate_label);
gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);
box = gtk_hbutton_box_new();
url_button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(url_button), label);
gtk_widget_show(url_button);
gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);
/* copyright label */
cop_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
gtk_widget_show(cop_label);
gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */
label = gtk_label_new(_("Info"));
gtk_widget_show(label);
gtk_widget_show_all(info_box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);
/* create "Credits" tab */
credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
row = 0;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < translators_len; i++)
{
ROW(translators[i][0], row, 0, 1, 4, 0);
ROW(translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < prev_translators_len; i++)
{
ROW(prev_translators[i][0], row, 0, 1, 4, 0);
ROW(prev_translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
g_snprintf(buffer, sizeof(buffer),
_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
"Thanks.txt"
#else
"THANKS"
#endif
);
label = geany_wrap_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
label = geany_wrap_label_new(contributors);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
gtk_widget_show_all(table);
label = gtk_label_new(_("Credits"));
gtk_widget_show(label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);
/* create "License" tab */
license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN);
license_textview = gtk_text_view_new();
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_widget_show(license_textview);
gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
label = gtk_label_new(_("License"));
gtk_widget_show(label);
g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);
g_file_get_contents(buffer, &license_text, NULL, NULL);
if (license_text == NULL)
{
license_text = g_strdup(
_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
}
tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
gtk_text_buffer_set_text(tb, license_text, -1);
g_free(license_text);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);
gtk_widget_show_all(dialog);
return dialog;
}
void gcb_main()
{
GtkWidget *hbox,*vbox;
int i;
#if 1
if (gcb_enabled==old_gcb_enabled && gcb_position==old_gcb_position && gcb_position_x==old_gcb_position_x
&& gcb_position_y==old_gcb_position_y)
return;
#endif
old_gcb_enabled = gcb_enabled;
old_gcb_position = gcb_position;
old_gcb_position_x = gcb_position_x;
old_gcb_position_y = gcb_position_y;
if (mainwin) {
gtk_widget_destroy(mainwin);
mainwin = NULL;
}
#if 0
if (button_bar_tips)
gtk_widget_destroy(button_bar_tips);
#endif
if (hist_window) {
gtk_widget_destroy(hist_window);
hist_window = NULL;
}
if (!gcb_enabled)
return;
// printf("gcb_position:%d\n", gcb_position);
static char geo[][2]={{0,0},{'+','-'},{'+','+'},{'-','-'},{'-','+'}};
g_free(geomstr);
geomstr = g_strdup_printf("%c%d%c%d",
geo[gcb_position][0], gcb_position_x, geo[gcb_position][1], gcb_position_y);
dbg("geomstr %s\n", geomstr);
if (!buttonArr) {
buttonArr=(GtkWidget**)g_malloc(gcb_button_n * sizeof(GtkWidget *));
buttonStr=(gchar**)g_malloc0(gcb_button_n * sizeof(gchar *));
}
if (!hist_strArr) {
hist_strArr=(gchar**)g_malloc0(gcb_history_n * sizeof(gchar *));
hist_buttonArr=(GtkWidget**)g_malloc(gcb_history_n * sizeof(GtkWidget *));
}
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE);
gtk_window_set_decorated(GTK_WINDOW(mainwin),FALSE);
gtk_window_set_focus_on_map (GTK_WINDOW(mainwin), FALSE);
hist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(hist_window), FALSE);
char icon_path[40];
sys_icon_fname("gcb.png", icon_path);
GtkWidget *win_icon=gtk_image_new_from_file(icon_path);
gtk_window_set_icon(GTK_WINDOW(mainwin),
gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
gtk_window_set_icon(GTK_WINDOW(hist_window),
gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
// Under gnome 2.0, the mainwin is not fixed if decorated, annoying
gtk_window_set_decorated(GTK_WINDOW(hist_window),FALSE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(hist_window),TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(hist_window),TRUE);
gtk_window_set_title (GTK_WINDOW (hist_window),"gcb history");
gtk_window_set_title (GTK_WINDOW(mainwin), "gcb: gtk copy-paste buffer");
gtk_window_stick(GTK_WINDOW(mainwin));
// g_signal_connect(G_OBJECT (mainwin),"destroy", G_CALLBACK (do_exit), NULL);
g_signal_connect(G_OBJECT (hist_window),"delete_event",
G_CALLBACK (delete_hist_win), NULL);
g_signal_connect(G_OBJECT (hist_window),"focus-out-event",
G_CALLBACK (hist_focus_out_callback), NULL);
#if !GTK_CHECK_VERSION(2,12,0)
button_bar_tips = gtk_tooltips_new ();
#endif
hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER(mainwin), hbox);
gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
for(i=0;i<gcb_button_n;i++) {
buttonArr[i] = gtk_button_new_with_label ("---");
// gtk_container_set_border_width(GTK_CONTAINER(buttonArr[i]),0);
gtk_box_pack_start (GTK_BOX(hbox), buttonArr[i], TRUE, TRUE, FALSE);
gtk_widget_show (buttonArr[i]);
g_signal_connect (G_OBJECT (buttonArr[i]), "button-press-event",
G_CALLBACK (get_mouse_button), (gpointer) buttonArr[i]);
#if 0
g_signal_connect (G_OBJECT (buttonArr[i]), "key-press-event",
G_CALLBACK (key_press_event), NULL);
#endif
#if 1
g_signal_connect (G_OBJECT (buttonArr[i]), "scroll-event",
G_CALLBACK (gcb_button_scroll_event), NULL);
#endif
}
vbox = gtk_vbox_new (FALSE, 1);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER(hist_window), vbox);
for(i=0;i<gcb_history_n;i++) {
hist_buttonArr[i] = gtk_button_new_with_label ("---");
gtk_container_set_border_width(GTK_CONTAINER(hist_buttonArr[i]),0);
gtk_box_pack_start (GTK_BOX(vbox), hist_buttonArr[i], TRUE, TRUE, FALSE);
gtk_widget_show (hist_buttonArr[i]);
g_signal_connect (G_OBJECT (hist_buttonArr[i]), "button-press-event",
G_CALLBACK (hist_get_mouse_button), (gpointer) hist_buttonArr[i]);
#if 1
g_signal_connect (G_OBJECT (hist_buttonArr[i]), "key-press-event",
G_CALLBACK (hist_key_press_event), NULL);
#endif
}
#if 1
// need this because on win32 scoll is not recieved if win is not focused.
gtk_box_pack_start (GTK_BOX (hbox), gtk_vseparator_new(), FALSE, FALSE, 0);
GtkWidget *eve_arrow = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(eve_arrow), FALSE);
gtk_box_pack_start (GTK_BOX(hbox), eve_arrow, FALSE, FALSE, FALSE);
g_signal_connect(G_OBJECT(eve_arrow),"button-press-event", G_CALLBACK(mouse_button_callback), NULL);
gtk_container_add(GTK_CONTAINER(eve_arrow), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN));
#endif
gtk_widget_show_all(hbox);
gtk_widget_show (vbox);
gtk_widget_show (mainwin);
pclipboard_prim = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
set_snoop_button(buttonArr[0]);
get_selection(pclipboard);
get_selection(pclipboard_prim);
gtk_container_set_border_width(GTK_CONTAINER(hbox),0);
gtk_container_set_border_width(GTK_CONTAINER(mainwin),0);
gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
#if GTK_CHECK_VERSION(2,6,0)
g_signal_connect(pclipboard, "owner-change", G_CALLBACK (cb_owner_change), NULL);
g_signal_connect(pclipboard_prim, "owner-change", G_CALLBACK (cb_owner_change), NULL);
#endif
}
int main(int argc, char *argv[])
{
GtkWidget *exp, *vbox1, *vbox, *hbox;
gint kateuth = 0;
i = 0;
gtk_init (&argc, &argv);
kateuth = epilogiKate();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
// gtk_window_set_icon (GTK_WINDOW(main_window), gdk_pixbuf_new_from_xpm_data((const char **) pixmap));
gtk_window_set_icon (GTK_WINDOW(main_window), gdk_pixbuf_new_from_xpm_data((const char **) icon()));
gtk_window_set_title (GTK_WINDOW (main_window), "Βαθμός πτυχίου!");
gtk_window_set_default_size (GTK_WINDOW (main_window), (gint) 700, (gint) 300);
gtk_window_set_position (GTK_WINDOW (main_window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW (main_window), FALSE);
g_signal_connect (G_OBJECT (main_window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (main_window), 10);
vbox = gtk_vbox_new (FALSE, 5);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX(hbox), gtk_label_new("Κωδικός"), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(hbox), gtk_label_new("Όνομα μαθήματος"), FALSE, FALSE, 5);
gtk_box_pack_end (GTK_BOX(hbox), gtk_label_new("Δ.Μ."), FALSE, FALSE, 5);
gtk_box_pack_end (GTK_BOX(hbox), gtk_label_new("Βαθμός"), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
/* PROTO EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("1o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
addLesson("Μαθηματική ανάλυση I", 0, "5", "[120]", vbox1);
addLesson("Φυσική", 0, "5", "[121]", vbox1);
addLesson("Προγραμματισμός I", 0, "5", "[122]", vbox1);
addLesson("Αρχές Τηλεπικοινωνιών", 0, "5", "[123]", vbox1);
addLesson("Ηλεκτρονικά", 0, "5", "[124]", vbox1);
addLesson("Διακριτά συστήματα", 0, "5", "[125]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
/* DEYTERO EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("2o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
addLesson("Μαθηματική ανάλυση II", 0, "5", "[220]", vbox1);
addLesson("Φυσικές Αρχές Τεχνολογίας Επικοινωνιών", 0, "6", "[221]", vbox1);
addLesson("Αρχιτεκτονική Η/Υ I", 0, "5", "[223]", vbox1);
addLesson("Ηλεκτρονικές Τηλεπικοινωνίες", 0, "5", "[224]", vbox1);
addLesson("Αριθμητική ανάλυση", 0, "5", "[225]", vbox1);
addLesson("Προγραμματισμός II", 0, "5", "[226]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
/* TRITO EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("3o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
addLesson("Βάσεις δεδομένων I", 0, "5", "[320]", vbox1);
addLesson("Δομές δεδομένων και αλγόριθμοι", 0, "5", "[321]", vbox1);
addLesson("Θεωρία πιθανοτήτων και στατιστική", 0, "5", "[322]", vbox1);
addLesson("Δίκτυα I", 0, "5", "[323]", vbox1);
addLesson("Λειτουργικά συστήματα I", 0, "5", "[324]", vbox1);
addLesson("Εφαρμογές γραμμική άλγεβρας", 0, "5", "[325]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
/* TETARTO EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("4o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
addLesson("Αλγόριθμοι και πολυπλοκότητα", 0, "5", "[421]", vbox1);
addLesson("Αρχιτεκτονική II", 0, "5", "[422]", vbox1);
addLesson("Ανάλυση και σχεδιασμός Π.Σ.", 0, "5", "[425]", vbox1);
addLesson("Θεωρία συστημάτων - ΣΑΕ", 0, "5", "[426]", vbox1);
addLesson("Δίκτυα II", 0, "5", "[427]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_hseparator_new(), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
addLesson("Υπολογισιμότητα", 1, "5", "[423]", vbox1);
addLesson("Αρχές γλωσσών προγραμματισμού", 1, "5", "[424]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
/* PEMPTO EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("5o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
addLesson("Οικονομικά των επιχειρήσεων", 0, "5", "[920]", vbox1);
if (kateuth == 0) {
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση πληροφορικής"), FALSE, FALSE, 5);
addLesson("Προγραμματισμός III", 0, "7", "[531Π]", vbox1);
addLesson("Τεχνολογία λογισμικού", 0, "7", "[532Π]", vbox1);
addLesson("Βάσεις δεδομένων II", 0, "6", "[533Π]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
addLesson("Λογικός προγραμματισμός", 1, "5", "[534Π]", vbox1);
addLesson("Οργάνωση και διαχείριση αρχείων ", 1, "5", "[535Π]", vbox1);
} else {
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση τηλεπικοινωνιών και δικτύων"), FALSE, FALSE, 5);
addLesson("Επεξεργασία σήματος", 0, "7", "[541Τ]", vbox1);
addLesson("Τηλεπικοινωνιακά συστήματα I", 0, "7", "[542Τ]", vbox1);
addLesson("Οπτικές επικοινωνίες", 0, "6", "[543Τ]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
addLesson("Κινητές επικοινωνίες", 1, "5", "[544Τ]", vbox1);
addLesson("Σχεδίαση, μελέτη και υλοποίηση δικτύων", 1, "5", "[545Τ]", vbox1);
}
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
/* ΕΚΤΟ EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("6o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("ΔΟΝΑ"), FALSE, FALSE, 5);
addLesson("Τεχνική νομοθεσία", 0, "5", "[921]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
addLesson("Επιχειρησιακή έρευνα", 1, "5", "[930]", vbox1);
addLesson("Διαχείριση έργων πληροφορικής", 1, "5", "[931]", vbox1);
if (kateuth == 0) {
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση πληροφορικής (4 από τα 6)"), FALSE, FALSE, 5);
addLesson("Τεχνητή νοημοσύνη", 1, "5", "[631Π]", vbox1);
addLesson("Προχωρημένες εφαρμογές προγραμματισμού", 1, "5", "[632Π]", vbox1);
addLesson("Πολυμέσα", 1, "5", "[633Π]", vbox1);
addLesson("Λειτουργικά συστήματα II", 1, "5", "[634Π]", vbox1);
addLesson("Δικτυακός προγραμματισμός", 1, "5", "[655]", vbox1);
addLesson("Ασφάλεια πληροφοριακών συστημάτων", 1, "5", "[656]", vbox1);
} else {
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση τηλεπικοινωνιών και δικτύων (4 από τα 6)"), FALSE, FALSE, 5);
addLesson("Επικοινωνίες δεδομένων", 1, "5", "[641Τ]", vbox1);
addLesson("Τηλεπικοινωνιακά συστήματα II", 1, "5", "[642Τ]", vbox1);
addLesson("Ειδικά θέματα οπτικών επικοινωνιών", 1, "5", "[643Τ]", vbox1);
addLesson("Ασύρματες επικοινωνίες", 1, "5", "[644Τ]", vbox1);
addLesson("Δικτυακός προγραμματισμός", 1, "5", "[655]", vbox1);
addLesson("Ασφάλεια πληροφοριακών συστημάτων", 1, "5", "[656]", vbox1);
}
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
/* EBDOMO EKSAMINO */
vbox1 = gtk_vbox_new (FALSE, 5);
exp = addTitle("7o εξάμηνο");
gtk_container_add (GTK_CONTAINER (exp), vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("ΔΟΝΑ (1 από τα 2)"), FALSE, FALSE, 5);
addLesson("Μάρκετινγκ πληροφοριακών συστημάτων", 1, "3", "[922]", vbox1);
addLesson("Διδακτική της πληροφορικής", 1, "3", "[923]", vbox1);
if (kateuth == 0) {
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση πληροφορικής"), FALSE, FALSE, 5);
addLesson("Σεμινάριο θεμάτων τεχνολογικής αιχμής", 0, "6", "[731Π]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("3 από τα 6"), FALSE, FALSE, 5);
addLesson("Ειδικά θέματα βάσεων δεδομένων", 1, "7", "[732Π]", vbox1);
addLesson("Ηλεκτρονικό εμπόριο", 1, "7", "[733Π]", vbox1);
addLesson("Προγραμματισμός Ιντερνετ", 1, "7", "[734Π]", vbox1);
addLesson("Υπολογιστικό πλέγμα", 1, "7", "[735Π]", vbox1);
addLesson("Μεταγλωττιστές", 1, "7", "[736Π]", vbox1);
addLesson("Κατανεμημένα συστήματα", 1, "7", "[757]", vbox1);
} else {
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση τηλεπικοινωνιών και δικτύων"), FALSE, FALSE, 5);
addLesson("Σεμινάριο θεμάτων τεχνολογικής αιχμής", 0, "6", "[741Τ]", vbox1);
gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("3 από τα 6"), FALSE, FALSE, 5);
addLesson("Δορυφορικές επικοινωνίες", 1, "7", "[742Τ]", vbox1);
addLesson("CDMA", 1, "7", "[743Τ]", vbox1);
addLesson("Δικτύωση και αυτοματοποίηση", 1, "7", "[744Τ]", vbox1);
addLesson("Ευρυζωνικά δίκτυα", 1, "7", "[745Τ]", vbox1);
addLesson("Απόδοση δικτύων", 1, "7", "[746Τ]", vbox1);
addLesson("Κατανεμημένα συστήματα", 1, "7", "[757]", vbox1);
}
gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
addLesson("Πτυχιακή εργασία", 0, "20", "[801]", vbox);
gtk_box_pack_start (GTK_BOX(vbox), addButtons(), FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (main_window), vbox);
gtk_widget_show_all (main_window);
gtk_main ();
return 0;
}
void
gtkutil_set_icon (GtkWidget *win)
{
gtk_window_set_icon (GTK_WINDOW (win), pix_xchat);
}
int main(int argc,char** argv) {
GtkWidget *window;
GtkWidget *halign;
GtkWidget *valign;
GdkPixbuf *icon;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button_md5;
GtkWidget *button_sha1;
GtkWidget *button_sha256;
struct EntryStruct entry;
//GtkWidget *entry_context;
//GtkWidget *hash_context;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"Hash from s2n libaray");
gtk_window_set_default_size(GTK_WINDOW(window),260,150);
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window),15);
icon = create_pixbuf("hash_icon.png");
gtk_window_set_icon(GTK_WINDOW(window),icon);
entry.input = gtk_entry_new();
entry.hash = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(entry.hash),false);
vbox = gtk_vbox_new(FALSE,5);
valign = gtk_alignment_new(0,1,0,0);
gtk_container_add(GTK_CONTAINER(vbox),valign);
gtk_container_add(GTK_CONTAINER(vbox),entry.input);
gtk_container_add(GTK_CONTAINER(vbox),entry.hash);
gtk_container_add(GTK_CONTAINER(window),vbox);
hbox = gtk_hbox_new(true,3);
button_md5 = gtk_button_new_with_label("MD5 hash");
button_sha1 = gtk_button_new_with_label("SHA-1 hash");
button_sha256 = gtk_button_new_with_label("SHA-256 hash");
//button =gtk_button_new_with_mnemonic("_Button");
g_signal_connect(G_OBJECT(button_md5),"clicked",G_CALLBACK(button_md5_clicked),&entry);
g_signal_connect(G_OBJECT(button_sha1),"clicked",G_CALLBACK(button_sha1_clicked),NULL);
g_signal_connect(G_OBJECT(button_sha256),"clicked",G_CALLBACK(button_sha256_clicked),NULL);
gtk_widget_set_tooltip_text(button_md5,"calcutate the MD5 disget of the text");
gtk_widget_set_tooltip_text(button_sha1,"calculate the SHA1 digest of the text");
gtk_widget_set_tooltip_text(button_sha256,"calculate the SHA-256 digest of the text");
//gtk_box_pack_start(GTK_BOX(vbox),button_md5,TRUE,TRUE,0);
//gtk_box_pack_start(GTK_BOX(vbox),button_sha1,TRUE,TRUE,0);
gtk_container_add(GTK_CONTAINER(hbox),button_md5);
gtk_container_add(GTK_CONTAINER(hbox),button_sha1);
gtk_container_add(GTK_CONTAINER(hbox),button_sha256);
halign = gtk_alignment_new(0,1,0,0);
gtk_container_add(GTK_CONTAINER(halign),hbox);
gtk_container_add(GTK_CONTAINER(vbox),halign);
gtk_box_pack_start(GTK_BOX(vbox),halign,FALSE,FALSE,0);
gtk_widget_show_all(window);
g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
gtk_main();
g_object_unref(icon);
return 0;
}
