void edit_init_menu_emacs (void)
{
    EditMenuBar[0] = create_menu (_(" File "), FileMenuEmacs, menu_entries (FileMenuEmacs));
    EditMenuBar[1] = create_menu (_(" Edit "), EditMenuEmacs, menu_entries (EditMenuEmacs));
    EditMenuBar[2] = create_menu (_(" Sear/Repl "), SearReplMenuEmacs, menu_entries (SearReplMenuEmacs));
    EditMenuBar[3] = create_menu (_(" Command "), CmdMenuEmacs, menu_entries (CmdMenuEmacs));
    EditMenuBar[4] = create_menu (_(" Options "), OptMenuEmacs, menu_entries (OptMenuEmacs));
}

static void
edit_init_menu_emacs (struct Menu *EditMenuBar[])
{
    EditMenuBar[0] = create_menu (_(" File "), FileMenuEmacs, menu_entries (FileMenuEmacs),
				    "[Internal File Editor]");
    EditMenuBar[1] = create_menu (_(" Edit "), EditMenuEmacs, menu_entries (EditMenuEmacs),
				    "[Internal File Editor]");
    EditMenuBar[2] = create_menu (_(" Sear/Repl "), SearReplMenuEmacs, menu_entries (SearReplMenuEmacs),
				    "[Internal File Editor]");
    EditMenuBar[3] = create_menu (_(" Command "), CmdMenuEmacs, menu_entries (CmdMenuEmacs),
				    "[Internal File Editor]");
    EditMenuBar[4] = create_menu (_(" Options "), OptMenuEmacs, menu_entries (OptMenuEmacs),
				    "[Internal File Editor]");
}

PLUGIN_API int XPluginStart(char *outName, char *outSig, char *outDesc)
{


	strcpy(outName, "XPUDPng " VERSION);
	strcpy(outSig, "li.rhaamo.xpudpng");
	strcpy(outDesc, "Send simuator data to an XPUDPNG-compliant application using UDP.");

	/* Initialize status variables */
	plugin_enabled = 0; /* set to 1 if the plugin is enabled from the menu. 0 otherwise */
	send_enabled = 1;   /* set to 1 if socket is open and preferences window is not shown. 0 otherwise */
	recv_enabled = 1;   /* set to 1 if socket is open and preferences window is not shown. 0 otherwise */
	recv_socket_open = 0;

	XPLMDebugString("XPUDPNG: Plugin " VERSION "\n");


	/* Create socket and addresses */
	receiverSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

	(void)set_addresses();
	(void)create_menu();

	/* Flag to tell us if the widget is being displayed */
	gMenuItem = 0;
	return 1;
}

/* Main program. An interactive model of a miniture steam engine.
   Sets system in Double Buffered mode and initialises all the call-back
   functions. */
int 
main(int argc, char **argv)
{
  puts("Miniature Steam Engine                    Troy Robinette\n");

  puts("Keypad Arrow keys (with NUM_LOCK on) rotates object.");
  puts("Rotate crank: 'a' = anti-clock wise 'z' = clock wise");
  puts("Crank Speed : '+' = Speed up by 1   '-' = Slow Down by 1");
  puts("Toggle      : 's' = Shading         't' = Texture");
  puts("            : ' ' = Animation       'o' = Transparency");
  puts("            : '0' = Right Light     '1' = Left Light");
  puts(" Alternatively a pop up menu with all toggles is attached");
  puts("   to the left mouse button.\n");

  glutInitWindowSize(400, 400);
  glutInit(&argc, argv);

  /* Transperancy won't work properly without GLUT_ALPHA */
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_MULTISAMPLE);
  glutCreateWindow("Miniature Steam Engine by Troy Robinette");

  glutDisplayFunc(display);
  glutKeyboardFunc(keyboard);
  glutSpecialFunc(special);
  create_menu();

  myinit();

  glutReshapeFunc(myReshape);
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}

/* Create the startup settings menu */
static struct Menu *make_startup_menu(struct Menu *parent) {
    struct Menu *m;
    struct MenuText save,back;
    struct MenuValue val;
    struct MenuItem *item;

    /* Create some special menu item labels */
    save = menu_txt_label("Save settings");
    save.color = font_color_red;
    back = menu_txt_label("Return");
    back.color = font_color_green;

    /* Create menu */
    m = create_menu(0,parent,NULL,NULL,NULL,0);
    add_caption(m,"Default startup settings");

    val.value = &luola_options.fullscreen;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Start in %s mode"),val);
    item->text_enabled="fullscreen";
    item->text_disabled="windowed";

    val.value = &luola_options.hidemouse;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Mouse pointer is %s"),val);
    item->text_enabled="hidden";
    item->text_disabled="shown";

