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; }