int main(int argc, char *argv[])
{
#ifdef DEBUG
gtk_init(&argc, &argv);
gtk_gl_init(&argc, &argv);
#else
gtk_init(NULL, NULL);
gtk_gl_init(NULL, NULL);
#endif
setup_splash();
splash("Starting up...");
// Init logfile
FILE* f = fopen("slade.log", "wt");
fclose(f);
load_main_config();
init_console();
setup_icons();
log_message("Init textures...\n");
init_textures();
log_message("Loading colour configurations...\n");
load_colour_configs();
string ccfg = col_config;
set_colour_config(ccfg);
log_message("Setup editor window...\n");
setup_editor_window();
log_message("Setup wad manager window...\n");
splash_hide();
setup_main_window();
log_message("Init OK.\n");
open_main_window();
// Setup gl font
//font_list = glGenLists(256);
//PangoFontDescription *font_desc = pango_font_description_from_string("Monospace 10");
//gdk_gl_font_use_pango_font(font_desc, 0, 255, font_list);
gtk_main();
save_main_config();
return 0;
}
bool
GtkGlExtGlue::init(int argc, char** argv[])
{
// GNASH_REPORT_FUNCTION;
gtk_gl_init (&argc, argv);
gint major, minor;
gdk_gl_query_version (&major, &minor);
log_debug ("OpenGL extension version - %d.%d", (int)major, (int)minor);
GdkGLConfigMode glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_DOUBLE |
GDK_GL_MODE_ACCUM);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("Cannot find the double-buffered visual.\n"
"Trying single-buffered visual."));
glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("No appropriate OpenGL-capable visual found."));
gtk_main_quit(); // XXX
} else {
log_debug ("Got single-buffered visual.");
}
} else {
log_debug ("Got double-buffered visual.");
}
return true;
}
int window_system_initialise(int argc, char ***argv)
{
gtk_init(&argc, argv);
gtk_gl_init(&argc, argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW (window), DEFAULT_WIN_WIDTH, DEFAULT_WIN_HEIGHT);
drawing_area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), drawing_area);
g_signal_connect_swapped(window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK);
gl_config = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (!gl_config) {
printf("Messed up the config :(\n");
exit(1);
}
if (!gtk_widget_set_gl_capability(drawing_area, gl_config, NULL, TRUE,
GDK_GL_RGBA_TYPE)) {
printf("Couldn't get capabilities we needed :(\n");
exit(1);
}
return 0;
}
int main(int argc, char **argv) {
GtkWidget *window;
GtkWidget *da;
gtk_init (&argc, &argv);
gtk_gl_init (&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW (window), 800, 600);
da = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER (window), da);
g_signal_connect_swapped(window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events(da, GDK_EXPOSURE_MASK);
set_up_graphics(da);
for(int i = 0; i < 57; i ++) increment_duration(1);
for(int i = 0; i < 10; i ++) increment_duration(127);
for(int i = 0; i < 234; i ++) increment_duration(12);
for(int i = 0; i < 115; i ++) increment_duration(15);
gtk_widget_show (window);
gtk_widget_show_all (window);
g_timeout_add(16, rotate, da);
gtk_main ();
}
int luaopen_lgob_gtkglext(lua_State *L)
{
luaL_loadstring(L, "require('lgob.gtk')"); lua_call(L, 0, 0);
luaL_loadstring(L, "glib.handle_log('GtkGLExt')"); lua_call(L, 0, 0);
gtk_gl_init(NULL, NULL);
luaL_register(L, "gtkglext", gtkglext);
luaL_loadstring(L, "gtkglext.Object = gobject.Object"); lua_call(L, 0, 0);
/* Register the classes */
register_class(L, "Config", "Object", config);
register_class(L, "Widget", "Object", widget);
register_class(L, "Drawable", NULL, drawable);
/* Register special class table */
lua_getfield(L, LUA_REGISTRYINDEX, "lgobSpecial");
lua_pushliteral(L, "GdkGLWindowImplX11"); lua_getfield(L, -3, "Drawable"); lua_rawset(L, -3);
lua_pushliteral(L, "GdkGLWindowImplWin32"); lua_getfield(L, -3, "Drawable"); lua_rawset(L, -3);
lua_pop(L, 1);
/* GdkGLConfigMode */
lua_pushliteral(L, "MODE_RGB"); lua_pushinteger(L, GDK_GL_MODE_RGB); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_RGBA"); lua_pushinteger(L, GDK_GL_MODE_RGBA); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_SINGLE"); lua_pushinteger(L, GDK_GL_MODE_SINGLE); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_INDEX"); lua_pushinteger(L, GDK_GL_MODE_INDEX); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_DOUBLE"); lua_pushinteger(L, GDK_GL_MODE_DOUBLE); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_STEREO"); lua_pushinteger(L, GDK_GL_MODE_STEREO); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_ALPHA"); lua_pushinteger(L, GDK_GL_MODE_ALPHA); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_DEPTH"); lua_pushinteger(L, GDK_GL_MODE_DEPTH); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_STENCIL"); lua_pushinteger(L, GDK_GL_MODE_STENCIL); lua_rawset(L, -3);
lua_pushliteral(L, "MODE_ACCUM"); lua_pushinteger(L, GDK_GL_MODE_ACCUM); lua_rawset(L, -3);
return 1;
}
int
main (int argc,
char *argv[])
{
unicap_handle_t handle;
unicap_format_t format;
/* Initialize */
gtk_init (&argc, &argv);
g_thread_init(NULL);
gdk_threads_init ();
gtk_gl_init (&argc, &argv);
init_extensions ();
init_gl_resources ();
handle = open_device();
set_format( handle );
unicap_get_format( handle, &format );
if( ( format.size.width != 640 ) ||
( format.size.height != 480 ) )
{
g_warning( "The default .cg file assumes a video format of 640x480 pixels. \nYou need to change the yuv.cg file to match your size.\n" );
}
prepare_yuv_buffer(&yuvbuffer, &format);
unicap_register_callback( handle, UNICAP_EVENT_NEW_FRAME, (unicap_callback_t)new_frame_cb, NULL );
unicap_start_capture( handle );
/* Gtk window & container */
GtkWindow *window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
glarea = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (glarea), WINDOW_WIDTH, WINDOW_HEIGHT);
g_signal_connect (glarea, "expose-event", G_CALLBACK (on_expose), NULL);
g_signal_connect (glarea, "configure-event", G_CALLBACK (on_configure), NULL);
g_signal_connect (glarea, "map-event", G_CALLBACK (on_mapped), NULL);
g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
GdkGLConfig *gl_config;
gl_config = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE);
if (gl_config == NULL)
g_critical ("Failed to setup a double-buffered RGB visual");
if (! gtk_widget_set_gl_capability (GTK_WIDGET (glarea),
gl_config,
NULL,
TRUE,
GDK_GL_RGBA_TYPE))
g_critical ("Failed to add gl capability");
gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (glarea));
gtk_widget_show_all (GTK_WIDGET (window));
/* Main loop */
gtk_main ();
return 0;
}
void GTKGL::GTKInit(int argc, char **argv)
{
if (init == false)
{
GTK::GTKInit(argc, argv);
gtk_gl_init(&argc, &argv);
}
}
int
main(int argc,
char **argv)
{
/* initialize gtk */
gtk_init(&argc, &argv);
/* initialize gtkglext */
gtk_gl_init(&argc, &argv);
/* Configure OpenGL-capable visual. */
/* Try double-buffered visual */
glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print("*** Cannot find the double-buffered visual.\n");
g_print("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print("*** No appropriate OpenGL-capable visual found.\n");
exit(1);
}
}
/* help? */
if (argc >= 2 && strcmp(argv[1],"--help")==0)
{
g_print("%s", help_text);
return 0;
}
if (argc == 1)
{
/* no filenames, show filerequester */
select_lwobject();
}
else
{
/* show requested files */
int i;
for (i=1; i<argc; i++)
show_lwobject(argv[i]);
}
if (window_count > 0)
gtk_main();
return 0;
}
int main(int argc, char **argv) {
Editor *editor;
gtk_init(&argc, &argv);
gtk_gl_init(&argc, &argv);
editor = editor_new();
gtk_main();
}
int main( int argc, char** argv )
{
gtk_init( &argc, &argv );
gtk_gl_init( &argc, &argv );
MainWindow* mainWindow = new MainWindow();
gtk_main();
return 0;
}
int main( int argc, char** argv )
{
gtk_init( &argc, &argv );
gtk_gl_init( &argc, &argv );
glutInit( &argc, argv );
MainWindow* window = new MainWindow();
window->show();
return 0;
}
int
main (int argc, char **argv)
{
RunAllTests();
GtkWidget *window;
GtkWidget *da;
GdkGLConfig *glconfig;
gtk_init (&argc, &argv);
gtk_gl_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
da = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), da);
g_signal_connect_swapped (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events (da, GDK_EXPOSURE_MASK);
gtk_widget_show (window);
/* prepare GL */
glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)
(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE));
if (!glconfig)
{
g_assert_not_reached ();
}
if (!gtk_widget_set_gl_capability (da, glconfig, NULL, TRUE,
GDK_GL_RGBA_TYPE))
{
g_assert_not_reached ();
}
g_signal_connect (da, "configure-event",
G_CALLBACK (configure), NULL);
g_signal_connect (da, "expose-event",
G_CALLBACK (expose), NULL);
gtk_widget_show_all (window);
g_timeout_add (1000 / 30, rotate, da);
t3dInit();
gtk_main ();
}
int main (int argc, char *argv[]) {
GtkWidget * window, * warning;
char locale[3];
const char * lang = pango_language_to_string (gtk_get_default_language ());
locale[0] = lang[0];
locale[1] = lang[1];
locale[2] = '\0';
setlocale(LC_ALL, "");
char * lng = setlocale(LC_MESSAGES, "");
g_debug("setlocale(LC_MESSAGES, \"%s\") = %s", locale, lng);
lng = setlocale(LC_NUMERIC, "C");
g_debug("setlocale(LC_NUMERIC, \"C\") = %s", lng);
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, saa_locale_directory());
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain (PACKAGE);
printf("%s : %s ; %s\n", PACKAGE, saa_locale_directory(), locale);
#endif
//gtk_disable_setlocale();
gtk_init (&argc, &argv);
//printf("setlocale(LC_ALL, NULL) :\n%s\n", setlocale(LC_ALL, NULL));
gtk_gl_init (&argc, &argv);
switch(argc) {
case 1:
window = saa_main_window_new("");
break;
case 2:
window = saa_main_window_new(argv[1]);
break;
default:
window = saa_main_window_new("");
warning = gtk_message_dialog_new (GTK_WINDOW(window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_CLOSE,
"usage : gsolaar [solid.saa]\n");
gtk_dialog_run(GTK_DIALOG(warning));
gtk_widget_destroy(warning);
}
gtk_widget_show (window);
gtk_main();
gtk_widget_destroy(window);
return 0;
}
void Interface_iniciar() {
GtkWidget *window;
GdkGLConfig *glconfig;
gtk_init(NULL, NULL);
gtk_gl_init(NULL, NULL);
GtkBuilder *builderPrincipal=Interface_carregarXML(INTERFACE_PRINCIPAL);
window = GTK_WIDGET(gtk_builder_get_object (builderPrincipal, "window"));
drawOpengl=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "drawOpengl"));
frameProgresso=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameProgresso"));
progress=GTK_PROGRESS_BAR(gtk_builder_get_object(builderPrincipal, "progressbar"));
labelPosicaoXY=GTK_LABEL(gtk_builder_get_object(builderPrincipal, "labelPosicaoXY"));
ajustScrollHorizGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL"));
ajustScrollVertGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL"));
adjustAlpha=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "adjustAlpha"));
tbAddEntidade=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddEntidade"));
tbAddImagem=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddImagem"));
tbAddTexto=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddTexto"));
tbAmpliar=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAmpliar"));
tbReduzir=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbReduzir"));
frameFerramentas=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameFerramentas"));
/*gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL")),500);
gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL")),500);*/
//Configura widget para opengl
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (!glconfig) {
g_print ("*** Cannot find the double-buffered visual.\n");
g_print ("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
if (!glconfig) {
g_print ("*** No appropriate OpenGL-capable visual found.\n");
g_assert_not_reached();
}
}
if (!gtk_widget_set_gl_capability(drawOpengl, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
g_assert_not_reached();
gtk_builder_connect_signals(builderPrincipal, NULL);
gtk_widget_show(window);
g_object_unref(G_OBJECT(builderPrincipal));
}
int main(int argc, char *argv[])
{
MainWindow* mainWin = MainWindow_new();
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
gtk_init (&argc, &argv);
gtk_gl_init (&argc, &argv);
MainWindow_presentation(mainWin);
gtk_main();
MainWindow_destroy(mainWin);
Global_destroy();
return EXIT_SUCCESS;
}
static gboolean
__init ()
{
dbg(2, "...");
if(!gl_context){
gtk_gl_init(NULL, NULL);
if(wf_debug){
gint major, minor;
gdk_gl_query_version (&major, &minor);
g_print ("GtkGLExt version %d.%d\n", major, minor);
}
}
glconfig = gdk_gl_config_new_by_mode( GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE );
if (!glconfig) { gerr ("Cannot initialise gtkglext."); return false; }
return true;
}
bool
GtkGlExtGlue::init(int argc, char** argv[])
{
// GNASH_REPORT_FUNCTION;
#ifdef FIX_I810_LOD_BIAS
int c = getopt (argc, *argv, "m:");
if (c == 'm') {
_tex_lod_bias = (float) strtof(optarg, NULL);
}
#endif
gtk_gl_init (&argc, argv);
gint major, minor;
gdk_gl_query_version (&major, &minor);
log_debug (_("OpenGL extension version - %d.%d"),
(int)major, (int)minor);
GdkGLConfigMode glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_DOUBLE |
GDK_GL_MODE_ACCUM);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("Cannot find the double-buffered visual.\n"
"Trying single-buffered visual."));
glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("No appropriate OpenGL-capable visual found."));
gtk_main_quit(); // XXX
} else {
log_debug (_("Got single-buffered visual."));
}
} else {
log_debug (_("Got double-buffered visual."));
}
return true;
}
int main(int argc, char *argv[]) {
struct configured_features my_config;
init_configured_features( &my_config);
if (!g_thread_supported())
g_thread_init( NULL);
gtk_init(&argc, &argv);
#ifdef GTKGLEXT_AVAILABLE
gtk_gl_init( &argc, &argv);
#endif
if ( !fill_configured_features( &my_config, argc, argv)) {
exit(0);
}
return common_gtk_glade_main( &my_config);
}
CV_IMPL int cvInitSystem( int argc, char** argv )
{
static int wasInitialized = 0;
// check initialization status
if( !wasInitialized )
{
hg_windows = 0;
gtk_disable_setlocale();
gtk_init( &argc, &argv );
#ifdef HAVE_OPENGL
gtk_gl_init(&argc, &argv);
#endif
wasInitialized = 1;
}
return 0;
}
int
main (int argc,
char *argv[])
{
GtkWidget *window;
GdkGLConfig *glconfig;
/* Initialize GTK. */
gtk_init (&argc, &argv);
/* Initialize GtkGLExt. */
gtk_gl_init (&argc, &argv);
/* Configure OpenGL framebuffer. */
glconfig = configure_gl ();
/* Create and show the application window. */
window = create_window (glconfig);
gtk_widget_show (window);
gtk_main ();
return 0;
}
int
main (int argc,
char *argv[])
{
GdkGLConfig *glconfig;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *drawing_area;
GtkWidget *button;
int i;
/*
* Init GTK.
*/
gtk_init (&argc, &argv);
/*
* Init GtkGLExt.
*/
gtk_gl_init (&argc, &argv);
/*
* Command line options.
*/
for (i = 0; i < argc; i++)
{
if (strcmp (argv[i], "--async") == 0)
is_sync = FALSE;
}
/*
* Configure OpenGL-capable visual.
*/
/* Try double-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print ("*** Cannot find the double-buffered visual.\n");
g_print ("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
}
/*
* Top-level window.
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "gears");
/* Get automatically redrawn if any of their children changed allocation. */
gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
/*
* VBox.
*/
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/*
* Drawing area for drawing OpenGL scene.
*/
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 300, 300);
/* Set OpenGL-capability to the widget. */
gtk_widget_set_gl_capability (drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
gtk_widget_add_events (drawing_area,
GDK_VISIBILITY_NOTIFY_MASK);
g_signal_connect_after (G_OBJECT (drawing_area), "realize",
G_CALLBACK (init), NULL);
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (reshape), NULL);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (draw), NULL);
g_signal_connect (G_OBJECT (drawing_area), "map_event",
G_CALLBACK (map), NULL);
g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
G_CALLBACK (unmap), NULL);
g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
G_CALLBACK (visible), NULL);
g_signal_connect_swapped (G_OBJECT (window), "key_press_event",
G_CALLBACK (key), drawing_area);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/*
* Simple quit button.
*/
button = gtk_button_new_with_label ("Quit");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_main_quit), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/*
* Show window.
*/
gtk_widget_show (window);
/*
* Main loop.
*/
//idle_add (drawing_area);
gtk_main ();
return 0;
}
/*
* The main function.
*/
int
main(int argc, char *argv[])
{
char *openThisFile = argv[argc - 1];
if (! parseCmdlineParameters(argc, argv) ) {
printCmdlineUsage();
return 0;
}
if (argc < 2) {
openThisFile = NULL;
} else if (! fileExists(openThisFile) ) {
fprintf(stderr, "Sprite bank file not found.\n");
printCmdlineUsage();
return -1;
}
// On Windows, change to the program directory to
// make sure the necessary resource files are found:
winChangeToProgramDir(argv[0]);
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);
spriteBankEditor = new SludgeSpriteBankEditor();
/*
* Get the window manager to connect any assigned signals in the loaded Glade file to our coded functions.
*/
gtk_builder_connect_signals(spriteBankEditor->theXml, NULL);
/*
* Show the window.
*/
gtk_widget_show(spriteBankEditor->theWindow);
// Start the render timer.
g_timeout_add(10000 / 60, render_timer_event, spriteBankEditor->theDrawingarea);
if (openThisFile != NULL) {
spriteBankEditor->open(openThisFile);
}
// Run the window manager loop.
if (spriteBankEditor->initSuccess)
gtk_main();
delete spriteBankEditor;
gdk_threads_leave();
return 0;
}
int test(char** argv)
{
int argc = 1;
static APPLICATION application = {0};
static APPLICATION_LABELS labels =
{
"English",
{"OK", "Apply", "Cancel", "Normal", "Reverse", "Edit Selection", "Window",
"Close Window", "Dock Left", "Dock Right", "Full Screen", "Reference Image Window",
"Move Top Left", "Hot Key", "Loading...", "Saving..."},
{"pixel", "Length", "Angle", "_BG", "Loop", "Preview", "Interval", "minute", "Detail", "Target",
"Clip Board", "Name", "Type", "Resolution", "Center", "Straight", "Grow", "Mode", "Red", "Green", "Blue",
"Cyan", "Magenta", "Yellow", "Key Plate", "Add", "Delete"},
{"File", "New", "Open", "Open as Layer", "Save", "Save as", "Close", "Quit", "Edit", "Undo", "Redo",
"Copy", "Copy Visible", "Cut", "Paste", "Clipboard", "Transform", "Projection", "Canvas",
"Change Resolution", "Change Canvas Size", "Flip Canvas Horizontally", "Flip Canvas Vertically",
"Switch _BG Color", "Change 2nd _BG Color", "Change ICC Profile", "Layer", "_New Layer(Color)",
"_New Layer(Vector)", "_New Layer Set", "_New 3D Modeling Layer", "_New Adjustment Lyaer", "_Copy Layer",
"_Delete Layer", "Fill with _FG Color", "Fill with Pattern", "Rasterize Layer", "Merge Down",
"_Flatten Image", "_Visible to Layer", "Visible Copy", "Select", "None", "Invert", "All", "Grow",
"Shrink", "View", "Zoom", "Zoom _In", "Zoom _Out", "Actual Size", "Reverse Horizontally", "Rotate",
"Reset Roatate", "Display Filters", "Nothing", "Gray Scale", "Gray Scale (YIQ)", "Filters", "Blur",
"Motion Blur", "Gaussian Blur", "Brightness & Contrast", "Hue & Saturation", "Levels", "Tone Curve",
"Luminosity to Opacity", "Color to Alpha", "Colorize with Under Layer", "Gradation Map",
"Map with Detect Max Black Value", "Transparency as White", "Fill with Vector", "Render", "Cloud",
"Fractal", "Trace Pixels", "Plug-in", "Script", "Help", "Version"
},
{"New", "New Canvas", "Width", "Height", "2nd BG Color", "Adopt ICC Profile?", "Preset", "Add Preset",
"Swap Height and Width"},
{"Tool Box", "Initialize", "New Brush", "Smooth", "Quality", "Rate", "Gaussian", "Average", "Magnification",
"Brush Size", "Scale", "Flow", "Pressure", "Extend Range", "Blur", "OutLine Hardness",
"Color Extends", "Start Distance of Drag and Move", "Anti Alias", "Change Text Color", "Horizonal",
"Vertical", "Style", "Normal", "Bold", "Italic", "Oblique", "Balloon", "Balloon Has Edge", "Line Color",
"Fill Color", "Line Width", "Change Line Width", "Manually Set", "Aspect Ratio", "Centering Horizontally",
"Centering Vertically", "Adjust Range to Text", "Number of Edge,", "Edge Size", "Edge Size Random",
"Edge Distance Random", "Number of Children", "Start Child Size", "End Child Size", "Reverse",
"Reverse Horizontally", "Reverse Vertically", "Blend Mode", "Hue", "Saturation", "Brightness", "Contrast",
"Distance", "Rotate Start", "Rotate Speed", "Random Rotate", "Rotate to Brush Direction", "Size Range",
"Rotate Range", "Random Size", "Clockwise", "Counter Clockwise", "Both Direction", "Minimum Degree",
"Minumum Distance", "Minimum Pressure", "Enter", "Out", "Enter & Out", "Mix", "Reverse FG BG",
"Devide Stroke", "Delete Stroke", "Target", "Stroke", "Prior Angle", "Control Point", "Free", "Scale",
"Free Shape", "Rotate", "Preference", "Name", "Copy Brush", "Change Brush", "Delete Brush", "Texture",
"Strength", "No Texture", "Add Color", "Delete Color", "Load Pallete", "Add Pallete", "Write Pallete",
"Clear Pallete", "Pick Mode", "Single Pixel", "Average Color", "Open Path", "Close Path", "Update",
"Frequency", "Cloud Color", "Persistence", "Random Seed", "Use Random", "Update Immediately",
"Number of Octaves", "Linear", "Cosine", "Cubic", "Colorize", "Start Editting 3D Model",
"Finish Editting 3D Model", "Scatter", "Scatter Size", "Scatter Range", "Random Size Scatter",
"Random Flow Scatter", "Bevel", "Round", "Mitter", "Normal Brush",
{"Pencil", "Hard Pen", "Air Brush", "Old Air Brush", "Water Color Brush", "Picker Brush", "Eraser", "Bucket",
"Pattern Fill", "Blur Tool", "Smudge", "Mix Brush", "Gradation", "Text Tool", "Stamp Tool",
"Image Brush", "Image Blend\nBrush", "Picker Image Brush", "Script Brush", "Custom Brush", "PLUG_IN"},
{"Detection Target", "Detect from ... ", "Pixels Color", "Pixel Color + Alpha",
"Alpha", "Active Layer", "Under Layer", "Canvas", "Threshold", "Detection Area", "Normal", "Large"},
{"Select/Release", "Move Control Point", "Change Pressure", "Delete Control Point",
"Move Stroke", "Copy & Move Stroke", "Joint Stroke"},
{"Circle", "Eclipse", "Triangle", "Square", "Rhombus", "Hexagon", "Star", "Pattern", "Image"}
},
{"Layer", "Layer", "Vector", "Layer Set", "Text", "Adjustment", "3D Modeling", "Add Layer", "Add Vector Layer",
"Add Layer Set", "Add 3D Modeling Layer", "Add Adjustment Layer", "Rename Layer", "Reorder Layer",
"Opacity to Selection Area", "Opacity Add Selection Area", "Pasted Layer", "Under Layer",
"Mixed Under Layer", "Blend Mode", "Opacity", "Masking with Under Layer", "Lock Opacity",
{"Normal", "Add", "Multiply", "Screen", "Overlay", "Lighten", "Darken", "Dodge", "Burn",
"Hard Light", "Soft Light", "Difference", "Exclusion", "Hue", "Saturation", "Color",
"Luminosity", "Binalize"}},
{"Random (Straight)", "Bidirection"},
{"Compress", "Quality", "Write Opacity Data", "Write ICC Profile Data", "Save before close the image?",
"There are some images with unsaved changes.", "There is Backup File.\nRecover it?"},
{"Navigtion"},
{"Preference", "Base Settings", "Auto Save", "Theme", "Default",
"There is a conflict to set a hot key.", "Language", "Backup File Directory",
"Show Preview Window on Taskbar", "Draw with Touch", "Scale Change and Move Canvas with Change",
"Set Back Ground Color"},
{"Execute Back Up..."}
};
static FRACTAL_LABEL fractal_labels =
{
"Triangle", "Transform", "Variations", "Colors", "Random",
"Weight", "Symmetry", "Linear", "Sinusoidal", "Spherical",
"Swirl", "Shorseshoe", "Polar", "Handkerchief", "Heart", "Disc",
"Spiral", "Hyperbolic", "Diamond", "Ex", "Julia", "Bent", "Waves",
"Fish Eye", "Pop Corn", "Preserve Weights", "Update", "Update Immediately",
"Adjust", "Rendering", "Gamma", "Brightness", "Vibrancy", "Camera", "Zoom",
"Option", "Oversample", "Filter Radius", "Forced Symmetry", "Type",
"Order", "None", "Bilateral", "Rotational", "Dihedral", "Mutation",
"Directions", "Controls", "Speed", "Trend", "Auto Zoom", "Add", "Delete",
"Flip Horizontal", "Flip Vertical", "Flip Horizontal All",
"Flip Vertical All", "Use Random", "Rest", "Create ID"
};
void *tbb = NULL;
#if defined(CHECK_MEMORY_POOL) && CHECK_MEMORY_POOL != 0
_CrtSetDbgFlag(_CRTDBG_CHECK_ALWAYS_DF);
#endif
#if defined(USE_3D_LAYER) && USE_3D_LAYER != 0
application.flags |= APPLICATION_HAS_3D_LAYER;
tbb = TbbObjectNew();
#endif
#ifdef _DEBUG
atexit(AtExit);
#endif
{
gchar *raw_path;
application.labels = &labels;
application.fractal_labels = &fractal_labels;
#if GTK_MAJOR_VERSION <= 2
gtk_set_locale();
#endif
gtk_init(&argc, &argv);
#if defined(USE_3D_LAYER) && USE_3D_LAYER != 0
gtk_gl_init(&argc, &argv);
#endif
raw_path = g_locale_to_utf8(argv[0], -1, NULL, NULL, NULL);
application.current_path = g_path_get_dirname(raw_path);
InitializeApplication(&application, INITIALIZE_FILE_NAME);
g_free(raw_path);
}
/*
{
cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 500, 500);
cairo_t *cairo_p = cairo_create(surface);
cairo_scale(cairo_p, 1, 2);
cairo_arc(cairo_p, 100, 100, 50, 0, 2*G_PI);
cairo_fill(cairo_p);
cairo_surface_write_to_png(surface, "test.png");
cairo_destroy(cairo_p);
}
*/
if(argc > 1)
{
//gchar *file_path = g_locale_to_utf8(argv[1], -1, NULL, NULL, NULL);
//OpenFile(file_path, &application);
//g_free(file_path);
#ifdef _PROFILING
return 0;
#endif
}
gtk_main();
#if defined(USE_3D_LAYER) && USE_3D_LAYER != 0
DeleteTbbObject(tbb);
#endif
return 0;
}
int main(int argc, char *argv[])
{
printf("%s \nPlease report any bug to %s\n", PACKAGE_STRING, PACKAGE_BUGREPORT);
//printf("number of arg = %d, argv = %s\n", argc, argv[1]);
/*printf("argc = %d\n", argc);
if (argv[1] != NULL) {
if (strstr (argv[1],"debug") != NULL) {
debug = TRUE;
printf("debug = TRUE\n");
}
}
DEBUG("debug is true\n");*/
gchar *filename;
int i = 0;
gint initialWindowHeight = 170;
guint timeoutEvent, intervalDisplaySpectro;
GtkWidget *pVBox[4], *pHBox[13], *menuBar, *menu, *submenu, *menuItem, *submenuItem, *button, *frame, *image, *label, *widget;
GdkColor color;
Spectrum3dGui spectrum3dGui;
GSList *radio_menu_group;
GError **error;
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
GdkGLConfig *glconfig;
#endif
gst_init (NULL, NULL);
gtk_init (&argc, &argv);
get_saved_values();
intervalDisplaySpectro = (guint)spectrum3d.interval_display;
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
gtk_gl_init(NULL, NULL);
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print ("\n*** Cannot find the double-buffered visual.\n");
g_print ("\n*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
}
#endif
initGstreamer();
init_audio_values();
init_display_values(&spectrum3dGui);
spectrum3dGui.mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (spectrum3dGui.mainWindow, 700, initialWindowHeight);
gtk_widget_realize(spectrum3dGui.mainWindow);
gtk_window_set_title(GTK_WINDOW(spectrum3dGui.mainWindow), PACKAGE_NAME);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "spectrum3d.png", NULL);
gtk_window_set_icon(GTK_WINDOW(spectrum3dGui.mainWindow), gdk_pixbuf_new_from_file (filename, error));
g_signal_connect (G_OBJECT (spectrum3dGui.mainWindow), "destroy", G_CALLBACK (quit_spectrum3d), NULL);
#ifdef GTK3
gtk_container_set_reallocate_redraws (GTK_CONTAINER (spectrum3dGui.mainWindow), TRUE);
#endif
#ifdef GTK3
for (i = 0; i < 4; i++) {
pVBox[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
}
pHBox[0] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
for (i = 1; i < 12; i++) {
pHBox[i] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
}
pHBox[12] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif defined GTK2
for (i = 0; i < 4; i++) {
pVBox[i] = gtk_vbox_new(FALSE, 0);
}
pHBox[0] = gtk_hbox_new(TRUE, 0);
for (i = 1; i < 12; i++) {
pHBox[i] = gtk_hbox_new(FALSE, 0);
}
pHBox[12] = gtk_hbox_new(TRUE, 0);
#endif
gtk_container_add(GTK_CONTAINER(spectrum3dGui.mainWindow), pVBox[1]);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[0], FALSE, FALSE, 0);
/* Menu */
menuBar = gtk_menu_bar_new();
menu = gtk_menu_new(); // 'Quit' submenu
menuItem = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(gtk_main_quit), NULL);
menuItem = gtk_menu_item_new_with_label("Quit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
menu = gtk_menu_new(); // 'Edit' submenu
menuItem = gtk_menu_item_new_with_label("Preferences");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onPreferences), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Edit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
menu = gtk_menu_new(); // 'Sound' submenu
menuItem = gtk_menu_item_new_with_label("Sound");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
submenu = gtk_menu_new();// 'Play test sound' sub-submenu
spectrum3dGui.checkMenuTestSound = gtk_check_menu_item_new_with_label("Test Sound");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), spectrum3dGui.checkMenuTestSound);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuTestSound), "activate", G_CALLBACK(menu_check_test_sound), &spectrum3dGui);
menu = gtk_menu_new(); // 'View' submenu
menuItem = gtk_menu_item_new_with_label("View");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
submenu = gtk_menu_new();// 'viewType' sub-submenu
menuItem = gtk_menu_item_new_with_label("Perspective");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.radio3D = gtk_radio_menu_item_new_with_label(NULL, "3D (D)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3D));
g_signal_connect(G_OBJECT(spectrum3dGui.radio3D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3D);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3D);
spectrum3dGui.radio3Dflat = gtk_radio_menu_item_new_with_label(radio_menu_group, "3D flat (F)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3Dflat));
g_signal_connect(G_OBJECT(spectrum3dGui.radio3Dflat), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3Dflat);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3Dflat);
spectrum3dGui.radio2D = gtk_radio_menu_item_new_with_label(radio_menu_group, "2D (D)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio2D));
g_signal_connect(G_OBJECT(spectrum3dGui.radio2D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio2D);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio2D);
submenu = gtk_menu_new();// 'Scale' sub-submenu
menuItem = gtk_menu_item_new_with_label("Scale");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.checkMenuText = gtk_check_menu_item_new_with_label("Text (T)");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuText), TRUE);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuText), "activate", G_CALLBACK(check_menu_text), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuText);
spectrum3dGui.checkMenuLines = gtk_check_menu_item_new_with_label("Lines (L)");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuLines), TRUE);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuLines), "activate", G_CALLBACK(check_menu_lines), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuLines);
spectrum3dGui.checkMenuPointer = gtk_check_menu_item_new_with_label("Pointer (P)");
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuPointer), "activate", G_CALLBACK(check_menu_pointer), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuPointer);
submenu = gtk_menu_new();// 'Change/reset view' sub-submenu
menuItem = gtk_menu_item_new_with_label("Change/reset view");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.reset = gtk_menu_item_new_with_label("Reset view (R)");
gtk_widget_set_tooltip_text (spectrum3dGui.reset, "Reset the view as if Spectrum3d was just started");
g_signal_connect(G_OBJECT(spectrum3dGui.reset), "activate", G_CALLBACK(reset_view), spectrum3dGui.reset);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.reset);
spectrum3dGui.front = gtk_menu_item_new_with_label("Front view (O)");
gtk_widget_set_tooltip_text (spectrum3dGui.front, "2D view showing frequency versus intensity of the sound; shows a snapshot of the harmonics at a given time");
g_signal_connect(G_OBJECT(spectrum3dGui.front), "activate", G_CALLBACK(front_view), spectrum3dGui.front);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.front);
submenuItem = gtk_menu_item_new_with_label("Preset view");
gtk_widget_set_tooltip_text (submenuItem, "Set the view with the chosen preset values");
g_signal_connect(G_OBJECT(submenuItem), "activate", G_CALLBACK(set_view_from_preset), submenuItem);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), submenuItem);
menu = gtk_menu_new(); // 'Help...' submenu
menuItem = gtk_menu_item_new_with_label("Shortcuts");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onShortcuts), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
#ifdef HAVE_LIBGEIS
menuItem = gtk_menu_item_new_with_label("Gestures Shortcuts");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onGesturesShortcuts), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
#endif
menuItem = gtk_menu_item_new_with_label("About...");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onAbout), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Quick start");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onQuickStart), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Help");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
gtk_box_pack_start(GTK_BOX(pHBox[0]), menuBar, FALSE, TRUE, 0);
/* SourceButtons to set type of source (none, audio file, microphone) */
spectrum3dGui.stop = gtk_button_new();
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "stop.png", NULL);
image = gtk_image_new_from_file(filename);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.stop),image);
gdk_color_parse ("gold",&color);
gtk_widget_set_name(spectrum3dGui.stop, "stop");
gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_NORMAL, &color);
gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_PRELIGHT, &color);
gtk_widget_set_tooltip_text (spectrum3dGui.stop, "Stop playing everything; no source of playing");
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[1], FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.stop, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.stop), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "microphone_grey.png", NULL);
image = gtk_image_new_from_file(filename);
spectrum3dGui.mic = gtk_button_new();
gtk_button_set_image (GTK_BUTTON(spectrum3dGui.mic), image);
gtk_widget_set_name(spectrum3dGui.mic, "mic");
gtk_widget_set_tooltip_text (spectrum3dGui.mic, "Source is microphone; select this to record something and then load it");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.mic, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.mic), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
spectrum3dGui.file = gtk_button_new();
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "file_grey.png", NULL);
image = gtk_image_new_from_file(filename);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.file),image);
gtk_widget_set_name(spectrum3dGui.file, "file");
gtk_widget_set_tooltip_text (spectrum3dGui.file, "Source is an audio file");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.file, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.file), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
spectrum3dGui.reload = gtk_button_new();
image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.reload),image);
gtk_widget_set_sensitive (spectrum3dGui.reload, FALSE);
gtk_widget_set_tooltip_text (spectrum3dGui.reload, "Reload audio file (usefull if some audio parameters like equalizer or filters have been changed)");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.reload, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.reload), "clicked", G_CALLBACK(load_audio_file), NULL);
widget = gtk_check_button_new_with_label("Analyse in\nrealtime");
gtk_widget_set_tooltip_text (GTK_WIDGET(widget), "If checked, harmonics will be analysed and displayed at the same time; if unchecked, harmonics will be analysed first, then displayed for the whole audio file, then it can be played afterwards");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(set_analyse_in_rt), &spectrum3dGui);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* "Play/Pause" button */
playButton = gtk_button_new();
gtk_widget_set_tooltip_text (playButton, "Play/Pause the audio stream");
setPlayButtonIcon();
gtk_widget_set_size_request (playButton, 50, 20);
gtk_box_pack_start(GTK_BOX(pHBox[1]), playButton, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(playButton), "clicked", G_CALLBACK(playFromSource), "NO_MESSAGE");
/* "Stop" button */
button = gtk_button_new();
gtk_widget_set_tooltip_text (button, "Stop playing audio stream");
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(button),image);
gtk_box_pack_start(GTK_BOX(pHBox[1]), button, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_stop), NULL);
/* "Record" button */
spectrum3dGui.record = gtk_button_new();
gtk_widget_set_tooltip_text (spectrum3dGui.record, "Record from microphone");
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.record),image);
gtk_widget_set_sensitive (spectrum3dGui.record, FALSE);
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.record, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.record), "clicked", G_CALLBACK(record_window), NULL);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* JACK check button */
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "qjackctl.png", NULL);
image = gtk_image_new_from_file(filename);
widget = gtk_check_button_new ();
gtk_button_set_image (GTK_BUTTON(widget), image);
gtk_widget_set_tooltip_text (widget, "Use Jack-Audio-Connection-Kit (JACK)");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(use_jack), &spectrum3dGui);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* Button to open the Filter and Equalizer window */
// create effectsWindow first without showing it
effects_window(&spectrum3dGui);
// then create a button that will call its display when clicked
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "equalizer.png", NULL);
image = gtk_image_new_from_file(filename);
widget = gtk_button_new();
gtk_button_set_image (GTK_BUTTON(widget), image);
gtk_widget_set_tooltip_text (widget, "Show/Hide the filter and equalizer window");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(show_effects_window), &spectrum3dGui);
/* Time label */
label=gtk_label_new("Time : ");
gtk_box_pack_start(GTK_BOX(pHBox[5]), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[5], FALSE, FALSE, 2);
/* Progress & seek scale */
#ifdef GTK3
scaleSeek = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1);
#elif defined GTK2
scaleSeek = gtk_hscale_new_with_range (0.0, 100.0, 1);
#endif
gtk_scale_set_draw_value (GTK_SCALE (scaleSeek), FALSE);
//gtk_scale_set_value_pos (GTK_SCALE (pScaleSeek), GTK_POS_TOP);
gtk_range_set_value (GTK_RANGE (scaleSeek), 0);
gtk_widget_set_size_request (scaleSeek, 500, 20);
gtk_box_pack_start(GTK_BOX(pHBox[5]), scaleSeek, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(scaleSeek), "value-changed", G_CALLBACK(on_seek), NULL);
timeLabel=gtk_label_new(" 0:00 / 0:00 ");
gtk_box_pack_start(GTK_BOX(pHBox[5]), timeLabel, FALSE, FALSE, 0);
/* Create drawing area */
if (externalWindow == FALSE){
/* Resize spectrum3dGui.mainWindow to contain drawing_area; using gtk_window_set_defaut() allows to shrink the window (gtk_widget_set_size_request() does not allow to shrink the window below the requested size); */
gtk_window_set_default_size (GTK_WINDOW(spectrum3dGui.mainWindow), (gint)spectrum3d.width, initialWindowHeight + (gint)spectrum3d.height);
//gtk_widget_realize(spectrum3dGui.mainWindow);
spectrum3dGui.drawing_area = gtk_drawing_area_new ();
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
/* Set OpenGL-capability to the widget */
gtk_widget_set_gl_capability (spectrum3dGui.drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
#endif
/* drawing_area has to be put in vBox AFTER the call to gtk_widget_set_gl_capability() (if GtkGlExt is used) and BEFORE the call to the sdl-gtk hack (if sdl is used)*/
gtk_box_pack_start (GTK_BOX (pVBox[1]), spectrum3dGui.drawing_area, TRUE, TRUE, 0);
#ifdef HAVE_LIBSDL
/* Hack to get SDL to use GTK window */
{ char SDL_windowhack[32];
sprintf(SDL_windowhack,"SDL_WINDOWID=%ld",
GDK_WINDOW_XID(gtk_widget_get_window(spectrum3dGui.drawing_area)));
// GDK_WINDOW_XID( spectrum3dGui.drawing_area->window))); pour GTK2??
putenv(SDL_windowhack);
printf("%s\n", SDL_windowhack);
}
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
#endif
g_signal_connect (spectrum3dGui.mainWindow, "key-press-event", G_CALLBACK (on_key_press), &spectrum3dGui);
g_signal_connect (spectrum3dGui.mainWindow, "key-release-event", G_CALLBACK (on_key_release), &spectrum3dGui);
g_signal_connect (spectrum3dGui.mainWindow, "motion-notify-event", G_CALLBACK (on_mouse_motion), NULL);
g_signal_connect (spectrum3dGui.mainWindow, "scroll-event", G_CALLBACK (on_mouse_scroll), NULL);
g_signal_connect (G_OBJECT (spectrum3dGui.drawing_area), "configure_event", G_CALLBACK (configure_event), NULL);
gtk_widget_add_events (spectrum3dGui.mainWindow, gtk_widget_get_events (spectrum3dGui.mainWindow) | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
}
else {
create_external_window_drawing_area(&spectrum3dGui);
}
/* Starting value of the display */
frame = gtk_frame_new("Start value of display (in Hz)");
gtk_widget_set_tooltip_text (frame, "The lower displayed frequency (in herz)");
spectrum3dGui.adjustStart = gtk_adjustment_new(0, 0, 9000, ((gdouble)hzStep * (gdouble)zoomFactor), (((gdouble)hzStep * (gdouble)zoomFactor) * 10), 0);
#ifdef GTK3
pScaleStart = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustStart));
#elif defined GTK2
pScaleStart = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustStart));
#endif
gtk_scale_set_digits (GTK_SCALE(pScaleStart), 0);
gtk_scale_set_value_pos(GTK_SCALE(pScaleStart), GTK_POS_RIGHT);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[11], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), pScaleStart);
g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(change_start), &spectrum3dGui);
g_signal_connect(G_OBJECT(pScaleStart), "format-value", G_CALLBACK(format_value_start), NULL);
g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui);
/* Range of display */
frame = gtk_frame_new("Range of display (in Hz)");
gtk_widget_set_tooltip_text (frame, "The range of the displayed frequency (in herz)");
spectrum3dGui.adjustBands = gtk_adjustment_new(1000, 20, 1000, 10, 50, 0);
#ifdef GTK3
spectrum3dGui.scaleBands = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustBands));
#elif defined GTK2
spectrum3dGui.scaleBands = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustBands));
#endif
gtk_scale_set_digits (GTK_SCALE(spectrum3dGui.scaleBands), 0);
gtk_scale_set_value_pos(GTK_SCALE(spectrum3dGui.scaleBands), GTK_POS_RIGHT);
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleBands);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(change_bands), &spectrum3dGui);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "format-value", G_CALLBACK(format_value_bands), NULL);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui);
/* "x" label */
label=gtk_label_new("x");
gtk_container_add(GTK_CONTAINER(pHBox[11]), label);
/* Factor that multiplies the range of display */
frame = gtk_frame_new("");
gtk_widget_set_tooltip_text (frame, "Factor that multiplies the frequency range, to make it larger");
spectrum3dGui.cbRange = gtk_combo_box_text_new();
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.cbRange);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
for (i = 1; i <= 20; i++){
gchar text[4];
sprintf(text, "%d", i);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(spectrum3dGui.cbRange), text);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(spectrum3dGui.cbRange), 0);
g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK( cb_range_changed ), &spectrum3dGui );
g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui );
/* Label that shows starting value, ending value and range of display */
frame = gtk_frame_new("Values displayed");
gtk_widget_set_tooltip_text (frame, "The lower and the highest displayed value (in herz), and their range");
displayLabel=gtk_label_new("");
gtk_container_add(GTK_CONTAINER(frame), displayLabel);
getTextDisplayLabel(NULL, &spectrum3dGui);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
/* 'Gain' Gtk Scale */
frame = gtk_frame_new("Display Gain");
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 10);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "gain.png", NULL);
image = gtk_image_new_from_file(filename);
spectrum3dGui.scaleGain = gtk_scale_button_new (GTK_ICON_SIZE_LARGE_TOOLBAR, 0, 1, 0.01, NULL);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.scaleGain),image);
//gtk_button_set_label (GTK_BUTTON(spectrum3dGui.scaleGain), "GAIN");
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleGain);
//gtk_box_pack_start(GTK_BOX(pHBox[11]), pScaleGain, FALSE, FALSE, 0);
//gtk_widget_set_size_request (pScaleGain, 200, 20);
//gtk_scale_set_value_pos(GTK_SCALE(pScaleGain), GTK_POS_RIGHT);
gtk_widget_set_tooltip_text (spectrum3dGui.scaleGain, "Adjust the displayed level of the intensity of the sound");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(spectrum3dGui.scaleGain), 0.2);
// FIXME error message here with the previous line : gtk_image_set_from_stock: assertion `GTK_IS_IMAGE (image)' failed; it could be a bug in Gtk
//g_object_set (pScaleGain, "update-policy", GTK_UPDATE_DISCONTINUOUS, NULL);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleGain), "value-changed", G_CALLBACK(change_gain), NULL);
#ifdef HAVE_LIBGEIS
setupGeis();
#endif
gtk_widget_show_all (spectrum3dGui.mainWindow);
//timeoutEvent = g_timeout_add (100, (GSourceFunc)sdl_event, &spectrum3dGui);
spectrum3d.timeoutExpose = g_timeout_add (intervalDisplaySpectro, (GSourceFunc)display_spectro, &spectrum3dGui);
printf("Showing Gtk GUI\n");
gtk_main ();
/* Quit everything */
#ifdef HAVE_LIBGEIS
geisQuit();
#endif
on_stop();
g_source_remove(spectrum3d.timeoutExpose);
#ifdef HAVE_LIBSDL
//g_source_remove(timeoutEvent);
SDL_Quit();
#endif
print_rc_file();
printf("Quit everything\nGood Bye!\n");
return 0;
}
static void init_plugin(PurplePlugin *plugin)
{
gtk_gl_init(NULL, NULL);
memset(&cc_info, 0, sizeof(cc_info));
Debug("CrazyChat plugin initialized\n");
}
int main (int argc, char **argv)
{
SDL_SysWMinfo info;
Display *gtkglext_display = NULL;
Window gtkglext_window = 0;
GLXContext gtkglext_gl_context = NULL;
GstPipeline *pipeline = NULL;
GstBus *bus = NULL;
GstElement *glfilter = NULL;
GstElement *fakesink = NULL;
GstState state;
GAsyncQueue *queue_input_buf = NULL;
GAsyncQueue *queue_output_buf = NULL;
gst_init (&argc, &argv);
gtk_init (&argc, &argv);
gtk_gl_init(&argc, &argv);
gint major;
gint minor;
gdk_gl_query_version(&major, &minor);
g_print("\nOpenGL extension version - %d.%d\n", major, minor);
/* Try double-buffered visual */
GdkGLConfig* glconfig;
// the line above does not work in C++ if the cast is not there.
glconfig = gdk_gl_config_new_by_mode(static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGB | GDK_GL_MODE_DOUBLE));
if (glconfig == NULL)
{
g_print("*** Cannot find the double-buffered visual.\n");
g_print("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode(static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGB));
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit(1);
}
}
examine_gl_config_attrib(glconfig);
// Main GTK window
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, 640, 480);
gtk_window_set_title(GTK_WINDOW (window), "Toonloop 1.3 experimental");
GdkGeometry geometry;
geometry.min_width = 1;
geometry.min_height = 1;
geometry.max_width = -1;
geometry.max_height = -1;
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geometry, GDK_HINT_MIN_SIZE);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(on_delete_event), NULL);
//area where the video is drawn
GtkWidget* drawing_area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), drawing_area);
/* Set OpenGL-capability to the widget. */
gtk_widget_set_gl_capability(drawing_area, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
/* Loop, drawing and checking events */
g_signal_connect_after(G_OBJECT(drawing_area), "realize", G_CALLBACK(on_realize), NULL);
g_signal_connect(G_OBJECT(drawing_area), "configure_event", G_CALLBACK(on_configure_event), NULL);
g_signal_connect(G_OBJECT(drawing_area), "expose_event", G_CALLBACK(on_expose_event), NULL);
gtk_widget_show_all(window);
// ------------------ done with the GTK GUI
/* retrieve and turn off gtkglext opengl context */
SDL_VERSION (&info.version);
SDL_GetWMInfo (&info);
gtkglext_display = info.info.x11.display;
gtkglext_window = info.info.x11.window;
gtkglext_gl_context = glXGetCurrentContext ();
glXMakeCurrent (gtkglext_display, None, 0);
pipeline =
GST_PIPELINE (gst_parse_launch
("videotestsrc ! video/x-raw-yuv, width=320, height=240, framerate=(fraction)30/1 ! "
"glupload ! gleffects effect=5 ! fakesink sync=1", NULL));
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message::error", G_CALLBACK (end_stream_cb), NULL);
g_signal_connect (bus, "message::warning", G_CALLBACK (end_stream_cb), NULL);
g_signal_connect (bus, "message::eos", G_CALLBACK (end_stream_cb), NULL);
gst_object_unref (bus);
/* gtkglext_gl_context is an external OpenGL context with which gst-plugins-gl want to share textures */
glfilter = gst_bin_get_by_name (GST_BIN (pipeline), "gleffects0");
g_object_set (G_OBJECT (glfilter), "external-opengl-context",
gtkglext_gl_context, NULL);
g_object_unref (glfilter);
/* NULL to PAUSED state pipeline to make sure the gst opengl context is created and
* shared with the gtkglext one */
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PAUSED);
state = GST_STATE_PAUSED;
if (gst_element_get_state (GST_ELEMENT (pipeline), &state, NULL,
GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) {
g_debug ("failed to pause pipeline\n");
return -1;
}
/* turn on back gtk opengl context */
glXMakeCurrent (gtkglext_display, gtkglext_window, gtkglext_gl_context);
/* append a gst-gl texture to this queue when you do not need it no more */
fakesink = gst_bin_get_by_name (GST_BIN (pipeline), "fakesink0");
g_object_set (G_OBJECT (fakesink), "signal-handoffs", TRUE, NULL);
g_signal_connect (fakesink, "handoff", G_CALLBACK (on_gst_buffer), NULL);
queue_input_buf = g_async_queue_new ();
queue_output_buf = g_async_queue_new ();
g_object_set_data (G_OBJECT (fakesink), "queue_input_buf", queue_input_buf);
g_object_set_data (G_OBJECT (fakesink), "queue_output_buf", queue_output_buf);
g_object_unref (fakesink);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
gtk_main();
/* before to deinitialize the gst-gl-opengl context,
* no shared context (here the gtkglext one) must be current
*/
glXMakeCurrent (gtkglext_display, gtkglext_window, gtkglext_gl_context);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL);
g_object_unref (pipeline);
/* turn on back gtkglext opengl context */
glXMakeCurrent (gtkglext_display, None, 0);
/* make sure there is no pending gst gl buffer in the communication queues
* between gtkglext and gst-gl
*/
while (g_async_queue_length (queue_input_buf) > 0) {
GstBuffer *buf = (GstBuffer *) g_async_queue_pop (queue_input_buf);
gst_buffer_unref (buf);
}
while (g_async_queue_length (queue_output_buf) > 0) {
GstBuffer *buf = (GstBuffer *) g_async_queue_pop (queue_output_buf);
gst_buffer_unref (buf);
}
return 0;
}
int
main (int argc,
char *argv[])
{
GdkGLConfig *glconfig;
gint major, minor;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *drawing_area;
GtkWidget *button;
/*
* Init GTK.
*/
gtk_init (&argc, &argv);
/*
* Init GtkGLExt.
*/
gtk_gl_init (&argc, &argv);
/*
* Query OpenGL extension version.
*/
gdk_gl_query_version (&major, &minor);
g_print ("\nOpenGL extension version - %d.%d\n",
major, minor);
/*
* Configure OpenGL-capable visual.
*/
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_SINGLE);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
examine_gl_config_attrib (glconfig);
/*
* Top-level window.
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "simple");
/* Get automatically redrawn if any of their children changed allocation. */
gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
/*
* VBox.
*/
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/*
* Drawing area for drawing OpenGL scene.
*/
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 200, 200);
/* Set OpenGL-capability to the widget. */
gtk_widget_set_gl_capability (drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
g_signal_connect_after (G_OBJECT (drawing_area), "realize",
G_CALLBACK (realize), NULL);
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (configure_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/*
* Simple quit button.
*/
button = gtk_button_new_with_label ("Quit");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_main_quit), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/*
* Show window.
*/
gtk_widget_show (window);
/*
* Main loop.
*/
gtk_main ();
return 0;
}
int
main(int argc, char *argv[]) {
Arg arg;
Client *c;
GdkGeometry hints = { 1, 1 };
memset(&arg, 0, sizeof(arg));
/* command line args */
ARGBEGIN {
case 'e':
embed = strtol(EARGF(usage()), NULL, 0);
break;
case 'v':
die("turf-"VERSION", ©2014 turf engineers, "
"see LICENSE for details\n");
case 'x':
showxid = TRUE;
break;
default:
usage();
} ARGEND;
if(argc > 0)
arg.v = argv[0];
sigchld(0);
gtk_init(NULL, NULL);
gtk_gl_init(NULL, NULL);
dpy = GDK_DISPLAY();
/* atoms */
atoms[AtomFind] = XInternAtom(dpy, "_TURF_FIND", False);
atoms[AtomGo] = XInternAtom(dpy, "_TURF_GO", False);
atoms[AtomUri] = XInternAtom(dpy, "_TURF_URI", False);
if(!(c = calloc(1, sizeof(Client))))
die("Cannot malloc!\n");
/* WIndow */
if(embed) {
c->win = gtk_plug_new(embed);
} else {
c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(c->win), "turf", "Turf");
gtk_window_set_role(GTK_WINDOW(c->win), "Turf");
}
gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
g_signal_connect(G_OBJECT(c->win),
"destroy",
G_CALLBACK(destroywin), c);
c->vbox = gtk_vbox_new(FALSE, 0);
/* cef init */
cef_settings_t *settings;
if(!(settings = malloc(sizeof(cef_settings_t))))
die("Cannot malloc\n");
cef_initialize(NULL, settings, NULL);
/* cef set as child (vbox) */
gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
gtk_widget_show_all(GTK_WIDGET(c->win));
gtk_window_set_geometry_hints(GTK_WINDOW(c->win), NULL, &hints,
GDK_HINT_MIN_SIZE);
gdk_window_set_events(GTK_WIDGET(c->win)->window, GDK_ALL_EVENTS_MASK);
/* process X events for window - aka AtomFind/AtomGo
* gdk_window_add_filter(GTK_WIDGET(c->win)->window, processx, c);
* setatom(c, AtomFind, "");
* setatom(c, AtomUri, "about:blank");
*/
c->title = NULL;
c->next = clients;
clients = c;
if(showxid) {
gdk_display_sync(gtk_widget_get_display(c->win));
printf("%u\n",
(guint)GDK_WINDOW_XID(GTK_WIDGET(c->win)->window));
fflush(NULL);
if (fclose(stdout) != 0) {
die("Error closing stdout");
}
}
if(arg.v)
loaduri(clients, &arg);
gtk_main();
cleanup();
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
/* Initialize */
gst_init (&argc, &argv);
gtk_init (&argc, &argv);
gdk_threads_init ();
gtk_gl_init (&argc, &argv);
init_extensions ();
init_gl_resources ();
/* Gtk window & container */
GtkWindow *window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
glarea = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (glarea), WINDOW_WIDTH, WINDOW_HEIGHT);
g_signal_connect (glarea, "expose-event", G_CALLBACK (on_expose), NULL);
g_signal_connect (glarea, "configure-event", G_CALLBACK (on_configure), NULL);
g_signal_connect (glarea, "map-event", G_CALLBACK (on_mapped), NULL);
g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
GdkGLConfig *gl_config;
gl_config = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE);
if (gl_config == NULL)
g_critical ("Failed to setup a double-buffered RGB visual");
if (! gtk_widget_set_gl_capability (GTK_WIDGET (glarea),
gl_config,
NULL,
TRUE,
GDK_GL_RGBA_TYPE))
g_critical ("Failed to add gl capability");
gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (glarea));
gtk_widget_show_all (GTK_WIDGET (window));
/* Create the elements */
pipeline = gst_pipeline_new (NULL);
source = gst_element_factory_make ("filesrc", "filesrc");
decodebin = gst_element_factory_make ("decodebin", "decodebin");
videosink = gst_element_factory_make ("fakesink", "videosink");
audiosink = gst_element_factory_make ("alsasink", "audiosink");
audioconvert = gst_element_factory_make ("audioconvert", "audioconvert");
audioqueue = gst_element_factory_make ("queue", "audioqueue");
videoqueue = gst_element_factory_make ("queue", "videoqueue");
if (pipeline == NULL || source == NULL || decodebin == NULL ||
videosink == NULL || audiosink == NULL || audioconvert == NULL || audioqueue == NULL ||
videoqueue == NULL)
g_critical ("One of the GStreamer decoding elements is missing");
/* Setup the pipeline */
g_object_set (G_OBJECT (source), "location", "video.avi", NULL);
gst_bin_add_many (GST_BIN (pipeline), source, decodebin, videosink,
audiosink, audioconvert, audioqueue, videoqueue, NULL);
g_signal_connect (decodebin, "pad-added", G_CALLBACK (on_new_pad), NULL);
/* Link the elements */
gst_element_link (source, decodebin);
gst_element_link (audioqueue, audioconvert);
gst_element_link (audioconvert, audiosink);
gst_element_link (videoqueue, videosink);
/* Now run the pipeline... */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
/* Main loop */
gtk_main ();
return 0;
}
int
main (int argc,
char *argv[])
{
gint major, minor;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *drawing_area;
GtkWidget *button;
/*
* Init GTK.
*/
gtk_init (&argc, &argv);
/*
* Init GtkGLExt.
*/
gtk_gl_init (&argc, &argv);
/*
* Query OpenGL extension version.
*/
gdk_gl_query_version (&major, &minor);
g_print ("\nOpenGL extension version - %d.%d\n",
major, minor);
/*
* Configure OpenGL-capable visual.
*/
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_SINGLE);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
examine_gl_config_attrib (glconfig);
/*
* Top-level window.
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "pixmap");
/*
* If window manager doesn't watch the WM_COLORMAP_WINDOWS property on
* the top-level window, we have to set OpenGL window's colormap to the
* top-level window.
*/
gtk_widget_set_colormap (window,
gdk_gl_config_get_colormap (glconfig));
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
/*
* VBox.
*/
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/*
* Drawing area for drawing OpenGL scene.
*/
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 200, 200);
/* Set OpenGL-capable colormap. */
gtk_widget_set_colormap (drawing_area,
gdk_gl_config_get_colormap (glconfig));
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (configure_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/*
* Simple quit button.
*/
button = gtk_button_new_with_label ("Quit");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_main_quit), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/*
* Show window.
*/
gtk_widget_show (window);
/*
* Main loop.
*/
/* Destroy the GLX context explicitly when application is terminated. */
gtk_quit_add (0, (GtkFunction) destroy_gl_context, NULL);
gtk_main ();
return 0;
}