    val.value = &luola_options.joystick;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Gamepad support is %s"),val);

    val.value = &luola_options.sounds;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Sound support is %s"),val);

    val.value = &luola_options.sfont;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Font engine: %s"),val);
    item->text_enabled="SFont";
    item->text_disabled="SDL_ttf";

    val.value = &luola_options.mbg_anim;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Menu background animations are %s"),val);

    val.max = 2;
    val.min = 0;
    val.inc = 1;
    val.value = (int*)&luola_options.videomode;
    item = add_menu_item(m,MNU_ITEM_VALUE,0,
            menu_func_label(vmode_label),val);

    add_menu_item(m,MNU_ITEM_SEP,0,menu_txt_label("- - -"),MnuNullValue);
    add_menu_item(m,MNU_ITEM_LABEL,0,save,MnuNullValue)->action =
        save_startup_settings;
    add_menu_item(m,MNU_ITEM_PARENT,0,back,MnuNullValue);

    return m;
}

int main(int argc, char *argv[]) 
{
    gtk_init(&argc, &argv);

    GError* error = NULL;

    eye_proxy = org_zlbruce_eyerest_basic_proxy_new_for_bus_sync(
            G_BUS_TYPE_SESSION,
            G_DBUS_PROXY_FLAGS_NONE,
            "org.zlbruce.eyerest",
            "/",
            NULL,
            &error);
    if(eye_proxy == NULL)
    {
        g_print ("init dbus failed: %s\n", error->message);
        return -1;
    }

    g_signal_connect(G_OBJECT(eye_proxy), "status",
            G_CALLBACK(on_status), NULL);

    tray_icon = create_tray_icon();
    menu = create_menu();

    gtk_main();

    g_object_unref (eye_proxy);
    return 0;
}

int main(int argc, char *argv[]) {
	pthread_t 		thread;

	/* init threads */
    g_thread_init (NULL);
    gdk_threads_init ();
    gdk_threads_enter ();

    gtk_init(&argc, &argv);

    initApp();

    appdata->program = HILDON_PROGRAM(hildon_program_get_instance());
    g_set_application_name("Webview");

    appdata->window = HILDON_WINDOW(hildon_window_new());
    hildon_program_add_window(appdata->program, appdata->window);


    create_menu(appdata->window);
    build_interface(appdata->window);

    /* Connect signal to X in the upper corner */
    g_signal_connect(G_OBJECT(appdata->window), "delete_event", G_CALLBACK(destroy), NULL);

	update_image();
	load_settings();

	gtk_widget_show_all(GTK_WIDGET(appdata->window));

	if(! start_camera(appdata->window))
	{
		g_warning("Unable to start camera\n");

		GtkWidget *failDialog = gtk_message_dialog_new(NULL,
	     		GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
	     		GTK_BUTTONS_OK,
	     		"Unable to start camera\n");
		gtk_dialog_run (GTK_DIALOG (failDialog));
		gtk_widget_destroy (failDialog);
	}

	if(! start_webserver())
	{
		GtkWidget *failDialog = gtk_message_dialog_new(NULL,
	     		GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
	     		GTK_BUTTONS_OK,
	     		"Unable to start web server.\nCheck server port is not already in use.\n");
		gtk_dialog_run (GTK_DIALOG (failDialog));
		gtk_widget_destroy (failDialog);
	}
	sleep(1);

	pthread_create(&thread, NULL, count_down_thread, NULL);

	gtk_main();

	gdk_threads_leave ();
	return( 0 );
}

/* Create the ship settings menu */
static struct Menu *make_ship_menu(struct Menu *parent) {
    struct Menu *m;
    struct MenuValue val;
    struct MenuItem *item;

    /* Create menu */
    m = create_menu(0,parent,NULL,NULL,NULL,0);
    add_caption(m,"Ship settings");

    val.value = &game_settings.ship_collisions;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,1,
            menu_txt_label("Ship collisions are %s"),val);

    val.value = &game_settings.coll_damage;
    add_menu_item(m,MNU_ITEM_TOGGLE,2,
            menu_txt_label("Collision damage is %s"),val);

    val.value = &game_settings.eject;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,3,
            menu_txt_label("Pilot ejection is %s"),val);

    val.value = &game_settings.recall;
    item = add_menu_item(m,MNU_ITEM_TOGGLE,4,
            menu_txt_label("Ship recall is %s"),val);

    add_ok(m);

    return m;

}

void setup_hud_new(hud_type* hud){
  for(int x=0;x<MAX_CHAR;x++){
    hud->textinput[x] = ' ';
  }
  hud->cur_char=0;
  create_menu(hud);
}

