int main( int argc,
char *argv[] )
{
GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "delete-event",
G_CALLBACK (close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_radio_button_new_with_label (NULL, "button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
button = gtk_radio_button_new_with_label (group, "button2");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button),
"button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (close_application),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
int main (int argc, char *argv[])
{
GtkWidget *button = NULL;
GtkWidget *win = NULL;
GtkWidget *hbox = NULL;
GtkWidget * Image;
/* Initialize GTK+ */
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
/* Create the main window */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (win), 0);
gtk_window_set_title (GTK_WINDOW (win), "FakeMaximus");
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request(win, 1024, 32);
gtk_window_set_resizable (GTK_WINDOW(win), FALSE);
gtk_widget_realize (win);
g_signal_connect (win, "destroy", gtk_main_quit, NULL);
/* Create a horizontal box */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (win), hbox);
Maximus.hvbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), Maximus.hvbox, TRUE, TRUE, 0);
/* Widget for windows icom list */
Maximus.IconList = NULL;
Maximus.hIconBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (Maximus.hIconBox);
gtk_box_pack_start (GTK_BOX (Maximus.hvbox), Maximus.hIconBox, FALSE, FALSE, 0);
/* 2- Widget window title bar */
Maximus.WinTitle = gtk_label_new ("Maximus");
gtk_widget_show (Maximus.WinTitle);
gtk_box_pack_start (GTK_BOX (Maximus.hvbox), Maximus.WinTitle, FALSE, FALSE, 0);
Maximus.CloseEvtBox = gtk_event_box_new ();
gtk_box_pack_end(GTK_BOX (Maximus.hvbox), Maximus.CloseEvtBox, FALSE, FALSE, 0);
Image = gtk_image_new_from_stock( GTK_STOCK_CLOSE, GTK_ICON_SIZE_SMALL_TOOLBAR );
//gtk_container_add(GTK_CONTAINER (maximus->hIconBox), pIcon->Image);
gtk_container_add (GTK_CONTAINER (Maximus.CloseEvtBox), Image);
gtk_widget_show (Maximus.CloseEvtBox);
g_signal_connect(G_OBJECT(Maximus.CloseEvtBox), "button_press_event", G_CALLBACK(mxs_OnClickedCloseWindow), (gpointer)&Maximus);
Maximus.ActiveScreen = wnck_screen_get_default();
wnck_screen_force_update(Maximus.ActiveScreen);
button = gtk_button_new_from_stock (GTK_STOCK_NEW);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (SimNewWin), (gpointer)&Maximus);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
{
extern void on_mxs_window_closed(WnckScreen *screen, WnckWindow *window, MaximusPlugin *maximus);
/* Want to be notified if window closed */
g_signal_connect(Maximus.ActiveScreen, "window-closed", G_CALLBACK (on_mxs_window_closed), (gpointer)&Maximus);
}
/* Enter the main loop */
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
int
main (int argc, char *argv[])
{
struct sigaction sig_callback;
gtk_init (&argc, &argv);
bindtextdomain (GETTEXT_PACKAGE, SNES9XLOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
memset (&Settings, 0, sizeof (Settings));
/* Allow original config file for backend settings */
S9xLoadConfigFiles (argv, argc);
/* Perform our config here */
gui_config = new Snes9xConfig ();
S9xInitInputDevices ();
gui_config->load_config_file ();
char *rom_filename = S9xParseArgs (argv, argc);
S9xReportControllers ();
if (!Memory.Init () || !S9xInitAPU ())
exit (3);
g_set_application_name ("Snes9x");
top_level = new Snes9xWindow (gui_config);
/* If we're going to fullscreen, do it before showing window to avoid flicker. */
if ((gui_config->full_screen_on_open && rom_filename) || (gui_config->fullscreen))
gtk_window_fullscreen (top_level->get_window ());
top_level->show ();
S9xInitDisplay (argc, argv);
Memory.PostRomInitFunc = S9xPostRomInit;
S9xPortSoundInit ();
gui_config->reconfigure ();
top_level->update_accels ();
Settings.Paused = TRUE;
syncing = 0;
idle_func_id = g_idle_add_full (IDLE_FUNC_PRIORITY,
S9xIdleFunc,
NULL,
NULL);
g_timeout_add (10000, S9xScreenSaverCheckFunc, NULL);
S9xNoROMLoaded ();
if (rom_filename)
{
if (S9xOpenROM (rom_filename) && gui_config->full_screen_on_open)
gtk_window_unfullscreen (top_level->get_window());
}
memset (&sig_callback, 0, sizeof (struct sigaction));
sig_callback.sa_handler = S9xTerm;
sigaction (15 /* SIGTERM */, &sig_callback, NULL);
sigaction (3 /* SIGQUIT */, &sig_callback, NULL);
sigaction (2 /* SIGINT */, &sig_callback, NULL);
if (gui_config->fullscreen)
{
gui_config->fullscreen = 0;
needs_fullscreening = 1;
}
#ifdef USE_JOYSTICK
gui_config->flush_joysticks ();
#endif
gtk_window_present (top_level->get_window ());
if (rom_filename && *Settings.InitialSnapshotFilename)
S9xUnfreezeGame(Settings.InitialSnapshotFilename);
gtk_main ();
return 0;
}
int main (int argc,
char *argv[])
{
GtkWidget *assistant, *entry, *label, *button, *progress, *hbox;
guint i;
PageInfo page[5] = {
{ NULL, -1, "Introduction", GTK_ASSISTANT_PAGE_INTRO, TRUE},
{ NULL, -1, NULL, GTK_ASSISTANT_PAGE_CONTENT, FALSE},
{ NULL, -1, "Click the Check Button", GTK_ASSISTANT_PAGE_CONTENT, FALSE},
{ NULL, -1, "Click the Button", GTK_ASSISTANT_PAGE_PROGRESS, FALSE},
{ NULL, -1, "Confirmation", GTK_ASSISTANT_PAGE_CONFIRM, TRUE},
};
gtk_init (&argc, &argv);
/* Create a new assistant widget with no pages. */
assistant = gtk_assistant_new ();
gtk_widget_set_size_request (assistant, 450, 300);
gtk_window_set_title (GTK_WINDOW (assistant), "GtkAssistant Example");
g_signal_connect (G_OBJECT (assistant), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
page[0].widget = gtk_label_new ("This is an example of a GtkAssistant. By\n"\
"clicking the forward button, you can continue\n"\
"to the next section!");
page[1].widget = gtk_hbox_new (FALSE, 5);
page[2].widget = gtk_check_button_new_with_label ("Click Me To Continue!");
page[3].widget = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
page[4].widget = gtk_label_new ("Text has been entered in the label and the\n"\
"combo box is clicked. If you are done, then\n"\
"it is time to leave!");
/* Create the necessary widgets for the second page. */
label = gtk_label_new ("Your Name: ");
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (page[1].widget), label, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (page[1].widget), entry, FALSE, FALSE, 5);
/* Create the necessary widgets for the fourth page. The, Attach the progress bar
* to the GtkAlignment widget for later access.*/
button = gtk_button_new_with_label ("Click me!");
progress = gtk_progress_bar_new ();
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), progress, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (page[3].widget), hbox);
g_object_set_data (G_OBJECT (page[3].widget), "pbar", (gpointer) progress);
/* Add five pages to the GtkAssistant dialog. */
for (i = 0; i < 5; i++)
{
page[i].index = gtk_assistant_append_page (GTK_ASSISTANT (assistant),
page[i].widget);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant),
page[i].widget, page[i].title);
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant),
page[i].widget, page[i].type);
/* Set the introduction and conclusion pages as complete so they can be
* incremented or closed. */
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant),
page[i].widget, page[i].complete);
}
/* Update whether pages 2 through 4 are complete based upon whether there is
* text in the GtkEntry, the check button is active, or the progress bar
* is completely filled. */
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (entry_changed), (gpointer) assistant);
g_signal_connect (G_OBJECT (page[2].widget), "toggled",
G_CALLBACK (button_toggled), (gpointer) assistant);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (button_clicked), (gpointer) assistant);
g_signal_connect (G_OBJECT (assistant), "cancel",
G_CALLBACK (assistant_cancel), NULL);
g_signal_connect (G_OBJECT (assistant), "close",
G_CALLBACK (assistant_close), NULL);
gtk_widget_show_all (assistant);
gtk_main ();
return 0;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *hbox, *vbox;
GtkWidget *vbox2, *bbox;
GtkWidget *button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *swindow;
GtkTreeModel *sample_model;
gint i;
gtk_init (&argc, &argv);
/* First initialize all the models for signal purposes */
left_tree_model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
sample_model = (GtkTreeModel *) gtk_list_store_new (1, G_TYPE_STRING);
sample_tree_view_top = gtk_tree_view_new_with_model (sample_model);
sample_tree_view_bottom = gtk_tree_view_new_with_model (sample_model);
top_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_top));
bottom_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_bottom));
top_right_tree_view = gtk_tree_view_new_with_model (top_right_tree_model);
bottom_right_tree_view = gtk_tree_view_new_with_model (bottom_right_tree_model);
for (i = 0; i < 10; i++)
{
GtkTreeIter iter;
gchar *string = g_strdup_printf ("%d", i);
gtk_list_store_append (GTK_LIST_STORE (sample_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (sample_model), &iter, 0, string, -1);
g_free (string);
}
/* Set up the test windows. */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_window_set_title (GTK_WINDOW (window), "Top Window");
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_top);
gtk_widget_show_all (window);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_window_set_title (GTK_WINDOW (window), "Bottom Window");
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_bottom);
gtk_widget_show_all (window);
/* Set up the main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 500, 300);
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* Left Pane */
cell = gtk_cell_renderer_text_new ();
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
left_tree_view = gtk_tree_view_new_with_model (left_tree_model);
gtk_container_add (GTK_CONTAINER (swindow), left_tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (left_tree_view), -1,
"Unattached Columns", cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), left_tree_view);
column = gtk_tree_view_column_new_with_attributes ("Visible", cell, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0);
/* Middle Pane */
vbox2 = gtk_vbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
bbox = gtk_vbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("<< (_Q)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic (">> (_W)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
bbox = gtk_vbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("<< (_E)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic (">> (_R)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
/* Right Pane */
vbox2 = gtk_vbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (top_right_tree_view), FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (top_right_tree_view), -1,
NULL, cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), top_right_tree_view);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column);
gtk_container_add (GTK_CONTAINER (swindow), top_right_tree_view);
gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (bottom_right_tree_view), FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (bottom_right_tree_view), -1,
NULL, cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), bottom_right_tree_view);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column);
gtk_container_add (GTK_CONTAINER (swindow), bottom_right_tree_view);
gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0);
/* Drag and Drop */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (left_tree_view),
GDK_BUTTON1_MASK,
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (left_tree_view),
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (top_right_tree_view),
GDK_BUTTON1_MASK,
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (top_right_tree_view),
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (bottom_right_tree_view),
GDK_BUTTON1_MASK,
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (bottom_right_tree_view),
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("_Add new Column");
g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkToolkit_gtkInit (JNIEnv *env,
jclass clazz __attribute__((unused)),
jint portableNativeSync)
{
int argc = 1;
char **argv;
char *homedir, *rcpath = NULL;
gtkgenericpeer = (*env)->FindClass(env, "gnu/java/awt/peer/gtk/GtkGenericPeer");
gtkgenericpeer = (*env)->NewGlobalRef(env, gtkgenericpeer);
printCurrentThreadID = (*env)->GetStaticMethodID (env, gtkgenericpeer,
"printCurrentThread", "()V");
NSA_INIT (env, gtkgenericpeer);
g_assert((*env)->GetJavaVM(env, &java_vm) == 0);
/* GTK requires a program's argc and argv variables, and requires that they
be valid. Set it up. */
argv = (char **) g_malloc (sizeof (char *) * 2);
argv[0] = (char *) g_malloc(1);
argv[0][0] = '\0';
argv[1] = NULL;
init_glib_threads(env, portableNativeSync);
/* From GDK 2.0 onwards we have to explicitly call gdk_threads_init */
gdk_threads_init();
gtk_init (&argc, &argv);
#if SYNCHRONIZE_GDK
XSynchronize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), True);
#endif
gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
/* Make sure queued calls don't get sent to GTK/GDK while
we're shutting down. */
atexit (gdk_threads_enter);
if ((homedir = getenv ("HOME")))
{
rcpath = (char *) g_malloc (strlen (homedir) + strlen (RC_FILE) + 2);
sprintf (rcpath, "%s/%s", homedir, RC_FILE);
}
gtk_rc_parse ((rcpath) ? rcpath : RC_FILE);
g_free (rcpath);
g_free (argv[0]);
g_free (argv);
/* On errors or warning print a whole stacktrace. */
#if GTK_MINOR_VERSION > 4
old_glog_func = g_log_set_default_handler (&glog_func, NULL);
#endif
cp_gtk_button_init_jni ();
cp_gtk_checkbox_init_jni ();
cp_gtk_choice_init_jni ();
cp_gtk_component_init_jni ();
cp_gtk_filedialog_init_jni ();
cp_gtk_list_init_jni ();
cp_gtk_menuitem_init_jni ();
cp_gtk_scrollbar_init_jni ();
cp_gtk_textcomponent_init_jni ();
cp_gtk_window_init_jni ();
cp_gtk_global_window_group = gtk_window_group_new ();
init_dpi_conversion_factor ();
}
int main(int argc, char **argv)
{
BrailleMusicEditor *editor;
// allocate the memory needed by our BrailleMusicEditor struct
editor = g_slice_new (BrailleMusicEditor);
//initialize GTK+ libraries
gtk_init(&argc, &argv);
ev_init();
// Creation of the main window
create_window("BMC",600,400, editor);
editor->vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(editor->window), editor->vbox);
//Creation of the menubar
create_menubar(editor);
gtk_box_pack_start(GTK_BOX(editor->vbox), editor->menubar, FALSE, FALSE, 0);
// Creation of the toolbar
create_toolbar(editor);
gtk_box_pack_start(GTK_BOX(editor->vbox), editor->toolbar, FALSE, FALSE, 2);
//Creation of the two text views with scrollbars
editor->hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(editor->vbox), editor->hbox);
editor->edit_scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(editor->edit_scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(editor->hbox),editor->edit_scrollbar, TRUE, TRUE, 5);
editor->textview=gtk_source_view_new();
//show line number
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(editor->textview), TRUE);
g_signal_connect(gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview)), "changed", G_CALLBACK(on_text_changed), editor);
gtk_container_add(GTK_CONTAINER(editor->edit_scrollbar), editor->textview);
//lexical coloration auto update
g_signal_connect(gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview)), "changed", G_CALLBACK(coloration_update), editor);
//score view
editor->score_scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(editor->hbox),editor->score_scrollbar, TRUE, TRUE, 5);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(editor->score_scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
editor->score_view = ev_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(editor->score_scrollbar), editor->score_view);
show_score(editor);
gtk_widget_grab_focus(editor->textview);
//Creation of the message error views with scrollbar
editor->error_scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(editor->vbox),editor->error_scrollbar, FALSE, TRUE, 0);
gtk_widget_set_size_request (editor->error_scrollbar, -1, 100);
gtk_container_set_border_width(GTK_CONTAINER(editor->error_scrollbar), 5);
editor->error_view = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(editor->error_view), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(editor->error_scrollbar), editor->error_view);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(editor->error_scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// show the window
gtk_widget_show_all(editor->window);
// enter GTK+ main loop
gtk_main();
// free memory we allocated for BrailleMusicEditor struct
g_slice_free (BrailleMusicEditor, editor);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
double q1, q2, q3, q4, q5, q6, q7, q8, q9, qt;
gtk_init(&argc, &argv);
GtkBuilder *gtkbuilder;
GtkWidget *window, *spin, *prim, *window3;
GtkEntry *entry, *entry1, *entry2, *entry3, *entry4, *entry5, *entry6, *entry7, *entry8, *entry9, *entry10, *entry11, *entry12, *entry13, *entry14, *entry15, *entry16, *entry17, *entry18;
gtkbuilder = gtk_builder_new();
gtk_builder_add_from_file(gtkbuilder, "teste.xml", NULL);
window = GTK_WIDGET(gtk_builder_get_object(gtkbuilder, "window3"));
GtkSpinButton *spinbutton10 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton10");
//spinbutton10= gtk_spin_button_new ( NULL, 1 ,2);
entry = (GtkEntry*)gtk_builder_get_object(gtkbuilder, spinbutton10);
const char *entryText = gtk_entry_get_text(entry);
double v1 = atof(entryText);
q1= 100.8 * exp ( pow( (v1 + -106), 2 ) / -3745 );
GtkSpinButton *spinbutton11 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton11");
entry1 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton11);
const char *entryText1 = gtk_entry_get_text(entry1);
double v2 = atof(entryText1);
q2=98.24034 - 34.7145 * (log10(v2)) + 2.614267 *(pow(log10(v2), 2)) + 0.107821 * (pow(log10(v2), 3));
GtkSpinButton *spinbutton12 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton12");
entry2 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton12);
const char *entryText2 = gtk_entry_get_text(entry2);
double v3 = atof(entryText2);
if(v3<=2){
q3=1;
}
else if(v3>2 && v3<=6.9){
q3= -37.1085 +41.91277*v3 - 15.7043 * pow(v3, 2) + 2.417486 * pow(v3, 3) - 0.091252* pow(v3, 4);
}
else if(v3>6.9 && v3<=7.1){
q3 = -4.69365 - 21.4593*v3 - 68.4561* pow(v3, 2) + 21.638886*pow(v3, 3) - 1.59165* (v3, 4);
}
else if(v3> 7.1 && v3 <=12){
q3= -7698.19 + 3262.031 * v3 - 499.494 * pow(v3, 2) + 33.1551* pow(v3, 3) - 0.810613*pow(v3, 4);
}
else{
q3=3;
}
GtkSpinButton *spinbutton13 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton13");
entry3 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton13);
const char *entryText3 = gtk_entry_get_text(entry2);
double v4 = atof(entryText3);
if(v4>30){
q4=2;
}
else{
q4= 100.9571 - 10.7121 * v4 + 0.49544 * pow(v4, 2) - 0.011167 * pow(v4, 3) + 0.0001 * pow(v4, 4);
}
GtkSpinButton *spinbutton14 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton14");
entry4 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton14);
const char *entryText4 = gtk_entry_get_text(entry4);
double v5 = atof(entryText4);
if(v5<=10){
q5=-5.1*v5+100.17;
}
else if(v5>10 && v5<=60){
q5=-22.853*log(v5) + 101.18;
}
else if(v5>60 && v5<=90){
q5=10000000000*pow(v5, -5.1161);
}
else if(v5>90){
q5=1;
}
GtkSpinButton *spinbutton15 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton15");
entry5 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton15);
const char *entryText5 = gtk_entry_get_text(entry5);
double v6 = atof(entryText5);
if(v6>10){
q6=5;
}
else{
q6= 79.7*(pow(v6 + 0.821, -1.15));
}
GtkSpinButton *spinbutton16 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton16");
entry6 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton16);
const char *entryText6 = gtk_entry_get_text(entry6);
double v7 = atof(entryText6);
if(v7>100){
q7=5;
}
else{
q7=90.37* pow(2.7182818, (-0.0169 * v7)) - 15*cos((0.0571*(v7-30))) + 10,22* pow(2.718281828, (-0.231*v7)) -0.8;
}
GtkSpinButton *spinbutton17 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton17");
entry7 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton17);
const char *entryText7 = gtk_entry_get_text(entry7);
double v8 = atof(entryText7);
if(v8>500){
q8=30;
}
else{
q8= 133.17* (pow(2.7182818, (-0.0027 * v8))) -53.17* (pow(2.7182818 , (-0.0141 * v8))) + ((-6.2*(pow(2.7182818, (-0.00462*v8)))) *sin(0.0146*v8));
}
GtkSpinButton *spinbutton18 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton18");
entry8 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton18);
const char *entryText8 = gtk_entry_get_text(entry8);
double v9 = atof(entryText8);
if(v9>15){
q9=9;
}
else if(v9<=5){
q9=1;
}
else{
q9=1/(0.0003869*pow(v9 + 0.1815, 2) + 0.01081);
}
GtkSpinButton *spinbutton1 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton1");
entry9 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton1);
const char *entryText9 = gtk_entry_get_text(entry9);
double p1 = atof(entryText9);
GtkSpinButton *spinbutton2 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton2");
entry10 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton2);
const char *entryText10 = gtk_entry_get_text(entry10);
double p2 = atof(entryText10);
GtkSpinButton *spinbutton3 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton3");
entry11 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton3);
const char *entryText11 = gtk_entry_get_text(entry11);
double p3 = atof(entryText11);
GtkSpinButton *spinbutton4 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton4");
entry12 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton4);
const char *entryText12 = gtk_entry_get_text(entry12);
double p4 = atof(entryText12);
GtkSpinButton *spinbutton5 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton5");
entry13 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton5);
const char *entryText13 = gtk_entry_get_text(entry13);
double p5 = atof(entryText13);
GtkSpinButton *spinbutton6 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton6");
entry14 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton6);
const char *entryText14 = gtk_entry_get_text(entry14);
double p6 = atof(entryText14);
GtkSpinButton *spinbutton7 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton7");
entry15 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton7);
const char *entryText15 = gtk_entry_get_text(entry15);
double p7 = atof(entryText15);
GtkSpinButton *spinbutton8 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton8");
entry16 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton8);
const char *entryText16 = gtk_entry_get_text(entry16);
double p8 = atof(entryText16);
GtkSpinButton *spinbutton9 = (GtkSpinButton*) gtk_builder_get_object(gtkbuilder, "spinbutton9");
entry17 = (GtkEntry*) gtk_builder_get_object(gtkbuilder, spinbutton9);
const char *entryText17 = gtk_entry_get_text(entry17);
double p9 = atof(entryText17);
qt=( (v1*p1) + (v2*p2) + (v3*p3) + (v4*p4) + (v5*p5) + (v6*p6) + (v7*p7) + (v8*p8) + (v9*p9));
gtk_widget_show((GtkWidget*)window);
gtk_main();
return 0;
}
int main(int argc, char *argv[])
{
// GtkWidget é o tipo de armazenamento para os widgets //
GtkWidget *window;
GtkWidget *button;
// Esta função inicializa a biblioteca, seta os manipuladores de sinais padrões //
gtk_init(&argc,&argv);
// Cria uma nova janela
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/*
* Quando é dada para janela um sinal "delete_event" (fornecido pelo gerenciador de
* janela, geralmente por uma opção de "fechar", ou por uma opção do menu), nós
* fazemos uma chamada para a função delete_event() como está definido acima. O
* dado passado para a função neste caso é NULL e é ignorado dentro da função
* callback delete_event();
*/
g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete_event),NULL);
/*
* Aqui nós conectamos o evento "destroy" para o tratador de sinal. Este evento
* acontece quando nós chamamos a função gtk_widget_destroy() pela janela (clique
* para fechar a janela no canto direito superior) ou então se nós retornamos
* FALSE na chamada "delete_event";
*
* Será explicado melhor sobre "Propagação de sinal" e TRUE e FALSE dentro de um
* tratador de sinal. Tudo será esclarecido mais adiante.
*
*/
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy),NULL);
// Seta a grossura da borda de uma janela
gtk_container_set_border_width(GTK_CONTAINER(window),10);
// Cria um botão novo escrito "helllllo!"
button = gtk_button_new_with_label("helllllo");
/*
* Novamente um tratador de sinal! Desta vez é para o botão. Quando um botão
* recebe este sinal "clicked", será chamado a função hello() definida acima.
* Podemos ver que temos NULL, que é um argumento NULO enviado para a função
* callback hello().
*
*/
g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(hello), NULL);
/*
* Outro sinal.. este sinal causa a destruição da janela ao ser clicado. Esta chama a
* função gtk_widget_destroy(window) para tal e novamente, o sinal de destruir pode
* vir daqui(clique no botão) ou então do gerenciador de janelas (botões de fechar -
* altF4, etc).
*
*/
g_signal_connect_swapped(G_OBJECT(button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(window));
// Esta função empacota o botão dentro de um container, neste caso o
// container seria o "window" (janela principal criada).
gtk_container_add(GTK_CONTAINER(window),button);
// A última etapa é mostrar o botão na tela
gtk_widget_show(button);
// e também, lógico, devemos mostrar a janela
gtk_widget_show(window);
/*
* Todas as aplicações GTK devem ter uma chamada gtk_main(). O controle do
* programa termina aqui e esta função fica esperando algum evento acontecer
* (clique de mouse, movimento do mouse, tecla pressionada, etc)
*
*/
gtk_main();
return 0;
}
static int init(void) {
LOG_DEBUG(2, "GTK+-2 file requester selected.\n");
gtk_init(NULL, NULL);
return 0;
}
int main(int argc, char *argv[])
{
int p=0, w=0, h=0, x=-1000000, y=-1000000;
//GdkGeometry geom;
channels = NULL;
current_channel = -1;
previous_channel = -1;
lirc_dev = NULL;
channelcombo = NULL;
gtk_init(&argc, &argv);
if (!parse_command_line_options(&argc, &argv, &p, &w, &h, &x, &y)) return 1;
load_options(w?NULL:&w, h?NULL:&h, x!=-1000000?NULL:&x, y!=-1000000?NULL:&y);
if (p) port = p;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (destroy), NULL);
gtk_window_set_policy(GTK_WINDOW(window), 1, 1, 0);
gtk_window_set_title (GTK_WINDOW (window), "Linux Video Studio TV");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
tv = gtk_tvplug_new(port);
if (!tv)
{
g_print("ERROR: no suitable video4linux device found\n");
g_print("Please supply a video4linux Xv-port manually (\'stv -p <num>\')\n");
return 1;
}
if (channels)
{
int i;
for(i=0;channels[i];i++)
if (channels[i]->frequency == (int)GTK_TVPLUG(tv)->frequency_adj->value)
{
current_channel = i;
break;
}
}
if (!port) port = GTK_TVPLUG(tv)->port;
GTK_WIDGET_SET_FLAGS(tv, GTK_CAN_FOCUS); /* key press events */
gtk_container_add (GTK_CONTAINER (window), tv);
gtk_widget_show(tv);
set_background_color(tv, 0, 0, 0);
gtk_signal_connect(GTK_OBJECT(tv), "button_press_event",
GTK_SIGNAL_FUNC(tv_clicked), NULL);
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
GTK_SIGNAL_FUNC(tv_typed), NULL);
gtk_signal_connect(GTK_OBJECT(window), "focus_in_event",
GTK_SIGNAL_FUNC(focus_in_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
set_background_color(window, 0, 0, 0);
input_init();
#if 0
geom.min_width = GTK_TVPLUG(tv)->width_best/16;
geom.min_height = GTK_TVPLUG(tv)->height_best/16;
geom.max_width = GTK_TVPLUG(tv)->width_best;
geom.max_height = GTK_TVPLUG(tv)->height_best;
geom.width_inc = GTK_TVPLUG(tv)->width_best/16;
geom.height_inc = GTK_TVPLUG(tv)->height_best/16;
geom.min_aspect = GTK_TVPLUG(tv)->height_best / GTK_TVPLUG(tv)->width_best - 0.05;
geom.max_aspect = GTK_TVPLUG(tv)->height_best / GTK_TVPLUG(tv)->width_best + 0.05;
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geom,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_ASPECT | GDK_HINT_RESIZE_INC);
if (w>0 && h>0) gtk_widget_set_usize(window, w, h);
if (x!=-1000000 && y!=-1000000) gtk_widget_set_uposition(window, x, y);
#endif
#ifdef HAVE_LIRC
lirc_init();
#endif
#ifdef OSS
sound_init();
#endif
gtk_widget_show(window);
gtk_main();
return 0;
}
int main(int argc,char **argv)
{
GtkWidget *win;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *scrolled;
GtkWidget *reader;
GtkWidget *displayer;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *from;
GtkWidget *to;
PangoFontDescription *font_name;
SelectionData select_data;
DuoYiData duoyi_data;
TranData tran_data;
/*默认使用UTF-8编码*/
setlocale(LC_ALL,"");
#ifdef _WIN32
putenv("LANG=zh_CN.UTF-8");
#else
setenv("LANG","zh_CN.UTF-8",1);
#endif
/*读取配置文件，配置文件以json格式存储*/
duoyi_read_config(&duoyi_data);
/*if(!g_thread_supported())
g_thread_init(NULL);
gdk_threads_init();*/
gtk_init(&argc,&argv);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win),"多译");
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file(GTK_WINDOW(win),"img/64x64/yi.png",NULL);
/*设置窗口大小固定*/
gtk_window_set_resizable(GTK_WINDOW(win),FALSE);
g_signal_connect(G_OBJECT(win),"delete-event",
G_CALLBACK(duoyi_quit),NULL);
/*创建两个GtkBox构件用来存放各界面构件*/
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_container_add(GTK_CONTAINER(win),vbox);
/*在状态栏中显示图标*/
tray_create(win);
/*reader为读取翻译内容构件，displayer为显示翻译结果构件*/
reader=gtk_text_view_new();
displayer=gtk_text_view_new();
/*创建主菜单*/
create_menu(win,vbox,reader);
/*设置显示构件的字体*/
if(duoyi_data.font)
{
font_name=pango_font_description_from_string(duoyi_data.font);
gtk_widget_override_font(reader,font_name);
gtk_widget_override_font(displayer,font_name);
}
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
/*初始化默认词典*/
select_data.select=duoyi_data.dic;
//init_select_data(&select_data,from,to,&duoyi_data);
/*创建词典选择界面*/
add_dic_selection(win,hbox,&select_data);
//from=create_combox(hbox,"从:");
//to=create_combox(hbox,"翻译到:");
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
gtk_box_pack_start(GTK_BOX(hbox),vbox,FALSE,FALSE,0);
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
/*创建选择语言的下拉框界面*/
from=create_combox(hbox,"从:");
to=create_combox(hbox,"翻译到:");
/*设置SelectionData数据结构其它值*/
init_select_data(&select_data,from,to,&duoyi_data);
/*添加一个横向条*/
gtk_box_pack_start(GTK_BOX(vbox),
gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
FALSE,FALSE,5);
/*给显示构件添加滚动条*/
scrolled=gtk_scrolled_window_new(NULL,NULL);
/*设置滚动条自动滚动*/
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//displayer=gtk_text_view_new();
gtk_widget_set_size_request(scrolled,0x260,0x95);
/*显示结果构件不可编辑*/
gtk_text_view_set_editable(GTK_TEXT_VIEW(displayer),FALSE);
/*设置显示构件自动换行*/
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(displayer),GTK_WRAP_CHAR);
gtk_container_add(GTK_CONTAINER(scrolled),displayer);
/*添加边框*/
frame=gtk_frame_new("翻译结果");
gtk_container_add(GTK_CONTAINER(frame),scrolled);
gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,0);
gtk_container_set_border_width(GTK_CONTAINER(scrolled),0x5);
gtk_box_pack_start(GTK_BOX(vbox),
gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
FALSE,FALSE,10);
/*为读取翻译内容构件设置滚动条并设置自动滚到*/
scrolled=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(scrolled,0x260,0x60);
//reader=gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(reader),GTK_WRAP_CHAR);
gtk_container_add(GTK_CONTAINER(scrolled),reader);
/*添加一个边框*/
frame=gtk_frame_new("输入");
gtk_container_add(GTK_CONTAINER(frame),scrolled);
gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,0);
gtk_container_set_border_width(GTK_CONTAINER(scrolled),0x5);
gtk_container_set_border_width(GTK_CONTAINER(vbox),0x10);
gtk_box_pack_start(GTK_BOX(vbox),
gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
FALSE,FALSE,10);
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,TRUE,TRUE,0);
/*清除读取内容按钮*/
button=gtk_button_new_with_label("清空");
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,10);
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(duoyi_reader_cleanup),reader);
/*从文件加载内容到读取构件按钮*/
button=gtk_button_new_with_label("从文件加载");
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,10);
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(duoyi_read_from_file),reader);
/*翻译按钮*/
button=gtk_button_new_with_label("翻译");
gtk_box_pack_end(GTK_BOX(hbox),button,TRUE,TRUE,80);
tran_data.data=&select_data;
tran_data.reader=reader;
tran_data.displayer=displayer;
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(duoyi_translate),&tran_data);
gtk_widget_show_all(win);
/*运行程序选择默认词典*/
switch(select_data.select)
{
case 0:
duoyi_baidu_select(NULL,&select_data);
break;
case 1:
duoyi_bing_select(NULL,&select_data);
break;
case 2:
duoyi_king_select(NULL,&select_data);
break;
case 3:
duoyi_youdao_select(NULL,&select_data);
break;
}
//gdk_threads_enter();
gtk_main();
//gdk_threads_leave();
return 0;
}
int main (int argc, char *argv[]) {
/* set up i18n */
bindtextdomain (PACKAGE, GUMMI_LOCALES);
setlocale (LC_ALL, "");
textdomain (PACKAGE);
GError* error = NULL;
GOptionContext* context = g_option_context_new ("files");
g_option_context_add_main_entries (context, entries, PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
if (error) g_error("%s\n", error->message);
if (showversion) {
printf("Gummi %s\n", PACKAGE_VERSION);
return 0;
}
/* initialize GTK */
g_thread_init (NULL);
gdk_threads_init ();
gtk_init (&argc, &argv);
GError* ui_error = NULL;
GtkBuilder* builder = gtk_builder_new ();
gchar* ui = g_build_filename (GUMMI_DATA, "ui", "gummi.glade", NULL);
// exit program when gummi.glade can not be located:
if (!g_file_test (ui, G_FILE_TEST_EXISTS)) {
printf("Could not locate Glade interface file at:\n%s\n", ui);
return 0;
}
gtk_builder_add_from_file (builder, ui, &ui_error);
if (ui_error) {
g_error ("%s\n", ui_error->message);
}
gtk_builder_set_translation_domain (builder, PACKAGE);
g_free (ui);
/* Initialize logging */
slog_init (debug);
slog (L_INFO, PACKAGE_NAME" version: "PACKAGE_VERSION"\n");
/* Initialize configuration */
gchar* configname = g_build_filename (g_get_user_config_dir (), "gummi",
"gummi.cfg", NULL);
config_init (configname);
config_load ();
g_free (configname);
/* Initialize signals */
gummi_signals_register ();
/* Initialize Classes */
gchar* snippetsname = g_build_filename (g_get_user_config_dir (), "gummi",
"snippets.cfg", NULL);
// why do we not load this from environment, like gui-main does? -A
GuMotion* motion = motion_init ();
GuIOFunc* io = iofunctions_init();
GuLatex* latex = latex_init ();
GuBiblio* biblio = biblio_init (builder);
GuTemplate* templ = template_init (builder);
GuTabmanager* tabm = tabmanager_init ();
GuProject* proj = project_init ();
GuSnippets* snippets = snippets_init (snippetsname);
gummi = gummi_init (motion, io, latex, biblio, templ, snippets, tabm, proj);
slog (L_DEBUG, "Gummi created!\n");
g_free (snippetsname);
/* Initialize GUI */
gui = gui_init (builder);
slog_set_gui_parent (gui->mainwindow);
slog (L_DEBUG, "GummiGui created!\n");
/* Start compile thread */
if (external_exists (config_get_value("typesetter"))) {
typesetter_setup ();
motion_start_compile_thread (motion);
}
else {
infoscreengui_enable (gui->infoscreengui, "program_error");
slog (L_ERROR, "Could not locate the typesetter program\n");
}
/* Install acceleration group to mainwindow */
gtk_window_add_accel_group (gui->mainwindow, snippets->accel_group);
if (argc != 2)
tabmanager_create_tab (A_DEFAULT, NULL, NULL);
else {
if (!g_file_test(argv[1], G_FILE_TEST_EXISTS)) {
slog(L_ERROR, "Failed to open file '%s': No such file or "
"directory\n", argv[1]);
exit(1);
}
tabmanager_create_tab (A_LOAD, argv[1], NULL);
}
if (config_get_value ("autosaving")) iofunctions_start_autosave ();
gui_main (builder);
config_save ();
config_clean_up ();
return 0;
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GdkColor color;
XWMHints mywmhints;
GtkWidget *main_button;
GdkPixmap *main_button_pixmap;
GdkBitmap *main_button_mask;
GtkWidget *main_button_box;
GtkWidget *color_menu;
GtkWidget *item;
GtkWidget *label;
GtkWidget *color_box;
GtkWidget *hbox;
GdkColor gcolor;
char *wmstickynotes_dir = NULL;
gboolean use_default_dir = TRUE;
int option_index = 0;
int i = 0;
struct option long_options[] = {
{"directory", required_argument, 0, 'd'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}};
for(
i = getopt_long(argc, argv, "d:vh", long_options, &option_index);
i >= 0;
i = getopt_long(argc, argv, "d:vh", long_options, &option_index)
) {
switch(i) {
case 'd':
wmstickynotes_dir = optarg;
use_default_dir = FALSE;
break;
case 'v':
printf("%s\n", PACKAGE_STRING);
printf("Copyright (C) 2009 %s\n", PACKAGE_BUGREPORT);
return 0;
case 'h':
usage();
return 0;
default:
usage();
return 1;
}
}
umask(077);
if(use_default_dir) {
wmstickynotes_dir = calloc(
strlen(default_wmstickynotes_dir) +
strlen(getenv("HOME")) + 2, sizeof(char));
strcpy(wmstickynotes_dir, getenv("HOME"));
strcat(wmstickynotes_dir, "/");
strcat(wmstickynotes_dir, default_wmstickynotes_dir);
}
if(chdir(wmstickynotes_dir)) {
if(errno == ENOENT) {
if(mkdir(wmstickynotes_dir, 0777)) {
fprintf(stderr, "Couldn't make directory: %s\n", wmstickynotes_dir);
exit(1);
}
if(chdir(wmstickynotes_dir)) {
fprintf(stderr, "Couldn't change to directory: %s\n", wmstickynotes_dir);
exit(1);
}
} else {
fprintf(stderr, "Couldn't change to directory: %s\n", wmstickynotes_dir);
exit(1);
}
}
if(use_default_dir) free(wmstickynotes_dir);
gtk_init(&argc, &argv);
colormap = gdk_colormap_new(gdk_visual_get_system(), TRUE);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 64, 64);
box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER (window), box);
gdk_color_parse ("#fafafa", &color);
gtk_widget_modify_bg(box, GTK_STATE_NORMAL, &color);
main_button_pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &main_button_mask, NULL, wmstickynotes_xpm);
main_button = gtk_image_new_from_pixmap(main_button_pixmap, main_button_mask);
main_button_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(main_button_box), main_button);
gtk_container_add(GTK_CONTAINER(box), main_button_box);
color_menu = gtk_menu_new();
for(i=0; i < num_color_schemes; i++) {
item = gtk_menu_item_new();
label = gtk_label_new(color_schemes[i].name);
color_box = gtk_event_box_new();
gtk_widget_set_size_request(color_box, 15, -1);
hbox = gtk_hbox_new(FALSE, 4);
gdk_color_parse(color_schemes[i].top, &gcolor);
gtk_widget_modify_bg(color_box, GTK_STATE_NORMAL, &gcolor);
gtk_widget_modify_bg(color_box, GTK_STATE_PRELIGHT, &gcolor);
gtk_container_add(GTK_CONTAINER(item), hbox);
gtk_box_pack_start(GTK_BOX(hbox), color_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), item);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(new_note_from_menu), &color_schemes[i]);
}
gtk_widget_show_all(GTK_WIDGET(color_menu));
gtk_widget_show_all(window);
mywmhints.initial_state = WithdrawnState;
mywmhints.icon_window = GDK_WINDOW_XWINDOW(box->window);
mywmhints.icon_x = 0;
mywmhints.icon_y = 0;
mywmhints.window_group = GDK_WINDOW_XWINDOW(window->window);
mywmhints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint;
XSetWMHints(GDK_DISPLAY(), GDK_WINDOW_XWINDOW(window->window), &mywmhints);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(main_button_box), "button-press-event", G_CALLBACK(main_button_pressed), color_menu);
read_old_notes();
gtk_main();
return 0;
}
int
main (int argc, char *argv[])
{
XdgDirEntry *old_entries, *new_entries, *entry;
XdgDirEntry *desktop_entry;
GtkBookmark *bookmark;
GList *bookmarks, *l;
char *old_locale;
char *locale, *dot;
int i;
gboolean modified_bookmarks;
char *uri;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GLIBLOCALEDIR);
bindtextdomain ("xdg-user-dirs", GLIBLOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
old_entries = parse_xdg_dirs (NULL);
old_locale = parse_xdg_dirs_locale ();
locale = g_strdup (setlocale (LC_MESSAGES, NULL));
dot = strchr (locale, '.');
if (dot)
*dot = 0;
if (old_locale && *old_locale != 0 &&
strcmp (old_locale, locale) != 0 &&
has_xdg_translation ())
{
gtk_init (&argc, &argv);
update_locale (old_entries);
}
new_entries = parse_xdg_dirs (NULL);
bookmarks = parse_gtk_bookmarks ();
modified_bookmarks = FALSE;
if (bookmarks == NULL)
{
char *make_bm_for[] = {
"DOCUMENTS",
"MUSIC",
"PICTURES",
"VIDEOS",
"DOWNLOAD",
NULL};
/* No previous bookmarks. Generate standard ones */
desktop_entry = find_dir_entry (new_entries, "DESKTOP");
for (i = 0; make_bm_for[i] != NULL; i++)
{
entry = find_dir_entry (new_entries, make_bm_for[i]);
if (entry && strcmp (entry->path, g_get_home_dir ()) != 0 &&
(desktop_entry == NULL || strcmp (entry->path, desktop_entry->path) != 0))
{
uri = g_filename_to_uri (entry->path, NULL, NULL);
if (uri)
{
modified_bookmarks = TRUE;
bookmark = g_new0 (GtkBookmark, 1);
bookmark->uri = uri;
bookmarks = g_list_append (bookmarks, bookmark);
}
}
}
}
else
{
/* Map old bookmarks that were moved */
for (l = bookmarks; l != NULL; l = l->next)
{
char *path;
bookmark = l->data;
path = g_filename_from_uri (bookmark->uri, NULL, NULL);
if (path)
{
entry = find_dir_entry_by_path (old_entries, path);
if (entry)
{
entry = find_dir_entry (new_entries, entry->type);
if (entry)
{
uri = g_filename_to_uri (entry->path, NULL, NULL);
if (uri)
{
modified_bookmarks = TRUE;
g_free (bookmark->uri);
bookmark->uri = uri;
}
}
}
g_free (path);
}
}
}
if (modified_bookmarks)
save_gtk_bookmarks (bookmarks);
g_free (new_entries);
g_free (old_entries);
return 0;
}
int main(int argc, char *argv[])
{
GtkWidget *win = NULL; /* The main window */
GtkWidget *vbox = NULL; /* Packing box for the menu and toolbars */
GtkWidget *menubar = NULL; /* The actual menubar */
GtkWidget *toolbar = NULL; /* The actual toolbar */
GtkActionGroup *action_group = NULL; /* Packing group for our Actions */
GtkUIManager *menu_manager = NULL; /* The magic widget! */
GError *error = NULL; /* For reporting exceptions or errors */
/* Initialize translation text domain */
bindtextdomain(g_config.package_name, g_config.locale_dir);
bind_textdomain_codeset(g_config.package_name, "UTF-8");
textdomain(g_config.package_name);
/* Initialize GTK+ */
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init(&argc, &argv);
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
/* Create the main window */
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win), _("Hello World"));
gtk_window_set_default_size(GTK_WINDOW(win), 400, 300);
gtk_widget_realize(win);
/* Create a vertical box to hold menubar and toolbar */
vbox = gtk_vbox_new(FALSE, 0);
/* Create menus */
action_group = gtk_action_group_new("TestActions");
gtk_action_group_set_translation_domain(action_group, g_config.package_name);
menu_manager = gtk_ui_manager_new();
/* Read in the UI from our XML file */
error = NULL;
gtk_ui_manager_add_ui_from_file(menu_manager, "hello.xml", &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
error = NULL;
}
/* Create a list of entries which are passed to the Action constructor.
* This is a huge convenience over building Actions by hand.
*/
const GtkActionEntry entries[] = {
/**********************************/
{ "FileMenuAction", NULL,
_("_File"), NULL,
_("File operations"),
NULL
},
/**********************************/
{ "SendAction", GTK_STOCK_EXECUTE,
_("_Send"), "<Ctrl>S",
_("Send hello world to console"),
G_CALLBACK(SendHelloWorld)
},
/**********************************/
{ "QuitAction", GTK_STOCK_QUIT,
_("_Quit"), "<Ctrl>Q",
_("Quit"),
G_CALLBACK(gtk_main_quit)
},
/**********************************/
};
/* Pack up our objects:
* vbox -> win
* actions -> action_group
* action_group -> menu_manager
*/
gtk_container_add(GTK_CONTAINER(win), vbox);
gtk_action_group_add_actions(action_group, entries, G_N_ELEMENTS(entries), NULL);
gtk_ui_manager_insert_action_group(menu_manager, action_group, 0);
/* Get the menubar and the toolbar and put them in the vertical packing box */
menubar = gtk_ui_manager_get_widget(menu_manager, "/MainMenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
toolbar = gtk_ui_manager_get_widget(menu_manager, "/MainToolbar");
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* Connect signals */
g_signal_connect(win, "destroy", gtk_main_quit, NULL);
/* Make sure that the accelerators work */
gtk_window_add_accel_group(GTK_WINDOW(win),
gtk_ui_manager_get_accel_group(menu_manager));
/* Enter the main loop */
gtk_widget_show_all(win);
gtk_main();
return (0);
}
int
main (int argc, char *argv[])
{
int err, i;
GNOME_Pilot_Survival survive;
GError *error;
GList *pilots = NULL;
GOptionContext *option_context;
bindtextdomain (PACKAGE, GNOMELOCALEDIR);
textdomain (PACKAGE);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
if (argc<2) {
g_message ("usage : %s [--now|--later] [--pilot PDA] [FILE ...]", argv[0]);
exit (1);
}
option_context = g_option_context_new (PACKAGE);
g_option_context_add_main_entries (option_context, options, NULL);
if (!g_option_context_parse(option_context, &argc, &argv, &error)) {
g_error (_("Error parsing commandline arguments: %s"), error->message);
exit (1);
}
gtk_init (&argc, &argv);
gpc = GNOME_PILOT_CLIENT (gnome_pilot_client_new ());
g_object_ref_sink (G_OBJECT (gpc));
g_signal_connect (G_OBJECT (gpc),"completed_request", G_CALLBACK(gpilotd_request_completed), NULL);
gnome_pilot_client_connect_to_daemon (gpc);
if (pilot_arg!=NULL) {
pilots = g_list_append (pilots, g_strdup (pilot_arg));
} else {
err = gnome_pilot_client_get_pilots (gpc, &pilots);
if (err !=GPILOTD_OK || pilots == NULL) {
g_warning (_("Unable to get PDA names"));
show_warning_dialog (_("Unable to get PDA names"));
exit (1);
}
}
notfailed = failed = handles = NULL;
survive = GNOME_Pilot_IMMEDIATE;
if (later) survive = GNOME_Pilot_PERSISTENT;
i=0;
while (filenames && filenames[i]!=NULL) {
gint err;
err = gnome_pilot_client_install_file (gpc,
pilots->data, /* get first pilot */
filenames[i],
survive,
0,
&handle);
if (err == GPILOTD_OK) {
handles = g_slist_prepend (handles,GINT_TO_POINTER(handle));
notfailed = g_slist_prepend (notfailed, (void *) filenames[i]);
} else {
failed = g_slist_prepend (failed, (void *) filenames[i]);
}
i++;
}
if (!later) {
gchar *message;
message = NULL;
if (failed != NULL) {
GSList *e;
message = g_strdup (_("Following files failed :\n"));
for (e=failed;e;e = g_slist_next (e)) {
gchar *tmp;
tmp = g_strconcat (message,"\t- ", e->data,"\n", NULL);
g_free (message);
message = tmp;
}
g_slist_free (failed);
}
{
GSList *e;
if (message == NULL)
message = g_strdup_printf (_("Installing to %s:\n"), (char*)pilots->data);
else {
gchar *tmp;
tmp = g_strconcat (message,"\nInstalling to ",
(char*)pilots->data, ":\n", NULL);
g_free (message);
message = tmp;
}
for (e=notfailed;e;e = g_slist_next (e)) {
gchar *tmp;
tmp = g_strconcat (message,"\t- ", e->data,"\n", NULL);
g_free (message);
message = tmp;
}
g_slist_free (notfailed);
}
{
gchar *tmp;
gchar *info;
if (handles == NULL)
info = g_strdup (_("No files to install"));
else {
info = g_strdup (_("Press synchronize on the cradle to install\n"
" or cancel the operation."));
err = gnome_pilot_client_conduit (gpc,
pilots->data,
"File",
GNOME_Pilot_CONDUIT_DEFAULT,
survive,
0,
&handle);
}
tmp = g_strconcat (message==NULL?"":message,
"\n",
info,
NULL);
g_free (message);
g_free (info);
message = tmp;
}
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_OTHER, GTK_BUTTONS_CANCEL, "%s",
message);
gint response = gtk_dialog_run(GTK_DIALOG(dialog));
if (dialog != NULL) /* if not destroyed by callback */
gtk_widget_destroy(dialog);
if (response == GTK_RESPONSE_CANCEL) {
GSList *e;
for (e=handles;e;e = g_slist_next (e)) {
gnome_pilot_client_remove_request
(gpc,GPOINTER_TO_INT(e->data));
}
g_slist_free (handles);
}
g_free (message);
}
g_object_unref (G_OBJECT (gpc));
return 0;
}
int main( int argc, char *argv[] )
{
// Initialize GTK+
gtk_init( &argc, &argv );
g_set_application_name( PACKAGE_NAME );
g_log_set_handler( "Wnck", G_LOG_LEVEL_WARNING, (GLogFunc)gtk_false , NULL );
const struct option longopts[] =
{
{ 0, 0, 0, 'v' },
{ 0, 0, 0, 'h' },
{ 0, 0, 0, 0 },
};
int index = 0;
int iarg = 0;
// turn off getopt error message
opterr = 0;
while( iarg != -1 )
{
iarg = getopt_long( argc, argv, "s:vh", longopts, &index );
switch( iarg )
{
case 'v':
g_fprintf( stderr, "%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION );
g_fprintf( stderr, "Features:\n" );
#ifdef HAVE_APPINDICATOR
g_fprintf( stderr, "AppIndicator support - Yes\n" );
#else
g_fprintf( stderr, "AppIndicator support - No\n" );
#endif
g_fprintf( stderr, "Icon cache - Yes\n" );
return 0;
break;
case 'h':
g_fprintf( stderr, "%s\n\n%s\n%s\n%s\n",
"Usage: gxkb [arguments]",
"Options:",
"-v \t Display gxkb's version number.",
"-h \t Show this help." );
return 0;
break;
}
}
gchar *config_file = xkb_util_get_config_file();
gboolean first_run = FALSE;
t_xkb_settings *xkb = xkb_new();
if( !xkb_load_config( xkb, config_file ) )
{
first_run = TRUE;
xkb->group_policy = GROUP_POLICY_PER_APPLICATION;
}
if( !xkb_config_initialize( xkb, xkb_state_changed, xkb ) )
{
g_fprintf( stderr, "Can't get instance of the X display.\n" );
return 1;
}
if( first_run )
xkb_save_config( xkb, config_file );
statusicon_new();
// Save original config
t_xkb_settings *orig_config = g_new0( t_xkb_settings, 1 );
xkb_load_config( orig_config, config_file );
/* Enter the main loop */
gtk_main();
// Load config and check if it was not changed
t_xkb_settings *last_config = g_new0( t_xkb_settings, 1 );
xkb_load_config( last_config, config_file );
gboolean is_diff = xkb_is_config_changed( orig_config, last_config );
if( is_diff )
g_warning("Config file was changed. Saving skipped.\n");
else if( xkb->never_modify_config )
g_warning("Saving skipped by your configuration.\n");
else
xkb_save_config( xkb, config_file );
g_free( orig_config );
g_free( last_config );
g_free( config_file );
xkb_free( xkb );
statusicon_free();
return 0;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *collection;
GError *err;
clock_t start, end;
GtkWidget *notebook;
int i;
bindtextdomain (GETTEXT_PACKAGE, MARCO_LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
run_position_expression_tests ();
#if 0
run_position_expression_timings ();
#endif
gtk_init (&argc, &argv);
if (g_getenv ("MARCO_DEBUG") != NULL)
{
meta_set_debugging (TRUE);
meta_set_verbose (TRUE);
}
start = clock ();
err = NULL;
if (argc == 1)
global_theme = meta_theme_load ("ClearlooksRe", &err);
else if (argc == 2)
global_theme = meta_theme_load (argv[1], &err);
else
{
g_printerr (_("Usage: marco-theme-viewer [THEMENAME]\n"));
exit (1);
}
end = clock ();
if (global_theme == NULL)
{
g_printerr (_("Error loading theme: %s\n"),
err->message);
g_error_free (err);
exit (1);
}
g_print (_("Loaded theme \"%s\" in %g seconds\n"),
global_theme->name,
(end - start) / (double) CLOCKS_PER_SEC);
run_theme_benchmark ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 350, 350);
if (strcmp (global_theme->name, global_theme->readable_name)==0)
gtk_window_set_title (GTK_WINDOW (window),
global_theme->readable_name);
else
{
/* The theme directory name is different from the name the theme
* gives itself within its file. Display both, directory name first.
*/
gchar *title = g_strconcat (global_theme->name, " - ",
global_theme->readable_name,
NULL);
gtk_window_set_title (GTK_WINDOW (window),
title);
g_free (title);
}
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_realize (window);
g_assert (window->style);
g_assert (window->style->font_desc);
notebook = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (window), notebook);
collection = preview_collection (FONT_SIZE_NORMAL,
window->style->font_desc);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Normal Title Font")));
collection = preview_collection (FONT_SIZE_SMALL,
window->style->font_desc);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Small Title Font")));
collection = preview_collection (FONT_SIZE_LARGE,
window->style->font_desc);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Large Title Font")));
collection = previews_of_button_layouts ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Button Layouts")));
collection = benchmark_summary ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
collection,
gtk_label_new (_("Benchmark")));
i = 0;
while (i < (int) G_N_ELEMENTS (previews))
{
/* preview widget likes to be realized before its size request.
* it's lame that way.
*/
gtk_widget_realize (previews[i]);
++i;
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int main(int argc, char** argv) {
//Widgets
GtkWidget *flash;
GtkWidget *window;
GtkWidget *frame;
GtkWidget *install_x64;
GtkWidget *install_x86;
GtkWidget *remove_flash;
GtkWidget *label;
GtkWidget *title1;
GtkWidget *title2;
GtkWidget *install_flash_beta;
PangoFontDescription *bold = pango_font_description_from_string ( "Sans Bold 24");//Bold Font Paremeters
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);//Window Position
gtk_window_set_default_size(GTK_WINDOW(window), 300, 180);//Window Size
gtk_window_set_title(GTK_WINDOW(window), "Adobe Flash Installer"); //Title
frame = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), frame); //Draw Window
install_x86 = gtk_button_new_with_label("Install Flash (x86)"); //32 - bit Flash Button
gtk_widget_set_size_request(install_x86, 140, 35);
gtk_fixed_put(GTK_FIXED(frame), install_x86, 77, 90);
install_x64 = gtk_button_new_with_label("Install Flash (x64)");//64 - bit Flash Button
gtk_widget_set_size_request(install_x64, 140, 35);
gtk_fixed_put(GTK_FIXED(frame), install_x64, 77, 135);
install_flash_beta = gtk_button_new_with_label("Install Flash Beta");//Beta Flash Button
gtk_widget_set_size_request(install_flash_beta, 140, 35);
gtk_fixed_put(GTK_FIXED(frame), install_flash_beta, 77, 180);
remove_flash = gtk_button_new_with_label("Remove Flash");//Remove Flash
gtk_widget_set_size_request(remove_flash, 120, 35);
gtk_fixed_put(GTK_FIXED(frame), remove_flash, 87, 225);
label = gtk_label_new("Designed By CarleeDolphinaura");
gtk_fixed_put(GTK_FIXED(frame), label, 45, 280);
title1 = gtk_label_new("Adobe Flash");//Title (Row 1)
gtk_fixed_put(GTK_FIXED(frame), title1, 45, 10);
gtk_widget_show_all(window);
title2 = gtk_label_new("Installer");
gtk_fixed_put(GTK_FIXED(frame), title2, 70, 40); //Title (Row 2)
gtk_widget_show_all(window);
gtk_widget_modify_font(GTK_WIDGET(title1),bold);//Make Title (Row 1) Bold
gtk_widget_modify_font(GTK_WIDGET(title2),bold);//Make TItle (Row 2) Bold
g_signal_connect(window, "destroy",//Closing Callback
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect(install_x86, "clicked",//32-bit Callbacks
G_CALLBACK(install_32bit), flash);
g_signal_connect(install_x64, "clicked",//64-bit Callbacks
G_CALLBACK(install_64bit), flash);
g_signal_connect(remove_flash, "clicked",//Remove Flash Callbacks
G_CALLBACK(remove_flsh), flash);
g_signal_connect(install_flash_beta, "clicked",//Flash Beta Callbacks
G_CALLBACK(install_beta), flash);
//Echo Terminal Output
system("echo 'Adobe Flash Tools For Ubuntu'");
system("echo 'Designed By CarleeDolphinaura (Ubuntu Forums)'");
system("echo 'Licenced Under GPL v3'");
gtk_main();
return 0;
}
/* tu wchodzimy do programu, czytamy krainy i wyswietlamy liste krain.
gdy uzytkownik wybierze kraine, wywolujemy kolejne funkcje (nizej w pliku) */
int main( int argc, char **argv )
{
struct timeval now_time;
AREA_DATA *a;
GtkTreeIter iter;
struct stat fst;
char katalog[ MIL ], sciezka[ MIL ], *p;
GtkWidget *powitalne;
GtkCellRendererText *renderer;
gtk_set_locale( );
gtk_init( &argc, &argv );
glacaxml = gtk_builder_new( );
if ( !stat( "glaca.glade", &fst ) )
gtk_builder_add_from_file( glacaxml, "glaca.glade", NULL /* &error */ );
else
{
/* dirname( ) z glibc niszczy argumenty, wiec nie podam mu argv[ 0 ] */
strcpy( katalog, argv[ 0 ] );
strcpy( katalog, dirname( katalog ) );
sprintf( sciezka, "%s/glaca.glade", katalog );
if ( !stat( sciezka, &fst ) )
gtk_builder_add_from_file( glacaxml, sciezka, NULL /* &error */ );
else
{
sprintf( sciezka, "%s/gla/glaca.glade", katalog );
if ( !stat( sciezka, &fst ) )
gtk_builder_add_from_file( glacaxml, sciezka, NULL /* &error */ );
else
{
sprintf( sciezka, "%s/../glaca/glaca.glade", katalog );
if ( !stat( sciezka, &fst ) )
gtk_builder_add_from_file( glacaxml, sciezka, NULL /* &error */ );
else
{
cbug( "Nie znalazlem pliku glaca.glade. Sprawdz swoja instalacje.", 0 );
return 1;
}
}
}
}
/* okienko powitalne */
ZNAJDZ_KONTROLKE( powitalne, "oknopowitalne" );
gtk_widget_show( powitalne );
/* Doprowadzmy do natychmiastowego wyswietlenia tego okienka. Nie bedzie
aktualizowane az zniknie, ale to juz minimalny problem, bo jednak
wczytanie krain nie jest az tak dlugie :) */
while ( gtk_events_pending( ) )
gtk_main_iteration( );
/* Wczytanie krain */
TylkoKonwersja = TRUE;
comm_main( TRUE, argc, argv );
if ( ( iso_uni = iconv_open( "UTF-8", "ISO_8859-2" ) ) == (iconv_t) -1 )
lac_perror( "iso_uni" );
if ( ( uni_iso = iconv_open( "ISO_8859-2", "UTF-8" ) ) == (iconv_t) -1 )
lac_perror( "uni_iso" );
/* Wielkim problemem gtk_builder_connect_signals jest brak mozliwosci
sprawdzenia, czy wszystko sie udalo (poza przeczytaniem stderr, gdzie
to wyrzuca bledy, co za glupota).
Moznaby przekierowac stderr do pliku, nastepnie go odczytac i wyswietlic
w okienku GTK+, zeby pod Windows uzytkownik mial co skopiowac, zeby potem
wkleic opiekunowi programu. */
gtk_builder_connect_signals( glacaxml, NULL );
ZNAJDZ_KONTROLKE( dlis.lista_krain, "treeviewlistakrain" );
ZNAJDZ_KONTROLKE( dlis.okno_lista_krain, "oknolistakrain" );
ZNAJDZ_KONTROLKE2( dlis.store_krain, "lis_store", GTK_LIST_STORE );
ZNAJDZ_KONTROLKE2( renderer, "lis_renderer_nazwa", GTK_CELL_RENDERER_TEXT );
g_object_set( renderer, "font", "Monospace", NULL );
ZNAJDZ_KONTROLKE2( renderer, "lis_renderer_zakres", GTK_CELL_RENDERER_TEXT );
g_object_set( renderer, "font", "Monospace", NULL );
dlis.selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( dlis.lista_krain ) );
gtk_tree_selection_set_mode( dlis.selection, GTK_SELECTION_MULTIPLE );
ZNAJDZ_KONTROLKE( dlis.button_mob, "lis_button_mob" );
ZNAJDZ_KONTROLKE( dlis.button_pom, "lis_button_pom" );
ZNAJDZ_KONTROLKE( dlis.button_prz, "lis_button_prz" );
ZNAJDZ_KONTROLKE2( dlis.entry_vnum, "lis_entry_vnum", GTK_ENTRY );
for ( a = area_first; a; a = a->next )
{
p = wiersz( a, sciezka );
gtk_list_store_append( dlis.store_krain, &iter );
gtk_list_store_set( dlis.store_krain, &iter,
KOL_WSKAZNIK, a,
KOL_NAZWA, a->file_name,
KOL_OPIS, sciezka,
KOL_OPIS2, p, -1 );
}
font_desc = pango_font_description_from_string( "Monospace" );
pango_font_description_set_absolute_size( font_desc, 12 * PANGO_SCALE );
/* dialogi */
zrob_Listy( );
zrob_dialog_Combo( );
zrob_okno_Krainy( );
zrob_okno_Pomieszczenia( );
zrob_okno_Moba( );
zrob_okno_Vnuma( );
zrob_okno_Mapy( );
zrob_okno_Wyjscia( );
zrob_okno_Progow( );
zrob_okno_Przedmiotu( );
zrob_okno_Resetu( );
pango_font_description_free( font_desc );
gtk_widget_show( dlis.okno_lista_krain );
gtk_widget_hide( powitalne );
/* zadne ZNAJDZ_KONTROLKE nie moze byc potem wywolywane - wszystko musi
byc wczesniej znalezione w funkcjach zrob_okno_blabla */
g_object_unref( G_OBJECT( glacaxml ) );
gtk_main( );
gettimeofday( &now_time, NULL );
current_time = (time_t) now_time.tv_sec;
log_string( "Edytor krain zakonczyl dzialanie." );
return 0;
}
int
main (int argc,
char *argv[])
{
GtkWidget *win, *vbox, *frame, *group_box;
GtkWidget *hbox, *label, *chooser, *button;
GtkSizeGroup *label_group;
GOptionContext *context;
gchar *cwd;
context = g_option_context_new ("- test GtkFileChooserButton widget");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
gtk_init (&argc, &argv);
/* to test rtl layout, use "--right-to-left" */
if (rtl)
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
cwd = g_get_current_dir();
gtk_src_dir = g_path_get_dirname (cwd);
g_free (cwd);
win = gtk_dialog_new_with_buttons ("TestFileChooserButton", NULL, 0,
"_Quit", GTK_RESPONSE_CLOSE, NULL);
g_signal_connect (win, "response", G_CALLBACK (gtk_main_quit), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
g_object_set (vbox, "margin", 6, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox);
frame = gtk_frame_new ("<b>GtkFileChooserButton</b>");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE);
gtk_widget_set_halign (frame, GTK_ALIGN_FILL);
gtk_widget_set_valign (frame, GTK_ALIGN_FILL);
g_object_set (frame, "margin-top", 6, "margin-start", 12, NULL);
label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
group_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), group_box);
/* OPEN */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE);
label = gtk_label_new_with_mnemonic ("_Open:");
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE);
chooser = gtk_file_chooser_button_new ("Select A File - testfilechooserbutton",
GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
g_signal_connect (chooser, "current-folder-changed",
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE);
/* SELECT_FOLDER */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE);
label = gtk_label_new_with_mnemonic ("Select _Folder:");
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE);
chooser = gtk_file_chooser_button_new ("Select A Folder - testfilechooserbutton",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
g_signal_connect (chooser, "current-folder-changed",
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE);
g_object_unref (label_group);
gtk_widget_show_all (win);
gtk_window_present (GTK_WINDOW (win));
gtk_main ();
return 0;
}
int main( int argc, char **argv)
{
// int choose = 0;
gtk_init(&argc, &argv);
GtkWidget *janela, *label;
GtkWidget *choice_box;
GtkWidget *extras0, *install_skype_button, *uninstall_skype_button;
GtkWidget *extras1, *install_flash_button, *uninstall_flash_button;
GtkWidget *extras2, *install_codecs_button, *uninstall_codecs_button;
GtkWidget *quit_button;
///// The master window ////////////
janela = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(janela), 10, 10);
gtk_window_set_position(GTK_WINDOW(janela), GTK_WIN_POS_CENTER);
////// Adds icon to systemtray and window-decoration/////////
gtk_window_set_icon(GTK_WINDOW(janela), create_pixbuf("/usr/share/icons/mandriva.png"));
////// Define the type of box for this variables
choice_box = gtk_vbox_new(TRUE, 7);
extras0 = gtk_hbox_new(TRUE, 7);
extras1 = gtk_hbox_new(TRUE, 7);
extras2 = gtk_hbox_new(TRUE, 7);
label = gtk_label_new("Select an option or press Quit");
////////////////////////////////////////
///Window Title////////////
gtk_window_set_title(GTK_WINDOW(janela), "Mandriva 2011 Stuff Installer");
///////////////
/////// Adds label to choice_box and choice_box do master_window ///////
gtk_container_add(GTK_CONTAINER(choice_box), label);
gtk_container_add(GTK_CONTAINER(janela), choice_box);
/////// Adds horizontal boxes with buttons to the choice_box //////
gtk_container_add(GTK_CONTAINER(choice_box), extras0);
gtk_container_add(GTK_CONTAINER(choice_box), extras1);
gtk_container_add(GTK_CONTAINER(choice_box), extras2);
// gtk_container_add(GTK_CONTAINER(choice_box), quit_button);
///// Create the buttons/////////////////
quit_button = gtk_button_new_with_label("Quit");
gtk_box_pack_start (GTK_BOX (choice_box), quit_button, FALSE, FALSE, 0);
install_skype_button = gtk_button_new_with_label("Install Skype");
gtk_box_pack_start (GTK_BOX (extras0), install_skype_button, TRUE, TRUE, 15);
uninstall_skype_button = gtk_button_new_with_label("Uninstall Skype");
gtk_box_pack_start (GTK_BOX (extras0), uninstall_skype_button, TRUE, TRUE, 15);
install_flash_button = gtk_button_new_with_label("Install Flash");
gtk_box_pack_start (GTK_BOX (extras1), install_flash_button, TRUE, TRUE, 15);
uninstall_flash_button = gtk_button_new_with_label("Uninstall Flash");
gtk_box_pack_start (GTK_BOX (extras1), uninstall_flash_button, TRUE, TRUE, 15);
install_codecs_button = gtk_button_new_with_label("Install Codecs");
gtk_box_pack_start (GTK_BOX (extras2), install_codecs_button, TRUE, TRUE, 15);
uninstall_codecs_button = gtk_button_new_with_label("Uninstall Codecs");
gtk_box_pack_start (GTK_BOX (extras2), uninstall_codecs_button, TRUE, TRUE, 15);
///// end of button creation///////////
//////// Show the master_window and all its babies//////
gtk_widget_show_all(janela);
////////////
//////////// Funtions to buttons when they are clicked///////////
g_signal_connect(install_skype_button, "clicked",
G_CALLBACK(install_skype), NULL);
g_signal_connect(uninstall_skype_button, "clicked",
G_CALLBACK(uninstall_skype), NULL);
g_signal_connect(install_flash_button, "clicked",
G_CALLBACK(install_flash), NULL);
g_signal_connect(uninstall_flash_button, "clicked",
G_CALLBACK(uninstall_flash), NULL);
g_signal_connect(quit_button, "clicked",
G_CALLBACK(gtk_main_quit), G_OBJECT(janela));
//////////////////////////////////////////////////////////////
////The main window(eg. kwin) close button ///////////////////
g_signal_connect_swapped(G_OBJECT(janela), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
////////////////////////////////////////////////////////////////
gtk_main();
/* if(geteuid() != 0){
printf ("Run as root\n");
}else{
printf ("1 - to Erase\n");
printf ("2 - to Install\n");
scanf ("%d", &choose);
switch (choose){
case 1: erase(); break;
case 2: erase(); install(); break;
}
}*/
return 0;
}
void
create_login (HWND hwnd, LPCSTR username, LPCSTR password, LPCSTR dsn,
TLOGIN *log_t)
{
GtkWidget *login;
GtkWidget *dialog_vbox8;
GtkWidget *frame99;
GtkWidget *alignment83;
GtkWidget *table9;
GtkWidget *label165;
GtkWidget *t_user;
GtkWidget *t_password;
GtkWidget *label164;
GtkWidget *dialog_action_area8;
GtkWidget *b_ok;
GtkWidget *b_cancel;
char buff[1024];
if (hwnd == (HWND) - 1L)
{
gtk_init (0, NULL);
hwnd = gtk_window_new (GTK_WINDOW_TOPLEVEL);
}
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return;
login = gtk_dialog_new ();
gtk_widget_set_name (login, "login");
gtk_widget_set_size_request (login, 400, 150);
sprintf (buff, "Login for DSN %s ...", (dsn) ? dsn : "Unknown");
gtk_window_set_title (GTK_WINDOW (login), buff);
gtk_window_set_position (GTK_WINDOW (login), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (login), TRUE);
gtk_window_set_default_size (GTK_WINDOW (login), 400, 150);
gtk_window_set_type_hint (GTK_WINDOW (login), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (login);
#endif
dialog_vbox8 = GTK_DIALOG (login)->vbox;
gtk_widget_set_name (dialog_vbox8, "dialog_vbox8");
gtk_widget_show (dialog_vbox8);
frame99 = gtk_frame_new (NULL);
gtk_widget_set_name (frame99, "frame99");
gtk_widget_show (frame99);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), frame99, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame99), GTK_SHADOW_NONE);
alignment83 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment83, "alignment83");
gtk_widget_show (alignment83);
gtk_container_add (GTK_CONTAINER (frame99), alignment83);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment83), 4, 0, 6, 7);
table9 = gtk_table_new (2, 2, FALSE);
gtk_widget_set_name (table9, "table9");
gtk_widget_show (table9);
gtk_container_add (GTK_CONTAINER (alignment83), table9);
gtk_table_set_row_spacings (GTK_TABLE (table9), 10);
gtk_table_set_col_spacings (GTK_TABLE (table9), 6);
label165 = gtk_label_new (_("Password :"******"label165");
gtk_widget_show (label165);
gtk_table_attach (GTK_TABLE (table9), label165, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label165), 0, 0.5);
t_user = gtk_entry_new ();
gtk_widget_set_name (t_user, "t_user");
gtk_widget_show (t_user);
gtk_table_attach (GTK_TABLE (table9), t_user, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
if (username && STRLEN (username))
gtk_entry_set_text (GTK_ENTRY (t_user), username);
t_password = gtk_entry_new ();
gtk_widget_set_name (t_password, "t_password");
gtk_widget_show (t_password);
gtk_table_attach (GTK_TABLE (table9), t_password, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_visibility (GTK_ENTRY (t_password), FALSE);
if (password && STRLEN (password))
gtk_entry_set_text (GTK_ENTRY (t_password), password);
label164 = gtk_label_new (_("Username :"******"label164");
gtk_widget_show (label164);
gtk_table_attach (GTK_TABLE (table9), label164, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label164), 0, 0.5);
dialog_action_area8 = GTK_DIALOG (login)->action_area;
gtk_widget_set_name (dialog_action_area8, "dialog_action_area8");
gtk_widget_show (dialog_action_area8);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END);
b_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (b_cancel, "b_cancel");
gtk_widget_show (b_cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (login), b_cancel, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
b_ok = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_set_name (b_ok, "b_ok");
gtk_widget_show (b_ok);
gtk_dialog_add_action_widget (GTK_DIALOG (login), b_ok, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (b_ok, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (login, login, "login");
GLADE_HOOKUP_OBJECT_NO_REF (login, dialog_vbox8, "dialog_vbox8");
GLADE_HOOKUP_OBJECT (login, frame99, "frame99");
GLADE_HOOKUP_OBJECT (login, alignment83, "alignment83");
GLADE_HOOKUP_OBJECT (login, table9, "table9");
GLADE_HOOKUP_OBJECT (login, label165, "label165");
GLADE_HOOKUP_OBJECT (login, t_user, "t_user");
GLADE_HOOKUP_OBJECT (login, t_password, "t_password");
GLADE_HOOKUP_OBJECT (login, label164, "label164");
GLADE_HOOKUP_OBJECT_NO_REF (login, dialog_action_area8, "dialog_action_area8");
GLADE_HOOKUP_OBJECT (login, b_ok, "b_ok");
GLADE_HOOKUP_OBJECT (login, b_cancel, "b_cancel");
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_ok), "clicked",
GTK_SIGNAL_FUNC (login_ok_clicked), log_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (login_cancel_clicked), log_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (login), "delete_event",
GTK_SIGNAL_FUNC (delete_event), log_t);
gtk_signal_connect (GTK_OBJECT (login), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
log_t->username = t_user;
log_t->password = t_password;
log_t->user = log_t->pwd = NULL;
log_t->mainwnd = login;
gtk_widget_show_all (login);
gtk_main ();
}
/*
* main
*/
int main (int argc, char *argv[])
{
GdkGLConfig *glConfig;
GtkWidget *mainWindow;
GtkWidget *copterDrawingArea;
extern int optind;
extern int optopt;
extern int opterr;
extern int optreset;
char *optstr="d:m:s:h";
char *sdev = NULL;
int sspeed = -1;
int opt = 0;
/*
* Init argument control
*/
opt = getopt( argc, argv, optstr);
while( opt != -1 ) {
switch( opt ) {
case 'd':
sdev = optarg;
break;
case 'm':
copter_filename = optarg;
case 's':
sspeed = atoi(optarg);
break;
case 'h':
usage();
return 0;
default:
break;
}
opt = getopt(argc, argv, optstr);
}
if (!g_thread_supported ()) {
g_thread_init (NULL);
}
gdk_threads_init ();
gdk_threads_enter ();
/*
* Init GTK+ and GtkGLExt.
*/
gtk_init (&argc, &argv);
gtk_gl_init (&argc, &argv);
/*
* Configure a OpenGL-capable context.
*/
// Try to make it double-buffered.
glConfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_ALPHA | GDK_GL_MODE_DOUBLE);
if (glConfig == NULL)
{
g_print ("Cannot configure a double-buffered context.\n");
g_print ("Will try a single-buffered context.\n");
// If we can't configure a double-buffered context, try for single-buffered.
glConfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_ALPHA);
if (glConfig == NULL)
{
g_critical ("Aargh! Cannot configure any type of OpenGL-capable context. Exiting.\n");
return -1;
}
}
/*
* Load the GTK interface.
*/
theXml = gtk_builder_new ();
gtk_builder_add_from_file (theXml, "amcc.glade", NULL);
if (theXml == NULL)
{
g_critical ("Failed to load an initialise the GTK file.\n");
return -1;
}
/*
* Get the top-level window reference from loaded Glade file.
*/
mainWindow = GTK_WIDGET (gtk_builder_get_object (theXml, "windowMain"));
// Set unassigned widgets to get handled automatically by the window manager.
gtk_container_set_reallocate_redraws (GTK_CONTAINER (mainWindow), TRUE);
/*
* Get the drawing area's reference from the loaded Glade file which we are going to use for OpenGL rendering.
*/
copterDrawingArea = GTK_WIDGET (gtk_builder_get_object (theXml, "copter"));
// Add OpenGL-capability to the drawing area.
gtk_widget_set_gl_capability (copterDrawingArea, glConfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
// Initialise the render mutex.
pthread_mutex_init (&copter_render_mutex, NULL);
/*
* Get the window manager to connect any assigned signals in the loaded Glade file to our coded functions.
*/
gtk_builder_connect_signals (theXml, NULL);
/*
* Init channel graph
*/
graph_init(&acc_graph, mainWindow, 3, 0, acc_graph_callback);
graph_set_channel_name(&acc_graph, 1, "Acc_X");
graph_set_channel_color(&acc_graph, 1, "#FF0000");
graph_set_channel_name(&acc_graph, 2, "Acc_Y");
graph_set_channel_color(&acc_graph, 2, "#00FF00");
graph_set_channel_name(&acc_graph, 3, "Acc_Z");
graph_set_channel_color(&acc_graph, 3, "#0000FF");
gtk_box_pack_start (GTK_BOX(GTK_WIDGET (gtk_builder_get_object (theXml, "vbox2"))),
graph_get_widget(&acc_graph),
TRUE, TRUE, 0); graph_set_data(&acc_graph, 0, 3300);
graph_init(&gyro_graph, mainWindow, 3, 0, gyro_graph_callback);
graph_set_channel_name(&gyro_graph, 1, "Gyro_X");
graph_set_channel_color(&gyro_graph, 1, "#FF0000");
graph_set_channel_name(&gyro_graph, 2, "Gyro_Y");
graph_set_channel_color(&gyro_graph, 2, "#00FF00");
graph_set_channel_name(&gyro_graph, 3, "Gyro_Z");
graph_set_channel_color(&gyro_graph, 3, "#0000FF");
gtk_box_pack_start (GTK_BOX(GTK_WIDGET (gtk_builder_get_object (theXml, "vbox3"))),
graph_get_widget(&gyro_graph),
TRUE, TRUE, 0); graph_set_data(&gyro_graph, 0, 3300);
mx_init(&mx, serial_tx_data, (void*)&serial);
serial_init(&serial, mx_rx_data, &mx);
if (!sdev)
sdev = DEFAULT_SERIAL_DEV;
if (sspeed == -1)
sspeed = 57600;
serial_open(&serial, sdev, sspeed);
/*
* Show main window.
*/
gtk_widget_show (mainWindow);
// attitude init;
attitude_init(&attitude);
// Start the render timer.
g_timeout_add (1000 / 10, render_timer_event, copterDrawingArea);
g_timeout_add (1000 / 10, update_accs_graph, &acc_graph);
g_timeout_add (1000 / 10, update_gyros_graph, &gyro_graph);
// Run the window manager loop.
gtk_main ();
gdk_threads_leave ();
return 0;
}
bool GTK_Get_Password(std::string title, std::string default_label, std::string& pwd, const char* icon)
{
bool succeeded=false;
GtkWidget* dialog;
GtkWidget* entry;
GtkWidget* image;
GtkWidget* label;
GtkWidget* hbox;
GtkWidget* vbox;
//Init GTK
gtk_init(0, NULL);
//Create the dialog box
dialog = gtk_dialog_new_with_buttons(title.c_str(),
GTK_WINDOW(NULL),
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,GTK_RESPONSE_OK,
NULL);
//Create container widgets
hbox = gtk_hbox_new(false, 0);
vbox = gtk_vbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, FALSE, 0);
//Create the image
if(icon!=NULL)
image = gtk_image_new_from_file(icon);
else
image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start(GTK_BOX(hbox), image, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, FALSE, 0);
//Create the label
if(*(customPrompt())!=std::string())
label = gtk_label_new(customPrompt()->c_str());
else
label = gtk_label_new(default_label.c_str());
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, FALSE, 0);
//Create the editbox
entry = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_entry_set_text(GTK_ENTRY(entry), "");
gtk_box_pack_start(GTK_BOX(vbox), entry, TRUE, FALSE, 0);
//Show the widgets
gtk_widget_show_all(GTK_DIALOG(dialog)->vbox);
//Make the dialog sensitive
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
//Launch the dialog box and wait for events
switch (gtk_dialog_run(GTK_DIALOG(dialog)))
{
//User clicked on OK
case GTK_RESPONSE_OK:
pwd = gtk_entry_get_text(GTK_ENTRY(entry));
succeeded=true;
break;
//User clicked on cancel
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_NONE:
default:
succeeded=false;
break;
}
//Destroy the dialog box
gtk_widget_destroy(dialog);
return succeeded;
}
/* Main */
int main(int ac, char *av[])
{
const char *name;
#if 0
char *env;
#endif
gchar *glade_file = GUI_PATH;
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
/* GTK stuffs */
gtk_set_locale();
gtk_init(&ac, &av);
glade_init();
//add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
//add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
#if 0
/* Determine GUI path */
env = getenv(SRCTREE);
if (env)
glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL);
else if (av[0][0] == '/')
glade_file = g_strconcat(av[0], ".glade", NULL);
else
glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL);
#endif
/* Conf stuffs */
if (ac > 1 && av[1][0] == '-') {
switch (av[1][1]) {
case 'a':
//showAll = 1;
break;
case 'h':
case '?':
printf("%s <config>\n", av[0]);
exit(0);
}
name = av[2];
} else
name = av[1];
conf_parse(name);
fixup_rootmenu(&rootmenu);
conf_read(NULL);
/* Load the interface and connect signals */
init_main_window(glade_file);
init_tree_model();
init_left_tree();
init_right_tree();
switch (view_mode) {
case SINGLE_VIEW:
display_tree_part();
break;
case SPLIT_VIEW:
display_list();
break;
case FULL_VIEW:
display_tree(&rootmenu);
break;
}
gtk_main();
return 0;
}
int main(int argc, char **argv){
GtkWidget *pWindow;
GtkWidget *pNotebook;
GtkWidget *pScrollbar;
int fd;
//debug
nbpaquetenqueue = 0;
gtk_init(&argc,&argv);
//reservation memoire des donnees des pages
dpr = (data_page_rule_p)malloc(sizeof(data_page_rule_t));
dfp = (data_front_page_p)malloc(sizeof(data_front_page_t));
dpsr = (data_page_show_rule_p)malloc(sizeof(data_page_show_rule_p));
dw = (data_window_p)malloc(sizeof(data_window_t));
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(pWindow), "VSPF");
gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 400);
g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
pScrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(pWindow),pScrollbar);
// Creation du GtkNotebook
// Position des onglets : en bas
// mise dans la fenetre
pNotebook = gtk_notebook_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScrollbar), pNotebook);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
//on met les donnees de la window dans sa structure
dw->pWindow = pWindow;
dw->pNotebook = pNotebook;
//deplacement
ihm_t ihm;
ihm_p = &ihm;
signal(SIGINT, sigquit);
signal(SIGTERM, sigquit);
signal(SIGQUIT, sigquit);
caract_list_p waiting_caract=caract_list_create();
printf("Etape -3\n");
ihm_p->wai_caract=waiting_caract;
printf("Etape -2\n");
ihm_init(&ihm);
printf("Initialisation finie\n");
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(pNotebook), GTK_POS_BOTTOM);
//gtk_container_add(GTK_CONTAINER(pWindow), pScrollbar);
//gtk_container_add(GTK_CONTAINER(pWindow), pNotebook);
printf("Apres init\n");
//on cree la page frontale
create_front_page(GTK_NOTEBOOK(pNotebook));
//on cree la page des règles et ses donnees ds dpr
create_rule_page_base(GTK_NOTEBOOK(pNotebook));
//on cree la page d'affichage des regles
create_show_rule_page(GTK_NOTEBOOK(pNotebook));
//Partie provenant de ihm.c
printf("Ouverture de %s\n",FIFO_CORE_TO_IHM);
ihm_p->core_to_ihm_fd = open(FIFO_CORE_TO_IHM, O_RDONLY| O_NDELAY);
assert(ihm_p->core_to_ihm_fd >= 0);
printf("Fichier %s ouvert\n",FIFO_CORE_TO_IHM);
//fd = open("./fifo_test", O_RDONLY);
//printf("Bibi %d\n", fd);
printf("Etape 1\n");
gtk_widget_show_all(pWindow);
printf("Etape 2\n");
pipe_tag = gdk_input_add( ihm_p->core_to_ihm_fd,GDK_INPUT_READ,input_callback,NULL);
printf("Etape 3\n");
gtk_main();
printf("Etape 4\n");
return EXIT_SUCCESS;
}
int
main (int argc,
char** argv)
{
GtkWidget* window;
GdkRGBA transparent = {0.0, 0.0, 0.0, 0.0};
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (!window)
return 0;
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_add_events (window,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
// hook up input/event handlers to window
g_signal_connect (G_OBJECT (window),
"screen-changed",
G_CALLBACK (screen_changed_handler),
NULL);
g_signal_connect (G_OBJECT (window),
"composited-changed",
G_CALLBACK (composited_changed_handler),
NULL);
gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y);
// make sure the window opens with a RGBA-visual
screen_changed_handler (window, NULL, NULL);
gtk_widget_realize (window);
gdk_window_set_background_rgba (gtk_widget_get_window (window),
&transparent);
// hook up window-event handlers to window
g_signal_connect (G_OBJECT (window),
"draw",
G_CALLBACK (expose_handler),
NULL);
// FIXME: read out current mouse-pointer position every 1/25 second
g_timeout_add (1000/40,
(GSourceFunc) pointer_update,
(gpointer) window);
g_timeout_add (10000,
(GSourceFunc) quit,
NULL);
g_timeout_add (1000/40,
(GSourceFunc) grow,
(gpointer) window);
// "clear" input-mask, set title/icon/attributes
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
gtk_window_set_opacity (GTK_WINDOW (window), 1.0f);
gtk_widget_set_size_request (window,
(gint) (BUBBLE_WIDTH + 2.0f *
BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f *
BUBBLE_SHADOW_SIZE));
gtk_widget_show (window);
g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window));
update_input_shape (window, 1, 1);
update_shape (window,
(gint) CORNER_RADIUS,
(gint) BUBBLE_SHADOW_SIZE);
set_bg_blur (window, TRUE);
setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE));
g_print ("This test will run for 10 seconds and then quit.\n");
gtk_main ();
tile_destroy (g_tile);
return 0;
}
int
main (int argc, char *argv [])
{
/*Running Shell*/
GError *error = NULL;
python_shell_data = g_try_malloc (sizeof (ChildProcessData));
python_shell_data->argv = NULL;
python_shell_data->slave_termios = g_try_malloc (sizeof (struct termios));
python_shell_data->current_dir = NULL;
bash_loaded = ptyFork (python_shell_data, &error);
gtk_init (&argc, &argv);
python_shell_data->channel = g_io_channel_unix_new (python_shell_data->master_fd);
g_io_add_watch (python_shell_data->channel, G_IO_IN,
(GIOFunc)read_masterFd, &(python_shell_data->master_fd));
/**********/
/*Loading Options*/
if (g_file_test ("./options.inf", G_FILE_TEST_EXISTS))
load_options_from_file ("./options.inf");
else
{
options.indent_width = 4;
options.tab_width = 4;
options.is_code_completion = TRUE;
options.is_code_folding = TRUE;
options.show_line_numbers = TRUE;
options.font_name = "Liberation Mono";
}
/*************/
options.python_shell_path = "/usr/bin/python";
options.comment_out_str = "##";
options.indent_width_str = " ";
options.tab_width_str = " ";
env_python_path = "";
gchar **p = options.env_vars;
if (p)
{
while (*p)
{
gchar *s = g_strstr_len (*p, -1, "PYTHONPATH=");
if (s)
{
env_python_path = s + strlen ("PYTHONPATH=");
break;
}
p++;
}
}
/*Get sys.path*/
char *sys_path_argv[] = {"python", "./scripts/path.py", NULL};
g_spawn_sync (NULL, sys_path_argv, NULL, G_SPAWN_SEARCH_PATH,
NULL, NULL, &sys_path_string, NULL, NULL, NULL);
/***********/
char *_str = g_strconcat (sys_path_string, "\n", env_python_path, NULL);
g_free (sys_path_string);
sys_path_string = _str;
file_monitor = file_monitor_new (file_monitor_changed);
/*Setting Main Window*/
GtkWidget *navigate_bookmarks;
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, "./ui/main.ui", NULL);
content_box = GTK_WIDGET (gtk_builder_get_object (builder, "content_box"));
window = gtk_builder_get_object (builder, "main_window");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
path_browser = path_browser_new ();
g_object_ref (path_browser);
proj_notebook = project_notebook_new ();
/**Setting proj_syms_tree_view**/
symbols_view = symbols_view_new ();
g_object_ref (symbols_view);
/*************************/
content_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
g_object_ref (content_paned);
status_bar = gtk_statusbar_new ();
g_object_ref (status_bar);
gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook),
symbols_view, gtk_label_new ("Symbols"));
gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook),
path_browser,
gtk_label_new ("Paths"));
navigate_bookmarks = GTK_WIDGET (gtk_builder_get_object (builder,
"navigate_bookmarks"));
bookmarks_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (navigate_bookmarks),
bookmarks_menu);
GtkAccelGroup *accelgroup = GTK_ACCEL_GROUP (gtk_builder_get_object (builder,
"accelgroup"));
/*Connecting menu item's signals*/
//For File Menu
g_signal_connect (gtk_builder_get_object (builder, "file_new"), "activate",
G_CALLBACK (file_new_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_new_tab"), "activate",
G_CALLBACK (file_new_tab_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_open"), "activate",
G_CALLBACK (file_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "recentchoosermenu"), "selection-done",
G_CALLBACK (file_recent_menu_selection_done), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save"), "activate",
G_CALLBACK (file_save_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_as"), "activate",
G_CALLBACK (file_save_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_copy_as"), "activate",
G_CALLBACK (file_save_copy_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_all"), "activate",
G_CALLBACK (file_save_all_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_close_tab"), "activate",
G_CALLBACK (file_close_tab_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_close_all_tabs"), "activate",
G_CALLBACK (file_close_all_tabs_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_quit"), "activate",
G_CALLBACK (file_quit_activate), NULL);
//For Edit Menu
g_signal_connect (gtk_builder_get_object (builder, "edit_undo"), "activate",
G_CALLBACK (edit_undo_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_redo"), "activate",
G_CALLBACK (edit_redo_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_cut"), "activate",
G_CALLBACK (edit_cut_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_copy"), "activate",
G_CALLBACK (edit_copy_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_paste"), "activate",
G_CALLBACK (edit_paste_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_delete"), "activate",
G_CALLBACK (edit_delete_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_all"), "activate",
G_CALLBACK (edit_select_all_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_function"), "activate",
G_CALLBACK (edit_select_function_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_block"), "activate",
G_CALLBACK (edit_select_block_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_fold_all_func"), "activate",
G_CALLBACK (edit_fold_all_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_unfold_all_func"), "activate",
G_CALLBACK (edit_unfold_all_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_fold_current_func"), "activate",
G_CALLBACK (edit_fold_current_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_autocomplete"), "activate",
G_CALLBACK (edit_autocomplete_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_matching_paranthesis"), "activate",
G_CALLBACK (edit_matching_paranthesis_activate), NULL);
//For Format Menu
g_signal_connect (gtk_builder_get_object (builder, "format_inc_indent"), "activate",
G_CALLBACK (format_inc_indent_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_inc_indent")),
"activate", accelgroup, GDK_KEY_bracketright,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_dec_indent"), "activate",
G_CALLBACK (format_dec_indent_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_dec_indent")),
"activate", accelgroup, GDK_KEY_bracketleft,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_comment_out"), "activate",
G_CALLBACK (format_comment_out_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_comment_out")),
"activate", accelgroup, GDK_KEY_3,
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_uncomment_out"), "activate",
G_CALLBACK (format_uncomment_out_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_uncomment_out")),
"activate", accelgroup, GDK_KEY_4,
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_tabify_region"), "activate",
G_CALLBACK (format_tabify_region_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_untabify_region"), "activate",
G_CALLBACK (format_untabify_region_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_uppercase"), "activate",
G_CALLBACK (format_uppercase_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_lowercase"), "activate",
G_CALLBACK (format_lowercase_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_strip_spaces"), "activate",
G_CALLBACK (format_strip_spaces_activate), NULL);
//For Search Menu
g_signal_connect (gtk_builder_get_object (builder, "search_find"), "activate",
G_CALLBACK (search_find_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_next"), "activate",
G_CALLBACK (search_find_next_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_prev"), "activate",
G_CALLBACK (search_find_prev_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_replace"), "activate",
G_CALLBACK (search_find_replace_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_selected"), "activate",
G_CALLBACK (search_find_selected_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_in_text"), "activate",
G_CALLBACK (search_find_in_text_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_file"), "activate",
G_CALLBACK (search_find_file_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_replace_file"), "activate",
G_CALLBACK (search_replace_file_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_reg_exp"), "activate",
G_CALLBACK (search_reg_exp_activate), NULL);
//For Navigation Menu
g_signal_connect (gtk_builder_get_object (builder, "navigate_back"), "activate",
G_CALLBACK (navigate_back_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_forward"), "activate",
G_CALLBACK (navigate_forward_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_first_line"), "activate",
G_CALLBACK (navigate_first_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_last_line"), "activate",
G_CALLBACK (navigate_last_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_line_history"), "select",
G_CALLBACK (navigate_line_history_select), NULL);
g_signal_connect (gtk_builder_get_object (builder, "naviagate_add_bookmark"), "activate",
G_CALLBACK (naviagate_add_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "naviagate_clear_bookmarks"), "activate",
G_CALLBACK (naviagate_clear_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_prev_bookmarks"), "activate",
G_CALLBACK (navigate_prev_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_next_bookmark"), "activate",
G_CALLBACK (navigate_next_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_bookmarks"), "activate",
G_CALLBACK (navigate_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_line"), "activate",
G_CALLBACK (navigate_go_to_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_block_start"), "activate",
G_CALLBACK (navigate_go_to_block_start_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_func_def"), "activate",
G_CALLBACK (navigate_go_to_func_def_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_next_func"), "activate",
G_CALLBACK (navigate_go_to_next_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_prev_func"), "activate",
G_CALLBACK (navigate_go_to_prev_func_activate), NULL);
//For Project Menu
g_signal_connect (gtk_builder_get_object (builder, "project_new"), "activate",
G_CALLBACK (project_new_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_open"), "activate",
G_CALLBACK (project_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save"), "activate",
G_CALLBACK (project_save_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save_as"), "activate",
G_CALLBACK (project_save_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save_copy_as"), "activate",
G_CALLBACK (project_save_copy_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_empty"), "activate",
G_CALLBACK (project_empty_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_close"), "activate",
G_CALLBACK (project_close_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_preferences"), "activate",
G_CALLBACK (project_preferences_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_recent"), "activate",
G_CALLBACK (project_recent_activate), NULL);
//For Python Shell Menu
g_signal_connect (gtk_builder_get_object (builder, "python_shell_open"), "activate",
G_CALLBACK (python_shell_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "python_shell_restart"), "activate",
G_CALLBACK (python_shell_restart_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "python_shell_close"), "activate",
G_CALLBACK (python_shell_close_activate), NULL);
//For Run Menu
g_signal_connect (gtk_builder_get_object (builder, "run_run_script"), "activate",
G_CALLBACK (run_run_script_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_debug_script"), "activate",
G_CALLBACK (run_debug_script_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_run_project"), "activate",
G_CALLBACK (run_run_project_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_debug_project"), "activate",
G_CALLBACK (run_debug_project_activate), NULL);
//For Debug Menu
g_signal_connect (gtk_builder_get_object (builder, "debug_open_pdb_shell"), "activate",
G_CALLBACK (debug_open_pdb_shell_activate), NULL);
//For Tools Menu
g_signal_connect (gtk_builder_get_object (builder, "tools_options"), "activate",
G_CALLBACK (tools_options_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "tools_auto_indent"), "activate",
G_CALLBACK (tools_auto_indent_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "tools_class_browser"), "activate",
G_CALLBACK (tools_class_browser_activate), NULL);
/*************************/
/**Connecting Toolbar's signals**/
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_menu"), "clicked",
G_CALLBACK (toolbar_new_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_file"), "activate",
G_CALLBACK (toolbar_new_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_project"), "activate",
G_CALLBACK (toolbar_new_proj_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_menu"), "clicked",
G_CALLBACK (toolbar_open_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_file"), "activate",
G_CALLBACK (toolbar_open_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_project"), "activate",
G_CALLBACK (toolbar_open_proj_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_menu"), "clicked",
G_CALLBACK (toolbar_save_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_file"), "activate",
G_CALLBACK (toolbar_save_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_project"), "activate",
G_CALLBACK (toolbar_save_project_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as"), "clicked",
G_CALLBACK (toolbar_save_as_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_file"), "activate",
G_CALLBACK (toolbar_save_as_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_project"), "activate",
G_CALLBACK (toolbar_save_as_project_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_undo"), "clicked",
G_CALLBACK (toolbar_undo_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_redo"), "clicked",
G_CALLBACK (toolbar_redo_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_cut"), "clicked",
G_CALLBACK (toolbar_cut_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_copy"), "clicked",
G_CALLBACK (toolbar_copy_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_paste"), "clicked",
G_CALLBACK (toolbar_cut_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_delete"), "clicked",
G_CALLBACK (toolbar_delete_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_select_all"), "clicked",
G_CALLBACK (toolbar_select_all_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_find"), "clicked",
G_CALLBACK (toolbar_find_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_find_replace"), "clicked",
G_CALLBACK (toolbar_find_replace_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_inc_indent"), "clicked",
G_CALLBACK (toolbar_inc_indent_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_dec_indent"), "clicked",
G_CALLBACK (toolbar_dec_indent_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_line"), "clicked",
G_CALLBACK (navigate_forward_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_line"), "clicked",
G_CALLBACK (navigate_back_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_add_bookmark"), "clicked",
G_CALLBACK (naviagate_add_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_bookmark"), "clicked",
G_CALLBACK (navigate_next_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_bookmark"), "clicked",
G_CALLBACK (navigate_prev_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_clear_bookmark"), "clicked",
G_CALLBACK (naviagate_clear_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_run"), "clicked",
G_CALLBACK (toolbar_run), NULL);
/*g_signal_connect (gtk_builder_get_object (builder, "toolbar_debug"), "clicked",
G_CALLBACK (toolbar_dec_indent_clicked), NULL); */
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_shell"), "clicked",
G_CALLBACK (python_shell_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_options"), "clicked",
G_CALLBACK (tools_options_activate), NULL);
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_add_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksadd.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_next_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksnext.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_prev_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksprev.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_clear_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksclear.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_debug")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/debug.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_open_shell")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/python_shell.png",NULL)));
/*************************/
line_history_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (builder, "navigate_line_history")),
line_history_menu);
GtkRecentFilter *py_recent_filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (py_recent_filter, "Python Files");
gtk_recent_filter_add_pattern (py_recent_filter, "*.py");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (gtk_builder_get_object (builder, "recentchoosermenu")),
py_recent_filter);
/* Connecting window's signals and events */
g_signal_connect (window, "delete-event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (main_window_destroy), NULL);
/********************************/
/*Other global variables*/
search_text = NULL;
bookmark_array= NULL;
bookmark_array_size = 0;
current_bookmark_index = -1;
/******************/
/*Initialize Regular Expressions*/
regex_class = g_regex_new ("[ \\ \\t]*\\bclass\\b\\s*\\w+\\s*\\(*.*\\)*:", 0, 0, NULL);
regex_func = g_regex_new ("[ \\ \\t]*def\\s+[\\w\\d_]+\\s*\\(.+\\)\\:", 0, 0, NULL);
/*Regex if you don't want to search imports with in indentation*/
/*regex_import = g_regex_new ("^import\\s+[\\w\\d_\\.]+", 0, 0, NULL);
regex_import_as = g_regex_new ("^import\\s+[\\w\\d_\\.]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);*/
regex_from_import = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+", 0, 0, NULL);
regex_from_import_as = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+as\\s+[\\w\\d_]", 0, 0, NULL);
regex_global_var = g_regex_new ("^[\\w\\d_]+\\s*=\\s*[\\w\\d_]+\\s*\\(.+\\)", 0, 0, NULL);
regex_static_var = g_regex_new ("^\\s*[\\w\\d_]+\\s*=.+", 0, 0, NULL);
regex_word = g_regex_new ("[self]*[\\w\\d_\\.]+$", 0, 0, NULL);
regex_local_var = g_regex_new ("^\\s*[\\w\\d_\\.]+\\s*=.+", 0, 0, NULL);
regex_self_var = g_regex_new ("^\\s+self\\.[\\w\\d_]+\\s*=.+", 0, 0, NULL);
/*Regex if you want to search imports with in indentation*/
regex_import = g_regex_new ("^\\s*import\\s+[\\w\\d_\\.]+", 0, 0, NULL);
regex_import_as = g_regex_new ("^\\s*import\\s+[\\w\\d_]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);
/***********************/
async_queue = g_async_queue_new ();
//Creating code_widget_array
//code_widget_array = g_malloc0 (1*sizeof (CodeWidget *));
//code_widget_array [0] = codewidget_new ();
code_widget_array_size = 0;
notebook = gtk_notebook_new ();
g_object_ref (notebook);
//gtk_notebook_append_page (GTK_NOTEBOOK (notebook), code_widget_array [0]->vbox,
// gtk_label_new ("New File"));
/*If bash is not loaded*/
if (!bash_loaded)
{
gchar *msg = g_strdup_printf ("Cannot run Python Shell (%s)", error->message);
gtk_statusbar_push (GTK_STATUSBAR (status_bar), 0, msg);
g_free (msg);
g_error_free (error);
}
/****************/
GtkSettings *settings = gtk_settings_get_default ();
g_object_set (settings, "gtk-application-prefer-dark-theme", TRUE, NULL);
gtk_window_maximize (GTK_WINDOW (window));
gtk_widget_show_all (GTK_WIDGET (window));
gtk_main ();
return 0;
}