int main(int argc, char **argv) {

    // Initialize the drawing window.
    glutInitWindowSize(DEFAULT_WIN_WIDTH, DEFAULT_WIN_HEIGHT);
    glutInitWindowPosition(0, 0);
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    // Create the main window (reset() sets the display callback).
    glutCreateWindow("Antialiased Bressenham Line Drawing");
    glutReshapeFunc(handle_resize);
    create_menu();
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    // GL initialization
    glPixelStorei(GL_UNPACK_ALIGNMENT, sizeof(GL_FLOAT));

    // Application initialization
    win_width = glutGet(GLUT_WINDOW_WIDTH);
    win_height = glutGet(GLUT_WINDOW_HEIGHT);
    reset();

    // Enter the main event loop.
    atexit(handle_exit);
    glutMainLoop();

    return EXIT_SUCCESS;
}

void show_menu(WMenuData *mdata, WThing *context, int x, int y,
			   bool button_down)
{
	
	WMenu* menu;
	
	if(mdata->inst1!=NULL){
		menu=mdata->inst1;
		if(menu->flags&WMENU_KEEP)
			goto create_it;
		
		destroy_menu_root(menu, FALSE);
		return;
	}
	
create_it:
	menu=create_menu(mdata, context, x, y, NULL);

	if(menu==NULL)
		return;
	
	if(button_down){
		pointer_change_context((WThing*)menu, ACTX_MENU);
	}else if(menu->flags&WMENU_CONTEXTUAL){
		vis_entry(menu, -1);
		grab_kb_ptr();
		wglobal.input_mode=INPUT_CTXMENU;
		wglobal.grab_holder=(WThing*)menu;
	}
}

int main(void){
   menu_t *games_list;
   int selected;
   PICvision_init();
   games_list=create_menu("SELECT GAME");
   add_menu_item("snake",1,games_list);
   add_menu_item("2048",2,games_list);
   //add_menu_item("game 3",3,games_list);
   //add_menu_item("etc...",4,games_list);
   while(1){
       clear_screen();
       selected=run_menu(games_list,10,(27-5)/2,PADDLE1);
       clear_screen();
       switch(selected){
           case 1:
               snake_game();
               break;
           case 2:
               gc_2048_game();
               break;
           case 3:
               set_curpos(0,0);
               print("game 3");
               wait_n_frame(60);
               break;
           case 4:
               set_curpos(0,0);
               print("autre jeux");
               wait_n_frame(60);
               break;
       }//switch
   }//while
   return 0;
}//main()

void
gui_gtk_widget_create(void)
{
	GtkWidget *main_vbox;
	GtkWidget *menubar;
	gchar *accel = NULL;
	gint root_x, root_y;

	main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//	gtk_widget_set_double_buffered(GTK_WIDGET(main_window), FALSE);
	gtk_window_set_resizable(GTK_WINDOW(main_window), FALSE);
	gtk_window_set_title(GTK_WINDOW(main_window), np2oscfg.titles);
	gtk_widget_add_events(main_window, EVENT_MASK);

	main_vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(main_window), main_vbox);
	gtk_widget_show(main_vbox);

	menubar = create_menu();
	gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
	gtk_widget_show(menubar);

	drawarea = gtk_drawing_area_new();
//	gtk_widget_set_double_buffered(GTK_WIDGET(drawarea), FALSE);
	gtk_widget_set_size_request(GTK_WIDGET(drawarea), 640, 400);
	gtk_box_pack_end(GTK_BOX(main_vbox), drawarea, FALSE, TRUE, 0);
	gtk_widget_show(drawarea);

	g_object_get(gtk_widget_get_settings(main_window),
	    "gtk-menu-bar-accel", &accel, NULL);
	if (accel) {
		g_object_set(gtk_widget_get_settings(main_window),
		    "gtk-menu-bar-accel", "Menu", NULL);
		g_free(accel);
	}

	gtk_widget_realize(main_window);
	gdk_window_get_origin(main_window->window, &root_x, &root_y);
	gdk_window_reparent(main_window->window, NULL, root_x, root_y);
	set_icon_bitmap(main_window);

	g_signal_connect(GTK_OBJECT(main_window), "destroy", 
	    G_CALLBACK(destroy_evhandler), (gpointer)"WM destroy");
	g_signal_connect(GTK_OBJECT(main_window), "key_press_event",
	    G_CALLBACK(key_press_evhandler), NULL);
	g_signal_connect(GTK_OBJECT(main_window), "key_release_event",
	    G_CALLBACK(key_release_evhandler), NULL);
	g_signal_connect(GTK_OBJECT(main_window), "button_press_event",
	    G_CALLBACK(button_press_evhandler), NULL);
	g_signal_connect(GTK_OBJECT(main_window), "button_release_event",
	    G_CALLBACK(button_release_evhandler), NULL);
	g_signal_connect(GTK_OBJECT(main_window), "motion_notify_event",
	    G_CALLBACK(motion_notify_evhandler), NULL);

	g_signal_connect(GTK_OBJECT(drawarea), "configure_event",
	    G_CALLBACK(configure_evhandler), NULL);
	g_signal_connect(GTK_OBJECT(drawarea), "expose_event",
	    G_CALLBACK(expose_evhandler), NULL);
}

void create_ingame_menu(MenuData *m) {
	create_menu(m);
	m->flags = MF_Abortable | MF_Transient | MF_AlwaysProcessInput;
	m->transition = NULL;
	add_menu_entry(m, "Return to Game", return_to_game, NULL);
	add_menu_entry(m, "Restart the Game", restart_game, NULL)->transition = TransFadeBlack;
	add_menu_entry(m, "Return to Title", return_to_title, NULL)->transition = TransFadeBlack;
}

void create_saverpy_menu(MenuData *m) {
	create_menu(m);
	
	m->flags = MF_Transient;
	
	add_menu_entry(m, "Yes",	save_rpy,		m);
	add_menu_entry(m, "No", (MenuAction) kill_menu, m);
}

void Menu::load(std::string filename, std::string menuname) {
	std::shared_ptr<Resource> res = loader->getResource(filename);

	if (res == nullptr)
	{
		printf("menu_creation failed\n");
		return;
	}

	if (!menuname.empty())
		create_menu(res->get(menuname));
	else
	{
		std::string startname = res->getString("start_menu");
		create_menu(res->get(startname));
	}

}

/**
 * \brief Default constructor.
 * \param env The workspace environment.
 */
bf::main_frame::main_frame( const workspace_environment& env )
: wxFrame(NULL, wxID_ANY, wxT("Bear Factory - Animation editor")),
  m_workspace(env)
{
  create_menu();
  create_toolbar();
  create_controls();
  Fit();
} // main_frame::main_frame()

void create_difficulty_menu(MenuData *m) {
	create_menu(m);
	
	add_menu_entry(m, "Easy\nfor fearful fairies", set_difficulty, (void *)D_Easy);
	add_menu_entry(m, "Normal\nfor confident kappa", set_difficulty, (void *)D_Normal);
	add_menu_entry(m, "Hard\nfor omnipotent oni", set_difficulty, (void *)D_Hard);
	add_menu_entry(m, "Lunatic\nfor gods", set_difficulty, (void *)D_Lunatic);
	
}

int main (int argc, char *argv[]) {
  GtkWidget *box, *scroll, *menu;
  GtkAccelGroup *accel = NULL;
      
  gtk_init(&argc, &argv);
  editor_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  // If the user quits the app  
  g_signal_connect(G_OBJECT(editor_window), "delete_event",
                   G_CALLBACK(delete_event), NULL);
  g_signal_connect(G_OBJECT(editor_window), "destroy",
                   G_CALLBACK(gtk_main_quit), NULL);

  gtk_window_set_title(GTK_WINDOW(editor_window),
                       "Text Editor (Insert file name)");
  gtk_window_set_default_size(GTK_WINDOW(editor_window), 600, 500);
    
  // Create a container where the menus and text widget go
  box = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(editor_window), box);
    
  // Create an accelerator for the item factory, keyboard shortcuts
  //accel = gtk_accel_group_new();
  //gtk_window_add_accel_group(GTK_WINDOW(editor_window), accel);
    
  // Create a menu bar above the text view widget
  menu = create_menu(accel);
  extend_menu(menu);

  // Put the menu in the menu container
  gtk_box_pack_start(GTK_BOX(box), menu, FALSE, FALSE, 0);
    
  //* Put a scroll window widget
  scroll = gtk_scrolled_window_new(NULL, NULL);
  gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 0);
  
  // Create the text view widget
  editor_view = gtk_text_view_new();
  gtk_container_add(GTK_CONTAINER(scroll), editor_view);

  // Get a buffer for the text view where everything gets stored
  editor_buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor_view));

  gtk_widget_show_all(editor_window);

  // Error checking
  g_set_printerr_handler(err_msg);

  // load the file if a filename is specified
  if (argc > 1)
    load_file(g_strdup(argv[1]));

  // Start the main loop
  gtk_main();

  return 0;  // for stupid compilers
}

void addto_menu(char men[], char item[], char comm[])
/* Adds an item to a menu */
{
  int n = find_menu(men);
  if (n<0) { create_menu(men); n = find_menu(men); }
  if (menus[n].numb == 9) return;
  strcpy(menus[n].iname[menus[n].numb],item);
  strcpy(menus[n].icommand[menus[n].numb],comm);
  menus[n].numb++;
}