//initializations and simple modifications for the things that will be drawn void ClientViewer::initClientViewer(int numberOfRobots, int myTeam, int _drawFactor) { #ifdef DEBUG string tmp=helper::logDirectory + helper::clientViewerDebugLogName; debug.open(tmp.c_str(), ios::out); debug << "Starting the Client Viewer!" << endl; #endif g_type_init(); //load the builder file gtk_builder_add_from_file(builder, builderPath.c_str(), NULL); GtkWidget *mainWindow = GTK_WIDGET(gtk_builder_get_object(builder, "window")); GtkToggleToolButton *info = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "Info")); GtkToolButton *zoomIn = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "ZoomIn")); GtkToolButton *zoomOut = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "ZoomOut")); GtkWidget *about = GTK_WIDGET(gtk_builder_get_object(builder, "About")); GtkWidget *infoWindow = GTK_WIDGET(gtk_builder_get_object(builder, "infoWindow")); GtkSpinButton *robotId = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "robotId")); GdkColor color; //drawing related variables drawFactor = new int(); *drawFactor = _drawFactor; int imageWidth = (VIEWDISTANCE+ROBOTDIAMETER) * (*drawFactor) * 2, imageHeight = (VIEWDISTANCE + ROBOTDIAMETER) * (*drawFactor) * 2; #ifdef DEBUG debug << "imageWidth is " << imageWidth << " and the imageHeight is " << imageHeight << endl; #endif drawingArea = GTK_DRAWING_AREA(gtk_builder_get_object(builder, "drawingArea")); gtk_widget_set_size_request(GTK_WIDGET(drawingArea), imageWidth, imageHeight); gtk_window_resize(GTK_WINDOW(mainWindow), imageWidth, imageHeight); //set the upper value for the spin button gtk_adjustment_set_upper(GTK_ADJUSTMENT(gtk_builder_get_object(builder, "robotIdAdjustment")), numberOfRobots - 1); gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builder, "robotIdAdjustment")), -1); //keep the info window floating on top of the main window gtk_window_set_keep_above(GTK_WINDOW(infoWindow), true); //change the color of the main window's background to black gdk_color_parse("black", &color); gtk_widget_modify_bg(GTK_WIDGET(mainWindow), GTK_STATE_NORMAL, &color); //change the color of the info window text gdk_color_parse("white", &color); gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labSpeed")), GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labAngle")), GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labFrames")), GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labPuck")), GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labHome")), GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labDestination")), GTK_STATE_NORMAL, &color); gtk_widget_modify_bg(GTK_WIDGET(drawingArea), GTK_STATE_NORMAL, &color); g_signal_connect(robotId, "value-changed", G_CALLBACK(onRobotIdChanged), (gpointer) & viewedRobot); g_signal_connect(info, "toggled", G_CALLBACK(onWindowToggled), (gpointer) infoWindow); g_signal_connect(about, "clicked", G_CALLBACK(onAboutClicked), (gpointer) mainWindow); g_signal_connect(zoomIn, "clicked", G_CALLBACK(onZoomInClicked), (gpointer)(new passToZoom( drawFactor, mainWindow, drawingArea, zoomIn, zoomOut))); g_signal_connect(zoomOut, "clicked", G_CALLBACK(onZoomOutClicked), (gpointer)(new passToZoom(drawFactor, mainWindow, drawingArea, zoomIn, zoomOut))); g_signal_connect(gtk_builder_get_object(builder, "Exit"), "clicked", G_CALLBACK(quitButtonDestroy), (gpointer)new passToQuit(&viewedRobot, mainWindow)); g_signal_connect(mainWindow, "destroy", G_CALLBACK(mainDestroy), (gpointer) &viewedRobot); g_signal_connect(mainWindow, "delete-event", G_CALLBACK(mainDeleteEvent), (gpointer) &viewedRobot); g_signal_connect(infoWindow, "destroy", G_CALLBACK(infoDestroy), (gpointer) info); g_signal_connect(infoWindow, "delete-event", G_CALLBACK(infoDeleteEvent), (gpointer) info); g_signal_connect(drawingArea, "expose-event", G_CALLBACK(drawingAreaExpose), (gpointer)( new passToDrawingAreaExpose(myTeam, numberOfRobots, drawFactor, &draw, &ownRobotDraw, info, builder))); gtk_widget_show_all(mainWindow); }
GtkDrawingArea* cast_GtkDrawingArea(GtkWidget* widget) { return GTK_DRAWING_AREA(widget); }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t)); dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data; c->mouse_x = c->mouse_y = -1.0; c->dragging = 0; c->activeToggleButton = NULL; c->current_pick = NONE; c->last_picked_color = -1; for (int i=0; i<3; i++) for (int j=0; j<2; j++) c->pick_xy_positions[i][j] = 0.5; self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 5)); c->area = GTK_DRAWING_AREA(gtk_drawing_area_new()); GtkWidget *asp = gtk_aspect_frame_new(NULL, 0.5, 0.5, 1.0, TRUE); gtk_box_pack_start(GTK_BOX(self->widget), asp, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(asp), GTK_WIDGET(c->area)); gtk_drawing_area_size(c->area, 258, 150); g_object_set (GTK_OBJECT(c->area), "tooltip-text", _("drag handles to set black, grey, and white points. operates on L channel."), (char *)NULL); gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK); g_signal_connect (G_OBJECT (c->area), "expose-event", G_CALLBACK (dt_iop_levels_expose), self); g_signal_connect (G_OBJECT (c->area), "button-press-event", G_CALLBACK (dt_iop_levels_button_press), self); g_signal_connect (G_OBJECT (c->area), "button-release-event", G_CALLBACK (dt_iop_levels_button_release), self); g_signal_connect (G_OBJECT (c->area), "motion-notify-event", G_CALLBACK (dt_iop_levels_motion_notify), self); g_signal_connect (G_OBJECT (c->area), "leave-notify-event", G_CALLBACK (dt_iop_levels_leave_notify), self); g_signal_connect (G_OBJECT (c->area), "scroll-event", G_CALLBACK (dt_iop_levels_scroll), self); GtkWidget *autobutton = dtgtk_button_new_with_label(_("auto"), NULL, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); g_object_set(G_OBJECT(autobutton), "tooltip-text", _("apply auto levels"), (char *)NULL); gtk_widget_set_size_request(autobutton, 70, 24); GtkWidget *blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(blackpick), "tooltip-text", _("pick blackpoint from image"), (char *)NULL); gtk_widget_set_size_request(blackpick, 24, 24); GtkWidget *greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(greypick), "tooltip-text", _("pick medium greypoint from image"), (char *)NULL); gtk_widget_set_size_request(greypick, 24, 24); GtkWidget *whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(whitepick), "tooltip-text", _("pick whitepoint from image"), (char *)NULL); gtk_widget_set_size_request(whitepick, 24, 24); GdkColor col; col.red = col.green = col.blue = 0; gtk_widget_modify_fg(GTK_WIDGET(blackpick), GTK_STATE_NORMAL, &col); gtk_widget_modify_fg(GTK_WIDGET(blackpick), GTK_STATE_SELECTED, &col); col.red = col.green = col.blue = 32767; gtk_widget_modify_fg(GTK_WIDGET(greypick), GTK_STATE_NORMAL, &col); gtk_widget_modify_fg(GTK_WIDGET(greypick), GTK_STATE_SELECTED, &col); col.red = col.green = col.blue = 65535; gtk_widget_modify_fg(GTK_WIDGET(whitepick), GTK_STATE_NORMAL, &col); gtk_widget_modify_fg(GTK_WIDGET(whitepick), GTK_STATE_SELECTED, &col); col.red = col.green = col.blue = 4096; gtk_widget_modify_bg(GTK_WIDGET(blackpick), GTK_STATE_ACTIVE, &col); gtk_widget_modify_bg(GTK_WIDGET(greypick), GTK_STATE_ACTIVE, &col); gtk_widget_modify_bg(GTK_WIDGET(whitepick), GTK_STATE_ACTIVE, &col); GtkWidget *box = gtk_hbox_new(TRUE,0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(blackpick), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(greypick), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(whitepick), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0); g_signal_connect (G_OBJECT(autobutton), "clicked", G_CALLBACK(dt_iop_levels_autoadjust_callback), (gpointer)self); g_signal_connect (G_OBJECT(blackpick), "toggled", G_CALLBACK (dt_iop_levels_pick_black_callback), self); g_signal_connect (G_OBJECT(greypick), "toggled", G_CALLBACK (dt_iop_levels_pick_grey_callback), self); g_signal_connect (G_OBJECT(whitepick), "toggled", G_CALLBACK (dt_iop_levels_pick_white_callback), self); }
int main(int argc,char *argv[]) { char dmmy[20]; GtkWidget *main_window; GtkWidget *v_box; GtkWidget *h_box; GtkWidget *box1; GtkWidget *box2; GtkWidget *right_side; GtkWidget *game_border; GtkWidget *next_block_border; GdkBitmap *mask; GtkWidget *menu_bar; GtkWidget *menu_game; GtkWidget *menu_game_menu; GtkWidget *separatormenuitem1; GtkWidget *separator1; GtkWidget *menu_settings; GtkWidget *menu_settings_menu; GtkWidget *menu_help; GtkWidget *menu_help_menu; GtkWidget *help1; GtkWidget *high_scores1; GtkWidget *separator2; GtkWidget *about1; GtkAccelGroup* accel_group; //init game values game_play=FALSE; get_opt_file(options_f,100); read_options(); game_over = TRUE; game_pause = FALSE; current_x = current_y = 0; current_block = current_frame = 0; current_score = current_lines = 0; current_level = options.level; next_block = next_frame = 0; // seed random generator srandom(time(NULL)); //options.shw_nxt = TRUE; gtk_set_locale(); gtk_init(&argc,&argv); accel_group = gtk_accel_group_new(); // window main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_policy(GTK_WINDOW(main_window),FALSE,FALSE,TRUE); gtk_window_set_title(GTK_WINDOW(main_window),"GTK Tetris"); g_signal_connect ((gpointer) main_window, "key_press_event", G_CALLBACK (keyboard_event_handler), NULL); // vertical box v_box = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(main_window),v_box); gtk_widget_show(v_box); // menu stuff menu_bar = gtk_menu_bar_new(); gtk_widget_show(menu_bar); gtk_box_pack_start(GTK_BOX(v_box),menu_bar,FALSE,FALSE,0); //Game sub-menu menu_game=gtk_menu_item_new_with_mnemonic ("_Game"); gtk_widget_show(menu_game); gtk_container_add (GTK_CONTAINER (menu_bar), menu_game); menu_game_menu=gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_game), menu_game_menu); menu_game_quick = gtk_menu_item_new_with_mnemonic ("Start Game"); gtk_widget_show (menu_game_quick); gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quick); g_signal_connect ((gpointer) menu_game_quick, "activate", G_CALLBACK (game_start_stop), NULL); gtk_widget_add_accelerator (menu_game_quick, "activate", accel_group, GDK_G, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); menu_game_stop = gtk_menu_item_new_with_mnemonic ("Stop Game"); gtk_widget_show (menu_game_stop); gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_stop); g_signal_connect ((gpointer) menu_game_stop, "activate", G_CALLBACK (game_start_stop), NULL); gtk_widget_add_accelerator (menu_game_stop, "activate", accel_group, GDK_O, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_set_sensitive(menu_game_stop,FALSE); menu_game_pause = gtk_check_menu_item_new_with_mnemonic ("Pause"); gtk_widget_show (menu_game_pause); gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_pause); g_signal_connect ((gpointer) menu_game_pause, "activate", G_CALLBACK (game_set_pause), NULL); gtk_widget_add_accelerator (menu_game_pause, "activate", accel_group, GDK_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); separatormenuitem1 = gtk_menu_item_new (); gtk_widget_show (separatormenuitem1); gtk_container_add (GTK_CONTAINER (menu_game_menu), separatormenuitem1); gtk_widget_set_sensitive (separatormenuitem1, FALSE); menu_game_quit = gtk_menu_item_new_with_mnemonic ("Quit"); gtk_widget_show (menu_game_quit); gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quit); g_signal_connect ((gpointer) menu_game_quit, "activate", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_add_accelerator(menu_game_quit,"activate", accel_group, GDK_X, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); //Settings sub-menu menu_settings = gtk_menu_item_new_with_mnemonic ("_Settings"); gtk_widget_show (menu_settings); gtk_container_add (GTK_CONTAINER (menu_bar), menu_settings); menu_settings_menu=gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_settings), menu_settings_menu); menu_game_start = gtk_menu_item_new_with_mnemonic ("Level Settings"); gtk_widget_show (menu_game_start); gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_start); g_signal_connect ((gpointer) menu_game_start, "activate", G_CALLBACK (show_new_game), NULL); menu_game_show_next_block = gtk_check_menu_item_new_with_mnemonic ("Show next block"); gtk_widget_show (menu_game_show_next_block); gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_show_next_block); if (options.shw_nxt) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_game_show_next_block), TRUE); g_signal_connect ((gpointer) menu_game_show_next_block, "activate", G_CALLBACK (game_show_next_block), NULL); gtk_widget_add_accelerator (menu_game_show_next_block, "activate", accel_group, GDK_N, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); separator1 = gtk_menu_item_new (); gtk_widget_show (separator1); gtk_container_add (GTK_CONTAINER (menu_settings_menu), separator1); gtk_widget_set_sensitive (separator1, FALSE); menu_save_options = gtk_menu_item_new_with_mnemonic ("Save Settings"); gtk_widget_show (menu_save_options); gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_save_options); g_signal_connect ((gpointer) menu_save_options, "activate", G_CALLBACK (save_options), NULL); //Help sub-menu menu_help=gtk_menu_item_new_with_mnemonic ("_Help"); gtk_widget_show (menu_help); gtk_container_add (GTK_CONTAINER (menu_bar), menu_help); gtk_menu_item_set_right_justified (GTK_MENU_ITEM(menu_help),TRUE); menu_help_menu = gtk_menu_new(); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_help), menu_help_menu); help1 = gtk_menu_item_new_with_mnemonic ("Help"); gtk_widget_show (help1); gtk_container_add (GTK_CONTAINER (menu_help_menu), help1); g_signal_connect ((gpointer) help1, "activate", G_CALLBACK (show_help), NULL); gtk_widget_add_accelerator (help1, "activate", accel_group, GDK_F1, (GdkModifierType) 0, GTK_ACCEL_VISIBLE); high_scores1 = gtk_menu_item_new_with_mnemonic ("High-scores"); gtk_widget_show (high_scores1); gtk_container_add (GTK_CONTAINER (menu_help_menu), high_scores1); g_signal_connect ((gpointer) high_scores1, "activate", G_CALLBACK (show_highscore_wrapper), NULL); separator2 = gtk_menu_item_new (); gtk_widget_show (separator2); gtk_container_add (GTK_CONTAINER (menu_help_menu), separator2); gtk_widget_set_sensitive (separator2, FALSE); about1 = gtk_menu_item_new_with_mnemonic ("About"); gtk_widget_show (about1); gtk_container_add (GTK_CONTAINER (menu_help_menu), about1); g_signal_connect ((gpointer) about1, "activate", G_CALLBACK (show_about), NULL); // horizontal box h_box = gtk_hbox_new(FALSE,1); gtk_widget_show(h_box); gtk_box_pack_start(GTK_BOX(v_box),h_box,FALSE,FALSE,0); // game_border game_border = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(game_border),GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(h_box),game_border,FALSE,FALSE,1); gtk_widget_show(game_border); // game_area game_area = gtk_drawing_area_new(); gtk_widget_show(game_area); gtk_drawing_area_size(GTK_DRAWING_AREA(game_area), MAX_X*BLOCK_WIDTH,MAX_Y*BLOCK_HEIGHT); g_signal_connect ((gpointer) game_area, "expose_event", G_CALLBACK (game_area_expose_event), NULL); gtk_widget_set_events(game_area, GDK_EXPOSURE_MASK); gtk_container_add(GTK_CONTAINER(game_border),game_area); // right_side right_side = gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(h_box),right_side,FALSE,FALSE,0); gtk_widget_show(right_side); // next_block_border next_block_border = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(next_block_border),GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(right_side),next_block_border,FALSE,FALSE,0); gtk_widget_show(next_block_border); // next_block_area next_block_area = gtk_drawing_area_new(); gtk_widget_show(next_block_area); gtk_drawing_area_size(GTK_DRAWING_AREA(next_block_area), 4*BLOCK_WIDTH,4*BLOCK_HEIGHT); g_signal_connect ((gpointer) next_block_area, "expose_event", G_CALLBACK (next_block_area_expose_event), NULL); gtk_widget_set_events(next_block_area, GDK_EXPOSURE_MASK); gtk_container_add(GTK_CONTAINER(next_block_border),next_block_area); // the score,level and lines labels score_label1 = gtk_label_new("Score:"); gtk_label_set_justify(GTK_LABEL(score_label1),GTK_JUSTIFY_RIGHT); gtk_widget_show(score_label1); gtk_box_pack_start(GTK_BOX(right_side),score_label1,FALSE,FALSE,3); score_label2 = gtk_label_new("0"); set_gtk_color_style(score_label2,0xffff,0,0); gtk_label_set_justify(GTK_LABEL(score_label2),GTK_JUSTIFY_RIGHT); gtk_widget_show(score_label2); gtk_box_pack_start(GTK_BOX(right_side),score_label2,FALSE,FALSE,3); level_label1 = gtk_label_new("Level:"); gtk_label_set_justify(GTK_LABEL(level_label1),GTK_JUSTIFY_RIGHT); gtk_widget_show(level_label1); gtk_box_pack_start(GTK_BOX(right_side),level_label1,FALSE,FALSE,3); sprintf(dmmy,"%d",current_level); level_label2 = gtk_label_new(dmmy); set_gtk_color_style(level_label2,0,0,0xffff); gtk_label_set_justify(GTK_LABEL(level_label2),GTK_JUSTIFY_RIGHT); gtk_widget_show(level_label2); gtk_box_pack_start(GTK_BOX(right_side),level_label2,FALSE,FALSE,3); lines_label1 = gtk_label_new("Lines:"); gtk_label_set_justify(GTK_LABEL(lines_label1),GTK_JUSTIFY_RIGHT); gtk_widget_show(lines_label1); gtk_box_pack_start(GTK_BOX(right_side),lines_label1,FALSE,FALSE,3); lines_label2 = gtk_label_new("0"); gtk_label_set_justify(GTK_LABEL(lines_label2),GTK_JUSTIFY_RIGHT); gtk_widget_show(lines_label2); gtk_box_pack_start(GTK_BOX(right_side),lines_label2,FALSE,FALSE,3); //the game buttons //Start_stop Start_stop_button = gtk_button_new(); gtk_widget_show(Start_stop_button); g_signal_connect ((gpointer) Start_stop_button, "clicked", G_CALLBACK (game_start_stop), NULL); Start_stop_button_label= gtk_label_new(start_stop_str[0]); box2 = label_box(right_side, Start_stop_button_label, start_stop_str[0] ); gtk_widget_show(box2); gtk_container_add (GTK_CONTAINER (Start_stop_button), box2); gtk_box_pack_start(GTK_BOX(right_side),Start_stop_button,FALSE,FALSE,3); GTK_WIDGET_SET_FLAGS(Start_stop_button, GTK_CAN_DEFAULT); gtk_widget_grab_default(Start_stop_button); //Pause Pause_button = gtk_button_new(); gtk_widget_show(Pause_button); g_signal_connect ((gpointer) Pause_button, "clicked", G_CALLBACK (game_set_pause_b), NULL); Pause_button_label = gtk_label_new(pause_str[0]); box1 = label_box(right_side, Pause_button_label, pause_str[0] ); gtk_widget_show(box1); gtk_container_add (GTK_CONTAINER (Pause_button), box1); gtk_box_pack_start(GTK_BOX(right_side),Pause_button,FALSE,FALSE,3); GTK_WIDGET_SET_FLAGS(Pause_button, GTK_CAN_DEFAULT); gtk_widget_set_sensitive(Pause_button,FALSE); gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group); gtk_widget_show(main_window); // Block images... blocks_pixmap = gdk_pixmap_create_from_xpm_d(game_area->window, &mask, NULL, (gchar **)blocks_xpm); gtk_main (); return 0; }
/* Create a gui_window */ struct gui_window *gui_create_browser_window(struct browser_window *bw, struct browser_window *clone, bool new_tab) { struct gui_window *g; /**< what we're creating to return */ g = (struct gui_window *)malloc(sizeof(*g)); if (!g) { warn_user("NoMemory", 0); return 0; } LOG(("Creating gui window %p for browser window %p", g, bw)); g->bw = bw; g->mouse.state = 0; g->current_pointer = GUI_POINTER_DEFAULT; if (clone != NULL) bw->scale = clone->scale; else bw->scale = (float) nsoption_int(scale) / 100; g->careth = 0; g->pending_resizes = 0; /* Attach ourselves to the list (push_top) */ if (window_list) window_list->prev = g; g->next = window_list; g->prev = NULL; window_list = g; /* Now construct and attach a scaffold */ g->scaffold = nsbeos_new_scaffolding(g); if (!g->scaffold) return NULL; /* Construct our primary elements */ BRect frame(0,0,-1,-1); // will be resized later g->view = new NSBrowserFrameView(frame, g); /* set the default background colour of the drawing area to white. */ //g->view->SetViewColor(kWhiteColor); /* NOOO! Since we defer drawing (DetachCurrent()), the white flickers, * besides sometimes text was drawn twice, making it ugly. * Instead we set to transparent here, and implement plot_clg() to * do it just before the rest. This almost removes the flicker. */ g->view->SetViewColor(B_TRANSPARENT_COLOR); g->view->SetLowColor(kWhiteColor); #ifdef B_BEOS_VERSION_DANO /* enable double-buffering on the content view */ /* XXX: doesn't really work g->view->SetDoubleBuffering(B_UPDATE_INVALIDATED | B_UPDATE_SCROLLED //| B_UPDATE_RESIZED | B_UPDATE_EXPOSED); */ #endif g->toplevel = true; /* Attach our viewport into the scaffold */ nsbeos_attach_toplevel_view(g->scaffold, g->view); #warning WRITEME #if 0 /* GTK */ GtkPolicyType scrollpolicy; /* Construct our primary elements */ g->fixed = GTK_FIXED(gtk_fixed_new()); g->drawing_area = GTK_DRAWING_AREA(gtk_drawing_area_new()); gtk_fixed_put(g->fixed, GTK_WIDGET(g->drawing_area), 0, 0); gtk_container_set_border_width(GTK_CONTAINER(g->fixed), 0); g->scrolledwindow = 0; g->viewport = GTK_VIEWPORT(gtk_viewport_new(NULL, NULL)); /* Need to attach adjustments */ gtk_container_add(GTK_CONTAINER(g->viewport), GTK_WIDGET(g->fixed)); /* Attach our viewport into the scaffold */ nsbeos_attach_toplevel_viewport(g->scaffold, g->viewport); gtk_container_set_border_width(GTK_CONTAINER(g->viewport), 0); gtk_viewport_set_shadow_type(g->viewport, GTK_SHADOW_NONE); if (g->scrolledwindow) gtk_widget_show(GTK_WIDGET(g->scrolledwindow)); /* And enable visibility from our viewport down */ gtk_widget_show(GTK_WIDGET(g->viewport)); gtk_widget_show(GTK_WIDGET(g->fixed)); gtk_widget_show(GTK_WIDGET(g->drawing_area)); switch(bw->scrolling) { case SCROLLING_NO: scrollpolicy = GTK_POLICY_NEVER; break; case SCROLLING_YES: scrollpolicy = GTK_POLICY_ALWAYS; break; case SCROLLING_AUTO: default: scrollpolicy = GTK_POLICY_AUTOMATIC; break; }; if (g->scrolledwindow) gtk_scrolled_window_set_policy(g->scrolledwindow, scrollpolicy, scrollpolicy); /* set the events we're interested in receiving from the browser's * drawing area. */ gtk_widget_add_events(GTK_WIDGET(g->drawing_area), GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(g->drawing_area), GTK_CAN_FOCUS); /* set the default background colour of the drawing area to white. */ gtk_widget_modify_bg(GTK_WIDGET(g->drawing_area), GTK_STATE_NORMAL, &((GdkColor) { 0, 0xffff, 0xffff, 0xffff } )); #define CONNECT(obj, sig, callback, ptr) \ g_signal_connect(G_OBJECT(obj), (sig), G_CALLBACK(callback), (ptr)) CONNECT(g->drawing_area, "expose_event", nsgtk_window_expose_event, g); CONNECT(g->drawing_area, "motion_notify_event", nsgtk_window_motion_notify_event, g); CONNECT(g->drawing_area, "button_press_event", nsgtk_window_button_press_event, g); CONNECT(g->drawing_area, "key_press_event", nsgtk_window_keypress_event, g); CONNECT(g->viewport, "size_allocate", nsgtk_window_size_allocate_event, g); #endif return g; }
int main(int argc, char **argv) { GtkWidget *win; GtkWidget *twin; // toolbar window GtkWidget *swin; const char *filename = NULL; //g_thread_init(NULL); //gdk_threads_init(); gdk_threads_enter(); gtk_init(&argc, &argv); printf("%s\n", S52_version()); //printf("float: %.02f \n", 3.1416); // 3.14 //printf("float: %.2f \n", 3.1416); // 3.14 //printf("float: %.02f \n", 3.1); // 3.10 //printf("float: %.2f \n", 3.1); // 3.10 //printf("float: %.2f \n", 3.665); // 3.67 //printf("float: %.2f \n", 3.664); // 3.66 //return 1; filename = _option(argc, argv); _dumpSetUp(); VecView = gv_view_area_new(); if (NULL == VecView){ printf("main.c:ERROR: VecView == NULL!! no OpenGL .. exit!\n"); exit(0); } win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_signal_connect(GTK_OBJECT(win), "destroy", GTK_SIGNAL_FUNC(_destroy), NULL); toolbox = GV_TOOLBOX(gv_toolbox_new()); gv_toolbox_add_tool(toolbox, "select", gv_selection_tool_new()); gv_toolbox_add_tool(toolbox, "zoompan", gv_zoompan_tool_new()); gv_toolbox_add_tool(toolbox, "point", gv_point_tool_new()); gv_toolbox_add_tool(toolbox, "line", gv_line_tool_new()); gv_toolbox_add_tool(toolbox, "area", gv_area_tool_new()); gv_toolbox_add_tool(toolbox, "node", gv_node_tool_new()); gv_toolbox_add_tool(toolbox, "roi", gv_roi_tool_new()); link = GV_VIEW_LINK(gv_view_link_new()); gtk_window_set_default_size( GTK_WINDOW(win), 800, 600 ); // 2D gv_view_area_set_mode(GV_VIEW_AREA(VecView), 0); gtk_drawing_area_size(GTK_DRAWING_AREA(VecView), 800, 600); swin = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(win), swin); gtk_container_add(GTK_CONTAINER(swin), VecView); //gv_view_area_add_layer(GV_VIEW_AREA(view), gv_shapes_layer_new(shapes)); gtk_signal_connect_object(GTK_OBJECT(VecView), "key-press-event", GTK_SIGNAL_FUNC(_key_press_cb), GTK_OBJECT(VecView)); gtk_widget_show(VecView); gtk_widget_show(swin); gtk_widget_show(win); gtk_widget_grab_focus(VecView); gtk_signal_connect(GTK_OBJECT(win), "delete-event", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_quit_add_destroy(1, GTK_OBJECT(win)); gv_tool_activate(GV_TOOL(toolbox), GV_VIEW_AREA(VecView)); gv_toolbox_activate_tool(toolbox, "zoompan" ); twin = _create_toolbar(); _loadCell(filename); gtk_main(); gdk_threads_leave(); // FIXME: do we ever get here! // put back env. var. as it was /* if (NULL != genv){ setenv("OGR_S57_OPTIONS", genv->str, 1); g_string_free(genv, TRUE); } */ printf("exit main()\n"); return 0; }
//! initialization of the board void board_init () { int i; GdkColormap *board_colormap; Game *game = opt_game; GdkGC *def_gc = gdk_gc_new ((GdkWindow *)board_area->window); // GtkWidget *hbox, *vbox; state_board_flipped = FALSE; if (!game) { #if GTK_MAJOR_VERSION == 1 gtk_drawing_area_size (GTK_DRAWING_AREA (board_area), 300, 300); #else gtk_widget_set_size_request (GTK_WIDGET (board_area), 300, 300); #endif return; } #if GTK_MAJOR_VERSION == 1 gtk_drawing_area_size (GTK_DRAWING_AREA (board_area), cell_size * board_wid, cell_size * board_heit); #else gtk_widget_set_size_request (GTK_WIDGET (board_area), cell_size * board_wid, cell_size * board_heit); #endif pieces = (GdkPixmap **) malloc (2 * num_pieces * sizeof (GdkPixmap *)); g_assert (pieces); piece_masks = (GdkBitmap **) malloc (2 * num_pieces * sizeof (GdkBitmap *)); g_assert (piece_masks); for (i=0; i<2*num_pieces; i++) pieces[i] = NULL; if (game_file_label) { board_rowbox_real = gtk_hbox_new (TRUE, 0); gtk_box_pack_end (GTK_BOX (board_rowbox), board_rowbox_real, FALSE, FALSE, 0); #if GTK_MAJOR_VERSION == 1 gtk_widget_set_usize (GTK_WIDGET (board_rowbox_real), cell_size * board_wid, -1); #else gtk_widget_set_size_request (GTK_WIDGET (board_rowbox_real), cell_size * board_wid, -1); #endif for (i=0; i<board_wid; i++) gtk_container_add (GTK_CONTAINER (board_rowbox_real), gtk_label_new (board_get_file_label_str (game_file_label, i))); gtk_widget_show_all (board_rowbox); } if (game_rank_label) { board_colbox_real = gtk_vbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (board_colbox), board_colbox_real, FALSE, FALSE, 0); #if GTK_MAJOR_VERSION == 1 gtk_widget_set_usize (GTK_WIDGET (board_colbox_real), -1, cell_size * board_heit); #else gtk_widget_set_size_request (GTK_WIDGET (board_colbox_real), -1, cell_size * board_heit); #endif for (i=0; i<board_heit; i++) gtk_container_add (GTK_CONTAINER (board_colbox_real), gtk_label_new (board_get_rank_label_str (game_rank_label, i))); gtk_widget_show_all (board_colbox); } if (game->colors == NULL) game->colors = board_default_colors; board_colormap = gdk_colormap_get_system (); board_color_init (&game->colors[0], &board_colors[0], &board_gcs[0], board_colormap, board_area); board_color_init (&game->colors[3], &board_colors[1], &board_gcs[1], board_colormap, board_area); if (game_draw_cell_boundaries) board_color_init (&game->colors[6], &board_colors[2], &board_gcs[2], board_colormap, board_area); if (game_highlight_colors) for (i=0; i<3; i++) board_color_init (&game_highlight_colors[3*i], &board_highlight_colors[i], &board_highlight_gcs[i], board_colormap, board_area); { char buttonize_colors [6] = {240, 240, 240, 128, 128, 128}; for (i=0; i<2; i++) board_color_init (&buttonize_colors[3*i], &board_buttonize_colors[i], &board_buttonize_gcs[i], board_colormap, board_area); } g_assert (num_pieces); for (i=0; i<2*num_pieces; i++) { char **pixmap = NULL; guchar *rgbbuf = NULL; { byte *colors = game->colors; if (i >= num_pieces && colors[0] == colors[3] && colors[1] == colors[4] && colors[2] == colors[5]) { pieces[i] = pieces[i-num_pieces]; piece_masks[i] = piece_masks[i-num_pieces]; continue; } } if (game_get_rgbmap) { rgbbuf = game_get_rgbmap(1+i%num_pieces, i < num_pieces ? WHITE: BLACK); if (rgbbuf) { pieces[i] = gdk_pixmap_new ( board_area->window, cell_size, cell_size, -1); gdk_draw_rgb_image ((GdkDrawable *)pieces[i], def_gc, 0, 0, cell_size, cell_size, GDK_RGB_DITHER_MAX, rgbbuf, cell_size * 3); } piece_masks[i] = NULL; } else { if (game_get_pixmap) pixmap = game_get_pixmap (1+i%num_pieces, i < num_pieces ? WHITE: BLACK); else pixmap = game->pixmaps [i%num_pieces]; if (pixmap) { pieces[i] = gdk_pixmap_colormap_create_from_xpm_d (NULL, board_colormap, &piece_masks[i], board_colors + i / num_pieces, pixmap); assert (pieces[i]); } else piece_masks[i] = NULL; } } if (game_bg_pixmap) { board_bgimage = gdk_pixmap_colormap_create_from_xpm_d (NULL, board_colormap, NULL, board_colors, game_bg_pixmap); assert (board_bgimage); } gdk_gc_destroy (def_gc); }
static void abi_table_init (AbiTable* table) { UT_UTF8String prText = "%d x %d "; char* text = g_strdup_printf(prText.utf8_str(), init_rows, init_cols); register_stock_icon(); table->button_box = gtk_vbox_new(FALSE, 0); table->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP)); table->window_vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0)); table->area = GTK_DRAWING_AREA(gtk_drawing_area_new()); table->handlers = 0; table->window_label = GTK_LABEL(gtk_label_new(text)); g_free(text); table->szTable = NULL; table->szCancel = NULL; gtk_container_add(GTK_CONTAINER(table->window), GTK_WIDGET(table->window_vbox)); gtk_box_pack_end(GTK_BOX(table->window_vbox), GTK_WIDGET(table->window_label), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(table->window_vbox), GTK_WIDGET(table->area), TRUE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(table->window_vbox)); table->selected_rows = init_rows; table->selected_cols = init_cols; table->total_rows = my_max(init_rows + 1, 5); table->total_cols = my_max(init_cols + 1, 6); abi_table_resize(table); table->icon = NULL; if (gtk_stock_lookup ("abi-table-widget", &table->stock_item)) { table->label = gtk_label_new_with_mnemonic(table->stock_item.label); table->icon = gtk_image_new_from_stock ("abi-table-widget", GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_widget_show(table->icon); gtk_widget_show(table->label); // // We actually never want this label in toolbar // gtk_box_pack_end(GTK_BOX(table->button_box), table->label, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(table->button_box), table->icon, FALSE, FALSE, 0); UT_DEBUGMSG(("abi-table icon loaded %p !\n",table->icon)); } else { /* it should not happen... */ UT_DEBUGMSG(("abi-table icon did not load !\n")); UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN); table->label = gtk_label_new_with_mnemonic("_Table"); // gtk_box_pack_end(GTK_BOX(table->button_box), table->label, FALSE, FALSE, 0); } gtk_container_add(GTK_CONTAINER(table), GTK_WIDGET(table->button_box)); g_signal_connect(G_OBJECT(table), "pressed", G_CALLBACK(on_pressed), static_cast<gpointer>(table)); g_signal_connect(G_OBJECT(table->area), "expose_event", G_CALLBACK(on_drawing_area_event), static_cast<gpointer>(table)); g_signal_connect(G_OBJECT(table->area), "motion_notify_event", G_CALLBACK(on_motion_notify_event), static_cast<gpointer>(table)); g_signal_connect(G_OBJECT(table->area), "button_release_event", G_CALLBACK(on_button_release_event), static_cast<gpointer>(table)); g_signal_connect(G_OBJECT(table->area), "button_press_event", G_CALLBACK(on_button_release_event), static_cast<gpointer>(table)); g_signal_connect(G_OBJECT(table->area), "leave_notify_event", G_CALLBACK(on_leave_event), static_cast<gpointer>(table)); g_signal_connect(G_OBJECT(table->window), "key_press_event", G_CALLBACK(on_key_event), static_cast<gpointer>(table)); gtk_widget_set_events (GTK_WIDGET(table->area), GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK); gtk_button_set_relief (GTK_BUTTON (table), GTK_RELIEF_NORMAL); }
int main(int argc, char *argv[]) { // GtkWidget *window; GtkWidget *fixed; GtkWidget *area; // gtk_init(&argc, &argv); // Window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "gui"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(window), 0); gtk_window_set_default_size(GTK_WINDOW(window), width, height); printf("window ok\n"); // layout fixed = gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(window), fixed); printf("fixed ok\n"); // Image GList *visuals = gdk_list_visuals(); void tst(gpointer data, gpointer udata) { if (((GdkVisual*)data)->depth == 32) printf("visual :\n\ttype = %d\n\ttype = %d\n\tdepth = %d\n\tbits/rgb = %d\n\torder = %d\n\tred = %08X\n\tgreen = %08X\n\tblue = %08X\n" , ((GdkVisual*)data)->type , ((GdkVisual*)data)->colormap_size , ((GdkVisual*)data)->depth , ((GdkVisual*)data)->bits_per_rgb , ((GdkVisual*)data)->byte_order , ((GdkVisual*)data)->red_mask , ((GdkVisual*)data)->green_mask , ((GdkVisual*)data)->blue_mask ); } g_list_foreach(visuals, &tst, NULL); GdkVisual *visu = gdk_visual_get_best_with_depth(32); ximg = gdk_image_new(GDK_IMAGE_SHARED, visu, width, height); printf("GdkImage : bytes/pix = %d, linesize = %d, bits/pix = %d ; type %d (mem = %p)\n" , ximg->bpp, ximg->bpl, ximg->bits_per_pixel , ximg->type, ximg->mem ); // GdkPixbufAnimation //gtk_image_set_from_pixbuf // GdkColormap *dcm = gdk_colormap_new(visu, FALSE); // drawing area area = gtk_drawing_area_new(); gdk_drawable_set_colormap(window, dcm); gdk_drawable_set_colormap(area, dcm); gtk_drawing_area_size(GTK_DRAWING_AREA(area), width, height); printf("area ok\n"); // gtk_fixed_put(GTK_FIXED(fixed), area, 0, 0); printf("fixed ok\n"); // bgra_alloc650(&bgra, width, height); bgra_origin650(&bgra, +width/2, +height/2); bgra_scale650(&bgra, 1, -1); printf("bgra alloc ok\n"); maj(); printf("bgra maj done, still (%p <- %p)\n", ximg->mem, bgra.data); // // Ximg // memcpy(ximg->mem, bgra.data, bgra.size); // printf("mcpy done\n"); // Pixmap GdkColor bg; GdkColor fg; fg.pixel = 0xff000000; fg.red = 0; fg.green = 0; fg.blue = 0; bg.pixel = 0xff000000; bg.red = 0; bg.green = 0; bg.blue = 0; pixmap = gdk_pixmap_create_from_data( GTK_WINDOW(window) , bgra.data , width , height , 32 , &fg , &bg ); // img = gdk_pixbuf_new_from_data( // (guchar*)bgra.data // , GDK_COLORSPACE_RGB // , TRUE // , 8 // , width // , height // , width << 2 // , &pbd, NULL // ); // printf("PixBuf new ok\n"); // // Image // frame = gtk_image_new_from_pixbuf(img); //// frame = gtimg; // gtk_fixed_put(GTK_FIXED(fixed), frame, 0, 0); // printf("fixed ok\n"); // Events g_signal_connect(area, "expose-event", G_CALLBACK (on_expose_event), NULL); // g_signal_connect(frame, "expose-event", G_CALLBACK (on_expose_event), NULL); g_signal_connect(window, "delete-event", G_CALLBACK (delete_event), NULL); g_signal_connect(window, "destroy", G_CALLBACK (destroy), NULL); printf("signals ok\n"); // Show // gtk_widget_show(area); gtk_widget_show(fixed); gtk_widget_show_all(window); printf("show ok\n"); // Timer g_timeout_add(500, (GSourceFunc)time_handler, (gpointer)area); printf("timer ok\n"); gtk_main(); return 0; }
GtkWidget * do_drawingarea (GtkWidget *do_widget) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *da; GtkWidget *label; GtkGesture *drag; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Drawing Area"); g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); g_object_set (vbox, "margin", 16, NULL); gtk_container_add (GTK_CONTAINER (window), vbox); /* * Create the checkerboard area */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Checkerboard pattern</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_vexpand (frame, TRUE); gtk_container_add (GTK_CONTAINER (vbox), frame); da = gtk_drawing_area_new (); gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 100); gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), 100); gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), checkerboard_draw, NULL, NULL); gtk_container_add (GTK_CONTAINER (frame), da); /* * Create the scribble area */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Scribble area</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_widget_set_vexpand (frame, TRUE); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (vbox), frame); da = gtk_drawing_area_new (); gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 100); gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), 100); gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), scribble_draw, NULL, NULL); gtk_container_add (GTK_CONTAINER (frame), da); g_signal_connect (da, "size-allocate", G_CALLBACK (scribble_size_allocate), NULL); drag = gtk_gesture_drag_new (); gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (drag), GDK_BUTTON_PRIMARY); gtk_widget_add_controller (da, GTK_EVENT_CONTROLLER (drag)); g_signal_connect (drag, "drag-begin", G_CALLBACK (drag_begin), da); g_signal_connect (drag, "drag-update", G_CALLBACK (drag_update), da); g_signal_connect (drag, "drag-end", G_CALLBACK (drag_end), da); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
int main( int argc, char *argv[] ) { GtkWidget *vbox; gtk_init( &argc, &argv ); if( client_open( NULL ) ) exit( 1 ); atexit( client_close ); window = argc == 2 ? gtk_plug_new( strtol( argv[1], NULL, 10 )) : gtk_window_new( GTK_WINDOW_TOPLEVEL ); vbox = gtk_vbox_new( FALSE, 0 ); gtk_container_add( GTK_CONTAINER( window ), vbox ); drawing_area = gtk_drawing_area_new(); /* Get the dimensions and colors of the pager and viewport and focus */ parse_stdin(); update_rect.x = update_rect.y = 0; gtk_drawing_area_size( GTK_DRAWING_AREA( drawing_area ), width, height ); gtk_box_pack_start( GTK_BOX( vbox ), drawing_area, FALSE, FALSE, 0 ); /* Signals to quit */ g_signal_connect( GTK_OBJECT( window ), "delete_event", G_CALLBACK( delete_event ), NULL ); g_signal_connect( GTK_OBJECT( window ), "destroy", G_CALLBACK( destroy_event ), NULL ); /* Wait for input from standard input */ gdk_input_add( 0, GDK_INPUT_READ, &wait_stdin, drawing_area ); /* Change the viewport when a button is pressed */ g_signal_connect( GTK_OBJECT( drawing_area ), "motion_notify_event", (GCallback) motion_notify_event, NULL ); g_signal_connect( GTK_OBJECT( drawing_area ), "button_press_event", (GCallback) button_press_event, NULL ); g_signal_connect( GTK_OBJECT( drawing_area ), "button_release_event", (GCallback) button_release_event, NULL ); g_signal_connect( GTK_OBJECT( drawing_area ), "leave_notify_event", (GCallback) leave_notify_event, NULL ); g_signal_connect ( GTK_OBJECT( drawing_area), "scroll_event", (GCallback) scroll_event, NULL ); gtk_widget_set_events( drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK ); /* Initialize and draw the pixmap */ g_signal_connect( GTK_OBJECT( drawing_area ), "expose_event", (GCallback) expose_event, NULL ); g_signal_connect( GTK_OBJECT( drawing_area ), "configure_event", (GCallback) configure_event, NULL ); gtk_widget_show( drawing_area ); gtk_widget_show( vbox ); wmspec_change_state(TRUE, window->window, gdk_atom_intern( "_NET_WM_STATE_SKIP_PAGER", FALSE ), gdk_atom_intern( "_NET_WM_STATE_SKIP_TASKBAR", FALSE )); gtk_window_set_type_hint( GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DOCK); gtk_widget_show( window ); gtk_main(); return 0; }
void drawlines_init() { GtkWidget* vbox = gtk_vbox_new(FALSE, 0); //show gtk_table_attach_defaults(GTK_TABLE(table2[0]), vbox, 0,12,0,12); GtkWidget *cpu_frame = gtk_frame_new("cpu曲线:"); //show gtk_box_pack_start(GTK_BOX(vbox), cpu_frame, TRUE, TRUE, 10); // gtk_widget_show(CPU_frame1); cpu_draw_area = gtk_drawing_area_new(); gtk_widget_set_app_paintable(cpu_draw_area, TRUE); gtk_drawing_area_size(GTK_DRAWING_AREA(cpu_draw_area), 40, 40); gtk_container_add(GTK_CONTAINER(cpu_frame), cpu_draw_area); g_signal_connect(cpu_draw_area, "expose_event", G_CALLBACK(cpu_expose_event), NULL); g_signal_connect(cpu_draw_area, "configure_event", G_CALLBACK( cpu_configure_event), NULL); // gtk_widget_show(cpu_draw_area); int i; for (i = 0; i < 100; i++) { cpuPoints[i] = (rand() % 30 + 50); memPoints[i] = (rand() % 30 + 50); lackPoints[i] = (rand() % 30 + 50); } // gtk_timeout_add(100, (GtkFunction) drawGraph, NULL); */ GtkWidget* mem_frame = gtk_frame_new("mem曲线:"); gtk_box_pack_start(GTK_BOX(vbox), mem_frame, TRUE, TRUE, 10); mem_draw_area = gtk_drawing_area_new(); gtk_widget_set_app_paintable(mem_draw_area, TRUE); gtk_drawing_area_size(GTK_DRAWING_AREA(mem_draw_area), 40, 40); gtk_container_add(GTK_CONTAINER(mem_frame), mem_draw_area); g_signal_connect(mem_draw_area, "expose_event", G_CALLBACK(mem_expose_event), NULL); g_signal_connect(mem_draw_area, "configure_event", G_CALLBACK( mem_configure_event), NULL); GtkWidget* lack_frame = gtk_frame_new("缺页曲线:"); gtk_box_pack_start(GTK_BOX(vbox), lack_frame, TRUE, TRUE, 10); lack_draw_area = gtk_drawing_area_new(); gtk_widget_set_app_paintable(lack_draw_area, TRUE); gtk_drawing_area_size(GTK_DRAWING_AREA(lack_draw_area), 40, 40); gtk_container_add(GTK_CONTAINER(lack_frame), lack_draw_area); g_signal_connect(lack_draw_area, "expose_event", G_CALLBACK(lack_expose_event), NULL); g_signal_connect(lack_draw_area, "configure_event", G_CALLBACK( lack_configure_event), NULL); /*mem_draw_area = gtk_drawing_area_new(); gtk_widget_set_app_paintable(mem_draw_area, TRUE); gtk_drawing_area_size(GTK_DRAWING_AREA(cpu_draw_area), 40, 40); gtk_container_add(GTK_CONTAINER(memframe), mem_draw_area); g_signal_connect(mem_draw_area, "expose_event", G_CALLBACK(cpu_expose_event), NULL); g_signal_connect(mem_draw_area, "configure_event", G_CALLBACK( cpu_configure_event), NULL); */ }
int load_image(FILE *fp) { char pattern[] = "fnXXXXXX"; char *filename; FILE *ft; GError *error = NULL; //GdkGeometry geometry; /* * Extract image from skin by creating a temp file */ filename = mktemp(pattern); // use tmpfile instead of stdio.h ft = fopen(filename, "wb"); if(ft == NULL) { fprintf(stderr, "Unable to open this file: <%s>\n", filename); return -1; } while(!feof(fp)) { fputc(fgetc(fp), ft); } fclose(ft); /* * Destroy previous pixbuf */ if(pixbuf != NULL) { g_object_unref(pixbuf); pixbuf = NULL; } /* * Feed the original pixbuf with our image */ skin_infos.img_orig = gdk_pixbuf_new_from_file(filename, &error); if (skin_infos.img_orig == NULL) { fprintf(stderr, "Failed to load pixbuf file: %s: %s\n", filename, error->message); g_error_free(error); return -1; } /* * Set image and drawing area sizes */ skin_infos.width = gdk_pixbuf_get_width(skin_infos.img_orig); skin_infos.height = gdk_pixbuf_get_height(skin_infos.img_orig); gtk_drawing_area_size(GTK_DRAWING_AREA(drawingarea1), skin_infos.width, skin_infos.height); /* geometry.min_width = -1; geometry.min_height = -1; geometry.max_width = -1; //skin_infos.width; geometry.max_height = -1; //skin_infos.height; geometry.base_height = -1; geometry.base_width = -1; gtk_window_set_geometry_hints(GTK_WINDOW(main_wnd), GTK_WIDGET(drawingarea1), &geometry, GDK_HINT_MAX_SIZE); */ /* * Display image in the back-end pixbuf */ pixbuf = gdk_pixbuf_copy(skin_infos.img_orig); //gtk_widget_draw (GTK_DRAWING_AREA(drawingarea1), (GdkRectangle *)&update_rect); /* * Delete temp file */ unlink(filename); return 0; }
void create_display_shell(DDisplay *ddisp, int width, int height, char *title) { GtkWidget *table; GtkWidget *status_hbox; int s_width, s_height; s_width = gdk_screen_width (); s_height = gdk_screen_height (); if (width > s_width) width = s_width; if (height > s_height) width = s_width; /* The adjustment datums */ ddisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, 1, width-1)); ddisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, 1, height-1)); /* The toplevel shell */ ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (ddisp->shell), title); gtk_window_set_wmclass (GTK_WINDOW (ddisp->shell), "diagram_window", "Dia"); gtk_window_set_policy (GTK_WINDOW (ddisp->shell), TRUE, TRUE, TRUE); gtk_object_set_user_data (GTK_OBJECT (ddisp->shell), (gpointer) ddisp); gtk_widget_set_events (ddisp->shell, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_FOCUS_CHANGE_MASK); /* GDK_ALL_EVENTS_MASK */ gtk_signal_connect (GTK_OBJECT (ddisp->shell), "delete_event", GTK_SIGNAL_FUNC (ddisplay_delete), ddisp); gtk_signal_connect (GTK_OBJECT (ddisp->shell), "destroy", GTK_SIGNAL_FUNC (ddisplay_destroy), ddisp); /* the table containing all widgets */ table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2); gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_container_add (GTK_CONTAINER (ddisp->shell), table); /* scrollbars, rulers, canvas, menu popup button */ ddisp->origin = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT); ddisp->hrule = gtk_hruler_new (); gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event", (GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ddisp->hrule)->klass)->motion_notify_event, GTK_OBJECT (ddisp->hrule)); ddisp->vrule = gtk_vruler_new (); gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event", (GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ddisp->vrule)->klass)->motion_notify_event, GTK_OBJECT (ddisp->vrule)); ddisp->hsb = gtk_hscrollbar_new (ddisp->hsbdata); GTK_WIDGET_UNSET_FLAGS (ddisp->hsb, GTK_CAN_FOCUS); ddisp->vsb = gtk_vscrollbar_new (ddisp->vsbdata); GTK_WIDGET_UNSET_FLAGS (ddisp->vsb, GTK_CAN_FOCUS); /* set up the scrollbar observers */ gtk_signal_connect (GTK_OBJECT (ddisp->hsbdata), "value_changed", (GtkSignalFunc) ddisplay_hsb_update, ddisp); gtk_signal_connect (GTK_OBJECT (ddisp->vsbdata), "value_changed", (GtkSignalFunc) ddisplay_vsb_update, ddisp); ddisp->canvas = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (ddisp->canvas), width, height); gtk_widget_set_events (ddisp->canvas, CANVAS_EVENT_MASK); GTK_WIDGET_SET_FLAGS (ddisp->canvas, GTK_CAN_FOCUS); gtk_signal_connect (GTK_OBJECT (ddisp->canvas), "event", (GtkSignalFunc) ddisplay_canvas_events, ddisp); gtk_object_set_user_data (GTK_OBJECT (ddisp->canvas), (gpointer) ddisp); /* pack all the widgets */ gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->hrule, 1, 2, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->vrule, 0, 1, 1, 2, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->hsb, 0, 2, 2, 3, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->vsb, 2, 3, 0, 2, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); /* the popup menu */ #ifdef GNOME ddisp->popup = gnome_display_menus_create (); ddisp->accel_group = gnome_popup_menu_get_accel_group(GTK_MENU(ddisp->popup)); #else menus_get_image_menu (&ddisp->popup, &ddisp->accel_group); #endif /* the accelerator table/group for the popup */ gtk_window_add_accel_group (GTK_WINDOW(ddisp->shell), ddisp->accel_group); /* the statusbars */ status_hbox = gtk_hbox_new (FALSE, 2); ddisp->zoom_status = gtk_statusbar_new (); ddisp->modified_status = gtk_statusbar_new (); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->zoom_status, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status, TRUE, TRUE, 0); gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (ddisp->hsb); gtk_widget_show (ddisp->vsb); gtk_widget_show (ddisp->origin); gtk_widget_show (ddisp->hrule); gtk_widget_show (ddisp->vrule); gtk_widget_show (ddisp->canvas); gtk_widget_show (ddisp->zoom_status); gtk_widget_show (ddisp->modified_status); gtk_widget_show (status_hbox); gtk_widget_show (table); gtk_widget_show (ddisp->shell); /* set the focus to the canvas area */ gtk_widget_grab_focus (ddisp->canvas); }
int GCcreatewidget(Gwidget_t * parent, Gwidget_t * widget, int attrn, Gwattr_t * attrp) { PIXsize_t ps; int width, height; int ai, i; GdkGCValues gcv; int r, g, b, color; GdkColor *cp; if (!parent) { Gerr(POS, G_ERRNOPARENTWIDGET); return -1; } canvas = widget; WCU->func = NULL; WCU->needredraw = FALSE; WCU->buttonsdown = 0; WCU->bstate[0] = WCU->bstate[1] = WCU->bstate[2] = 0; ps.x = ps.y = MINCWSIZE; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRSIZE: GETSIZE(attrp[ai].u.s, ps, MINCWSIZE); break; case G_ATTRBORDERWIDTH: break; #ifdef FEATURE_GMAP case G_ATTRMODE: if (Strcmp("gmap", attrp[ai].u.t) == 0) { gmapmode = TRUE; } else { Gerr(POS, G_ERRBADATTRVALUE, attrp[ai].u.t); return -1; } break; #endif case G_ATTRCURSOR: break; case G_ATTRCOLOR: break; case G_ATTRVIEWPORT: break; case G_ATTRWINDOW: break; case G_ATTRWINDOWID: Gerr(POS, G_ERRCANNOTSETATTR2, "windowid"); return -1; case G_ATTREVENTCB: WCU->func = (Gcanvascb) attrp[ai].u.func; break; case G_ATTRUSERDATA: widget->udata = attrp[ai].u.u; break; default: Gerr(POS, G_ERRBADATTRID, attrp[ai].id); return -1; } } /* XtSetValues (widget->w, argp, argn); */ widget->w = gtk_drawing_area_new(); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(parent->w), widget->w); gtk_drawing_area_size(GTK_DRAWING_AREA(widget->w), ps.x, ps.y); gtk_widget_add_events(widget->w, GDK_ALL_EVENTS_MASK); gtk_signal_connect(GTK_OBJECT(widget->w), "key_release_event", GTK_SIGNAL_FUNC(Gcwkeyaction), NULL); gtk_signal_connect(GTK_OBJECT(widget->w), "key_press_event", GTK_SIGNAL_FUNC(Gcwkeyaction), NULL); gtk_signal_connect(G_OBJECT(widget->w), "button_press_event", GTK_SIGNAL_FUNC(Gcwbutaction), NULL); gtk_signal_connect(G_OBJECT(widget->w), "button_release_event", GTK_SIGNAL_FUNC(Gcwbutaction), NULL); gtk_signal_connect(G_OBJECT(widget->w), "visibility_notify_event", GTK_SIGNAL_FUNC(cweventhandler), NULL); gtk_signal_connect(G_OBJECT(widget->w), "expose_event", GTK_SIGNAL_FUNC(exposeeventhandler), NULL); gtk_signal_connect(G_OBJECT(widget->w), "motion_notify_event", GTK_SIGNAL_FUNC(cweventhandler), NULL); gtk_widget_show(widget->w); gtk_widget_show(parent->w); GC = gdk_gc_new(widget->w->window); WCU->cmap = gdk_colormap_get_system(); WCU->colors[0].color.pixel = WCU->colors[1].color.pixel = 1000000; if (WCU->colors[0].color.pixel == 1000000) { gdk_gc_get_values(GC, &gcv); WCU->colors[0].color = gcv.background; } if (WCU->colors[1].color.pixel == 1000000) { gdk_gc_get_values(GC, &gcv); WCU->colors[1].color = gcv.foreground; } WCU->colors[0].color.red = 65535; WCU->colors[0].color.green = 65535; WCU->colors[0].color.blue = 65535; WCU->colors[1].color.red = 0; WCU->colors[1].color.green = 0; WCU->colors[1].color.blue = 0; gdk_colormap_alloc_color(WCU->cmap, &WCU->colors[0].color, FALSE, TRUE); WCU->colors[0].inuse = TRUE; gdk_colormap_alloc_color(WCU->cmap, &WCU->colors[1].color, FALSE, TRUE); WCU->colors[1].inuse = TRUE; WCU->allocedcolor[0] = WCU->allocedcolor[1] = FALSE; for (i = 2; i < G_MAXCOLORS; i++) WCU->colors[i].inuse = FALSE; WCU->gattr.color = 1; /* gdk_gc_set_background(GC, widget->w->style->white_gc); gdk_gc_set_foreground(GC, widget->w->style->black_gc); */ WCU->gattr.width = 0; WCU->gattr.mode = 0; WCU->gattr.fill = 0; WCU->gattr.style = 0; WCU->defgattr = WCU->gattr; WCU->font = NULL; WCU->wrect.o.x = 0.0, WCU->wrect.o.y = 0.0; WCU->wrect.c.x = 1.0, WCU->wrect.c.y = 1.0; WCU->vsize.x = ps.x, WCU->vsize.y = ps.y; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRCURSOR: if (Strcmp(attrp[ai].u.t, "default") == 0) { curcursori = -1; } break; case G_ATTRCOLOR: color = attrp[ai].u.c.index; if (color < 0 || color > G_MAXCOLORS) { Gerr(POS, G_ERRBADCOLORINDEX, color); return -1; } r = attrp[ai].u.c.r * 257; g = attrp[ai].u.c.g * 257; b = attrp[ai].u.c.b * 257; cp = &WCU->colors[color].color; if (WCU->colors[color].inuse) if (cp->red != r || cp->green != g || cp->blue != b) if (color > 1 || WCU->allocedcolor[color]) gdk_colormap_free_colors(WCU->cmap, cp, 1); cp->red = r, cp->green = g, cp->blue = b; if (gdk_colormap_alloc_color(WCU->cmap, cp, TRUE, TRUE)) { WCU->colors[color].inuse = TRUE; if (color <= 1) WCU->allocedcolor[color] = TRUE; } cp->red = r, cp->green = g, cp->blue = b; if (color == WCU->gattr.color) WCU->gattr.color = -1; break; case G_ATTRVIEWPORT: WCU->vsize.x = (int) (attrp[ai].u.s.x + 0.5); WCU->vsize.y = (int) (attrp[ai].u.s.y + 0.5); break; case G_ATTRWINDOW: WCU->wrect = attrp[ai].u.r; break; } } adjustclip(widget); return 0; }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_colorzones_gui_data_t)); dt_iop_colorzones_gui_data_t *c = (dt_iop_colorzones_gui_data_t *)self->gui_data; dt_iop_colorzones_params_t *p = (dt_iop_colorzones_params_t *)self->params; // c->channel = DT_IOP_COLORZONES_C; c->channel = dt_conf_get_int("plugins/darkroom/colorzones/gui_channel"); int ch = (int)c->channel; c->minmax_curve = dt_draw_curve_new(0.0, 1.0, CATMULL_ROM); (void)dt_draw_curve_add_point(c->minmax_curve, p->equalizer_x[ch][DT_IOP_COLORZONES_BANDS-2]-1.0, p->equalizer_y[ch][DT_IOP_COLORZONES_BANDS-2]); for(int k=0; k<DT_IOP_COLORZONES_BANDS; k++) (void)dt_draw_curve_add_point(c->minmax_curve, p->equalizer_x[ch][k], p->equalizer_y[ch][k]); (void)dt_draw_curve_add_point(c->minmax_curve, p->equalizer_x[ch][1]+1.0, p->equalizer_y[ch][1]); c->mouse_x = c->mouse_y = c->mouse_pick = -1.0; c->dragging = 0; c->x_move = -1; c->mouse_radius = 1.0/DT_IOP_COLORZONES_BANDS; self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING)); // select by which dimension GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 5)); GtkWidget *label = gtk_label_new(_("select by")); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); c->select_by = gtk_combo_box_new_text(); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_combo_box_append_text(GTK_COMBO_BOX(c->select_by), _("hue")); gtk_combo_box_append_text(GTK_COMBO_BOX(c->select_by), _("saturation")); gtk_combo_box_append_text(GTK_COMBO_BOX(c->select_by), _("lightness")); gtk_box_pack_start(GTK_BOX(hbox), c->select_by, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (c->select_by), "changed", G_CALLBACK (select_by_changed), (gpointer)self); GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL); g_signal_connect(G_OBJECT(tb), "toggled", G_CALLBACK(request_pick_toggled), self); gtk_box_pack_start(GTK_BOX(hbox), tb, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 0); // tabs GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));//DT_GUI_IOP_MODULE_CONTROL_SPACING)); c->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new()); gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_("lightness"))); gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_("saturation"))); gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_("hue"))); gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(c->channel_tabs, c->channel))); gtk_notebook_set_current_page(GTK_NOTEBOOK(c->channel_tabs), c->channel); g_object_set(G_OBJECT(c->channel_tabs), "homogeneous", TRUE, (char *)NULL); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(c->channel_tabs), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(c->channel_tabs), "switch_page", G_CALLBACK (colorzones_tab_switch), self); // the nice graph c->area = GTK_DRAWING_AREA(gtk_drawing_area_new()); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(c->area), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(vbox), TRUE, TRUE, 5); gtk_drawing_area_size(c->area, 195, 195); gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK); g_signal_connect (G_OBJECT (c->area), "expose-event", G_CALLBACK (colorzones_expose), self); g_signal_connect (G_OBJECT (c->area), "button-press-event", G_CALLBACK (colorzones_button_press), self); g_signal_connect (G_OBJECT (c->area), "button-release-event", G_CALLBACK (colorzones_button_release), self); g_signal_connect (G_OBJECT (c->area), "motion-notify-event", G_CALLBACK (colorzones_motion_notify), self); g_signal_connect (G_OBJECT (c->area), "leave-notify-event", G_CALLBACK (colorzones_leave_notify), self); g_signal_connect (G_OBJECT (c->area), "enter-notify-event", G_CALLBACK (colorzones_enter_notify), self); g_signal_connect (G_OBJECT (c->area), "scroll-event", G_CALLBACK (colorzones_scrolled), self); c->hsRGB = dt_colorspaces_create_srgb_profile(); c->hLab = dt_colorspaces_create_lab_profile(); c->xform = cmsCreateTransform(c->hLab, TYPE_Lab_DBL, c->hsRGB, TYPE_RGB_DBL, INTENT_PERCEPTUAL, 0); }
void init_main_win( void ) { GtkAttachOptions xOpt, yOpt; gMapWin = gtk_window_new( GTK_WINDOW_TOPLEVEL ); if( gMapWin == NULL ){ print_msg( FLG_MSG_ERR, "gtk_window_new()" ); exit_game( EXIT_FAILURE ); } GtkWidget *vBox = gtk_vbox_new( FALSE, 0 ); gtk_container_add( GTK_CONTAINER( gMapWin ), vBox ); gtk_widget_show( vBox ); // メイン・ウィンドウへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapWin ), "delete_event", GTK_SIGNAL_FUNC( handle_delete ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapWin ), "destroy", GTK_SIGNAL_FUNC( handle_destroy ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapWin ), "key-press-event", GTK_SIGNAL_FUNC( handleKeyPress ), NULL ); // ツール・バーを作成 GtkWidget *handleBox = gtk_handle_box_new(); gtk_box_pack_start( GTK_BOX( vBox ), handleBox, FALSE, FALSE, 0 ); gtk_widget_show( handleBox ); GtkWidget *toolBar = gtk_toolbar_new(); gtk_toolbar_set_orientation( GTK_TOOLBAR( toolBar ), GTK_ORIENTATION_HORIZONTAL ); gtk_toolbar_set_style( GTK_TOOLBAR( toolBar ), GTK_TOOLBAR_ICONS ); gtk_widget_show( toolBar ); gtk_container_add( GTK_CONTAINER( handleBox ), toolBar ); // ツール・バーのボタンを作成 btnMapExec = gtk_button_new_with_label( MSG_GUI_MAP_EXEC ); gMapButtonContExec = gtk_button_new_with_label( MSG_GUI_MAP_CONT_EXEC_OFF ); #if FLAG_BTN_MAP_LABEL_IS_NAME btnMapAutoMark = gtk_button_new_with_label( MSG_GUI_MAP_AUTO_MARK ); btnMapUserMenu = gtk_button_new_with_label( MSG_GUI_MAP_USER_MENU ); btnMapSpell = gtk_button_new_with_label( MSG_GUI_MAP_SPELL ); btnMapSquare = gtk_button_new_with_label( MSG_GUI_MAP_SQUARE ); #else btnMapAutoMark = gtk_button_new_with_label( " / " ); btnMapUserMenu = gtk_button_new_with_label( " * " ); btnMapSpell = gtk_button_new_with_label( " - " ); btnMapSquare = gtk_button_new_with_label( " + " ); #endif btnMapCancel = gtk_button_new_with_label( MSG_GUI_MAP_CANCEL ); btnMapOk = gtk_button_new_with_label( MSG_GUI_MAP_OK ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapExec, MSG_GUI_MAP_TOOL_TIP_EXEC, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), gMapButtonContExec, MSG_GUI_MAP_TOOL_TIP_CONT_EXEC, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapAutoMark, MSG_GUI_MAP_TOOL_TIP_AUTO_MARK, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapUserMenu, MSG_GUI_MAP_TOOL_TIP_USER_MENU, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapSpell, MSG_GUI_MAP_TOOL_TIP_SPELL, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapSquare, MSG_GUI_MAP_TOOL_TIP_SQUARE, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapCancel, MSG_GUI_MAP_TOOL_TIP_CANCEL, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapOk, MSG_GUI_MAP_TOOL_TIP_OK, NULL ); gtk_widget_show( btnMapExec ); gtk_widget_show( gMapButtonContExec ); gtk_widget_show( btnMapAutoMark ); gtk_widget_show( btnMapUserMenu ); gtk_widget_show( btnMapSpell ); gtk_widget_show( btnMapSquare ); gtk_widget_show( btnMapCancel ); gtk_widget_show( btnMapOk ); // ツール・バーへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( btnMapExec ), "clicked", GTK_SIGNAL_FUNC( handle_exec_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapButtonContExec ), "clicked", GTK_SIGNAL_FUNC( handle_cont_exec_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapAutoMark ), "clicked", GTK_SIGNAL_FUNC( handle_auto_mark_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapUserMenu ), "clicked", GTK_SIGNAL_FUNC( handle_user_menu_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapSpell ), "clicked", GTK_SIGNAL_FUNC( handle_spell_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapSquare ), "clicked", GTK_SIGNAL_FUNC( handle_square_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapCancel ), "clicked", GTK_SIGNAL_FUNC( handle_cancel_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapOk ), "clicked", GTK_SIGNAL_FUNC( handle_ok_clicked ), NULL ); // 描画エリアを作成 GtkWidget *pTab = gtk_table_new( 2, 2, FALSE ); gtk_box_pack_start( GTK_BOX( vBox ), pTab, TRUE, TRUE, 0 ); gtk_widget_show( pTab ); gMapDrawingArea = gtk_drawing_area_new(); if( gMapDrawingArea == NULL ){ print_msg( FLG_MSG_ERR, "gtk_drawing_area_new()" ); exit_game( EXIT_FAILURE ); } gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ), MAP_WIN_INIT_WIDTH(), MAP_WIN_INIT_HEIGHT() ); xOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL); yOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapDrawingArea, 0, 1, 0, 1, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapDrawingArea ); // 描画エリアへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "expose_event", GTK_SIGNAL_FUNC( handle_map_expose ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "configure_event", GTK_SIGNAL_FUNC( handle_map_configure ), NULL ); // 描画エリアのマウス・モーションのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "motion_notify_event", GTK_SIGNAL_FUNC( handle_map_motion_notify ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "button_press_event", GTK_SIGNAL_FUNC( handle_map_button_press ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "button_release_event", GTK_SIGNAL_FUNC( handle_map_button_release ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "scroll_event", GTK_SIGNAL_FUNC( handle_map_scroll ), NULL ); gtk_widget_set_events( gMapDrawingArea, (GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK) ); // 水平スクロール・バーの調整を作成 gMapHScrollBarAdjustment = gtk_adjustment_new( 0, 0, MAP_PIX_MAX_X(), 1 * TILE_X_SIZE(), AREA_MAX_X * TILE_X_SIZE() / 2, AREA_MAX_X * TILE_X_SIZE() ); if( gMapHScrollBarAdjustment == NULL ){ print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" ); exit_game( EXIT_FAILURE ); } // 水平スクロール・バーの調整のイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ), "changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ), "value_changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); // 水平スクロール・バーを作成 gMapHScrollBar = gtk_hscrollbar_new( GTK_ADJUSTMENT( gMapHScrollBarAdjustment ) ); if( gMapHScrollBar == NULL ){ print_msg( FLG_MSG_ERR, "gtk_hscrollbar_new()" ); exit_game( EXIT_FAILURE ); } xOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL); yOpt = (GtkAttachOptions)(GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapHScrollBar, 0, 1, 1, 2, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapHScrollBar ); // 垂直スクロール・バーの調整を作成 gMapVScrollBarAdjustment = gtk_adjustment_new( 0, 0, MAP_PIX_MAX_Y(), 1 * TILE_Y_SIZE(), AREA_MAX_Y * TILE_Y_SIZE() / 2, AREA_MAX_Y * TILE_Y_SIZE() ); if( gMapVScrollBarAdjustment == NULL ){ print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" ); exit_game( EXIT_FAILURE ); } // 垂直スクロール・バーの調整のイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ), "changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ), "value_changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); // 垂直スクロール・バーを作成 gMapVScrollBar = gtk_vscrollbar_new( GTK_ADJUSTMENT( gMapVScrollBarAdjustment ) ); if( gMapVScrollBar == NULL ){ print_msg( FLG_MSG_ERR, "gtk_vscrollbar_new()" ); exit_game( EXIT_FAILURE ); } xOpt = (GtkAttachOptions)(GTK_FILL); yOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapVScrollBar, 1, 2, 0, 1, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapVScrollBar ); // ステータス・バーを作成 statBarMap = gtk_statusbar_new(); if( statBarMap == NULL ){ print_msg( FLG_MSG_ERR, "gtk_statusbar_new()" ); exit_game( EXIT_FAILURE ); } gtk_box_pack_start( GTK_BOX( vBox ), statBarMap, FALSE, FALSE, 0 ); statBarMapContextId = gtk_statusbar_get_context_id( GTK_STATUSBAR( statBarMap ), "Status bar" ); gtk_statusbar_set_has_resize_grip( GTK_STATUSBAR( statBarMap ), TRUE ); statBarMapMesId = gtk_statusbar_push( GTK_STATUSBAR( statBarMap ), statBarMapContextId, "OK" ); gtk_widget_show( statBarMap ); // メイン・ウィンドウを表示 gWinPos[WIN_KIND_MAP].draw( WIN_KIND_MAP ); gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ), MAP_WIN_MIN_WIDTH(), MAP_WIN_MIN_HEIGHT() ); }
int main(int argc, char *argv[]) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *menubar; GtkWidget *vbox; g_thread_init(NULL); gtk_init(&argc, &argv); gdk_init (&argc, &argv); gdk_rgb_init(); // buf= (unsigned char *)malloc (ROWS * COLS * DEPTH * sizeof (unsigned char)); //if (!buf) { // perror ("malloc buf"); // exit(0); // } open_dev(); /* abre e inicializa video */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), "WM destroy"); gtk_window_set_title(GTK_WINDOW(window), "NutoScope"); //gtk_widget_set_usize(GTK_WIDGET(window), COLS, ROWS); main_vbox = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_vbox), 1); gtk_container_add(GTK_CONTAINER(window), main_vbox); gtk_widget_show(main_vbox); get_main_menu(window, &menubar); gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0); gtk_widget_show(menubar); darea = gtk_drawing_area_new(); gtk_box_pack_start (GTK_BOX (main_vbox), darea, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (darea), "expose-event", GTK_SIGNAL_FUNC (on_darea_expose), (gpointer) darea); gtk_drawing_area_size (GTK_DRAWING_AREA (darea), COLS, ROWS); gtk_widget_show(darea); status = gtk_statusbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), status, FALSE, FALSE, 0); context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(status), "Ready"); gtk_widget_show (status); gtk_widget_show(window); // load 50x50x3 logo logo_image=malloc(50*50*3); if (!logo_image) { perror("malloc logo "); exit; } load_pnm("logo.pnm", logo_image); // Queue frames for(frame=0; frame<grab_vm.frames; frame++) { grab_buf.frame = frame; if(ioctl(grab_fd, VIDIOCMCAPTURE, &grab_buf)<0) { perror("VIDIOCMCAPTURE"); exit(-1); } } gtk_timeout_add(25, send_expose, NULL); gdk_threads_enter(); gtk_main(); gdk_threads_leave(); return (0); }
gboolean NewGLArea(GtkWidget* vboxwin) { GtkWidget* frame; /* gchar *info_str; */ GtkWidget* table; GtkWidget* hboxtoolbar; GtkWidget* vbox; #define DIMAL 13 int k = 0; GdkGLConfig *glconfig; k = 0; /* if(openGLOptions.alphaSize!=0) { attrlist[k++] = GDK_GL_ALPHA_SIZE; attrlist[k++] = 1; } if(openGLOptions.depthSize!=0) { attrlist[k++] = GDK_GL_DEPTH_SIZE; attrlist[k++] = 1; } if(openGLOptions.doubleBuffer!=0) attrlist[k++] = GDK_GL_DOUBLEBUFFER; */ set_show_symbols(FALSE); set_show_distances(FALSE); trackball(Quat , 0.0, 0.0, 0.0, 0.0); frame = gtk_frame_new (NULL); gtk_container_set_border_width (GTK_CONTAINER (frame), 0); gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT); gtk_box_pack_start (GTK_BOX (vboxwin), frame, TRUE, TRUE, 0); gtk_widget_show (frame); table = gtk_table_new(2,2,FALSE); gtk_container_add(GTK_CONTAINER(frame),table); gtk_widget_show(GTK_WIDGET(table)); /* hboxtoolbar = gtk_hbox_new (FALSE, 0); gtk_widget_show (hboxtoolbar); gtk_table_attach(GTK_TABLE(table), hboxtoolbar,0,1,0,1, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK ), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND ), 0,0); */ vbox = gtk_vbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), vbox, 0,1, 0,1, GTK_FILL , GTK_FILL, 0, 0); gtk_widget_show(vbox); add_menu_button(PrincipalWindow, vbox); hboxtoolbar = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hboxtoolbar, TRUE, TRUE, 0); gtk_widget_show(hboxtoolbar); gtk_quit_add_destroy(1, GTK_OBJECT(PrincipalWindow)); /* Create new OpenGL widget. */ /* pthread_mutex_init (&theRender_mutex, NULL);*/ GLArea = gtk_drawing_area_new (); gtk_drawing_area_size(GTK_DRAWING_AREA(GLArea),(gint)(ScreenHeight*0.2),(gint)(ScreenHeight*0.2)); gtk_table_attach(GTK_TABLE(table),GLArea,1,2,0,1, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND ), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND ), 0,0); gtk_widget_show(GTK_WIDGET(GLArea)); /* Events for widget must be set before X Window is created */ gtk_widget_set_events(GLArea, GDK_EXPOSURE_MASK| GDK_BUTTON_PRESS_MASK| GDK_BUTTON_RELEASE_MASK| GDK_POINTER_MOTION_MASK| GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK ); /* prepare GL */ glconfig = configure_gl(); if (!glconfig) { g_assert_not_reached (); } if (!gtk_widget_set_gl_capability (GLArea, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE)) { g_assert_not_reached (); } g_signal_connect(G_OBJECT(GLArea), "realize", G_CALLBACK(init), NULL); g_signal_connect(G_OBJECT(GLArea), "configure_event", G_CALLBACK(reshape), NULL); g_signal_connect(G_OBJECT(GLArea), "expose_event", G_CALLBACK(draw), NULL); /*gtk_widget_set_size_request(GTK_WIDGET(GLArea ),(gint)(ScreenHeight*0.2),(gint)(ScreenHeight*0.2));*/ gtk_widget_realize(GTK_WIDGET(PrincipalWindow)); /* info_str = gdk_gl_get_info(); Debug("%s\n",info_str); g_free(info_str); */ g_signal_connect (G_OBJECT(GLArea), "button_press_event", G_CALLBACK(glarea_button_press), NULL); g_signal_connect_after(G_OBJECT(GLArea), "button_press_event", G_CALLBACK(event_dispatcher), NULL); g_signal_connect_after(G_OBJECT(GLArea), "motion_notify_event", G_CALLBACK(glarea_motion_notify), NULL); g_signal_connect (G_OBJECT(GLArea), "button_release_event", G_CALLBACK(glarea_button_release), NULL); create_toolbar_and_popup_menu_GL(hboxtoolbar); g_signal_connect(G_OBJECT (PrincipalWindow), "key_press_event", (GCallback) set_key_press, GLArea); g_signal_connect(G_OBJECT (PrincipalWindow), "key_release_event", (GCallback) set_key_release, NULL); return TRUE; }
int main(int argc, char *argv[]) { gnome_init(VERSION, VERSION, argc, argv); /* Set up to draw from card class */ GtkWidget *vbox, *vbox1, *vbox2, *vbox3; GtkWidget *tbar; GtkWidget *setbutton, *nosetbutton; GdkColor white, black, blue; /* Done setting up */ window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Set Game"); gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, TRUE); gtk_container_border_width(GTK_CONTAINER(window), 0); vbox= gtk_vbox_new(FALSE, 0); vbox1 = gtk_vbox_new(FALSE, 0); vbox2 = gtk_vbox_new(FALSE, 0); vbox3 = gtk_vbox_new(FALSE, 0); drawing_area = gtk_drawing_area_new(); gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK); gtk_widget_set_events(window, GDK_KEY_PRESS_MASK); gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event", GTK_SIGNAL_FUNC(expose_event), 0); gtk_signal_connect(GTK_OBJECT(drawing_area), "button_press_event", GTK_SIGNAL_FUNC(button_event), 0); GnomeUIInfo toolbar[ ] = { GNOMEUIINFO_ITEM_STOCK ("New Game", "Start new Game", newgame, GNOME_STOCK_PIXMAP_NEW), GNOMEUIINFO_ITEM_STOCK ("High Scores", "Shows High scores", gtk_main_quit, GNOME_STOCK_PIXMAP_SCORES), GNOMEUIINFO_ITEM_STOCK ("End Game", "Ends Current Game", gtk_main_quit, GNOME_STOCK_PIXMAP_STOP), GNOMEUIINFO_ITEM_STOCK ("Exit", "Exit the application", gtk_main_quit, GNOME_STOCK_PIXMAP_EXIT), GNOMEUIINFO_END }; tbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS); gnome_app_fill_toolbar(GTK_TOOLBAR(tbar), toolbar, gtk_accel_group_new()); gtk_box_pack_start(GTK_BOX(vbox1), tbar, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vbox3, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox2), drawing_area, TRUE, TRUE, 5); gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area), SPACE_INTER+CARD_WS*4, SPACE_INTER+CARD_HS*3); gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Player"), TRUE, TRUE, 1); playerscore = gtk_label_new("0"); gtk_box_pack_start(GTK_BOX(vbox3), playerscore, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Computer"), TRUE, TRUE, 1); computerscore = gtk_label_new("0"); gtk_box_pack_start(GTK_BOX(vbox3), computerscore, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Cards Remaining"), TRUE, TRUE, 1); cards_remain = gtk_label_new("81"); gtk_box_pack_start(GTK_BOX(vbox3), cards_remain, TRUE, TRUE, 1); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show_all(window); gtk_idle_add( myidle, NULL); /************************ Start Deck Setup *************************/ unsigned char *pixmap_data[] = { bean_e_bits, bean_s_bits, bean_f_bits, blob_e_bits, blob_s_bits, blob_f_bits, diamond_e_bits, diamond_s_bits, diamond_f_bits }; int i, j; GdkWindow *wn = window->window; GdkColor col[4]; GdkColormap *cmap = gdk_window_get_colormap(wn); GdkGC *gc; GtkStyle *style = gtk_widget_get_style(window); col[0].red = 54000; col[0].green = col[0].blue = 0; col[1].green = 40000; col[1].red = col[1].blue = 0; col[2].red = col[2].blue = 32000; col[2].green = 0; gdk_color_white(cmap, &white); gdk_color_black(cmap, &black); blue.red = blue.green = 0; blue.blue = 48000; gdk_color_alloc(cmap, &blue); for (i=0; i<3; i++) gdk_color_alloc(cmap, &col[i]); for (i=0; i<9; i++) for (j=0; j<3; j++) card_pixmap[i*3+j] = gdk_pixmap_create_from_data(wn, (gchar*) pixmap_data[i], SHAPE_W, SHAPE_H, -1, &col[j], &white); /* free colors? !! */ gc = gdk_gc_new(wn); /*** cards in normal state ***/ card_bkg = gdk_pixmap_new(wn, CARD_WIDTH, CARD_HEIGHT, -1); /* clear the card */ gdk_gc_set_foreground(gc, &style->bg[GTK_STATE_NORMAL]); gdk_draw_rectangle(card_bkg, gc, 1, 0, 0, CARD_WIDTH, CARD_HEIGHT); /* draw corner arcs */ gdk_gc_set_foreground(gc, &white); gdk_draw_arc(card_bkg, gc, 1, 0, 0, 2*ARC_SIZE, 2*ARC_SIZE, 90*64, 90*64); gdk_draw_arc(card_bkg, gc, 1, CARD_WIDTH-2*ARC_SIZE, 0, 2*ARC_SIZE, 2*ARC_SIZE, 0, 90*64); gdk_draw_arc(card_bkg, gc, 1, 0, CARD_HEIGHT-2*ARC_SIZE, 2*ARC_SIZE, 2*ARC_SIZE, 180*64, 90*64); gdk_draw_arc(card_bkg, gc, 1, CARD_WIDTH-2*ARC_SIZE, CARD_HEIGHT-2*ARC_SIZE, 2*ARC_SIZE, 2*ARC_SIZE, 270*64, 90*64); /* draw the rest */ gdk_draw_rectangle(card_bkg, gc, 1, ARC_SIZE, 0, CARD_WIDTH-2*ARC_SIZE, CARD_HEIGHT); gdk_draw_rectangle(card_bkg, gc, 1, 0, ARC_SIZE, CARD_WIDTH, CARD_HEIGHT-2*ARC_SIZE); gdk_gc_destroy(gc); /************************ End Deck Setup *************************/ /* done setting up for once to draw wn = drawing_area->window; gc-gdk_gc_new(wn); card1.draw(); .............draw(); gdk_gc_destroy(); Card(int colr, int shp, int num, int shdng); */ mytable.Draw(); gtk_main(); return 0; }
void gui_init(dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t)); dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data; dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params; dt_pthread_mutex_init(&c->lock, NULL); dt_pthread_mutex_lock(&c->lock); c->auto_levels[0] = NAN; c->auto_levels[1] = NAN; c->auto_levels[2] = NAN; dt_pthread_mutex_unlock(&c->lock); c->modes = NULL; c->mouse_x = c->mouse_y = -1.0; c->dragging = 0; c->activeToggleButton = NULL; c->current_pick = NONE; c->last_picked_color = -1; for(int i = 0; i < 3; i++) for(int j = 0; j < 2; j++) c->pick_xy_positions[i][j] = -1; self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); c->mode = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(c->mode, NULL, _("mode")); dt_bauhaus_combobox_add(c->mode, C_("mode", "manual")); c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_MANUAL)); dt_bauhaus_combobox_add(c->mode, _("automatic")); c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_AUTOMATIC)); dt_bauhaus_combobox_set_default(c->mode, LEVELS_MODE_MANUAL); dt_bauhaus_combobox_set(c->mode, g_list_index(c->modes, GUINT_TO_POINTER(p->mode))); gtk_box_pack_start(GTK_BOX(self->widget), c->mode, TRUE, TRUE, 0); c->mode_stack = gtk_stack_new(); gtk_stack_set_homogeneous(GTK_STACK(c->mode_stack),FALSE); gtk_box_pack_start(GTK_BOX(self->widget), c->mode_stack, TRUE, TRUE, 0); c->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(9.0 / 16.0)); GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(c->area), TRUE, TRUE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(c->area),_("drag handles to set black, gray, and white points. " "operates on L channel.")); gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_SCROLL_MASK); g_signal_connect(G_OBJECT(c->area), "draw", G_CALLBACK(dt_iop_levels_area_draw), self); g_signal_connect(G_OBJECT(c->area), "button-press-event", G_CALLBACK(dt_iop_levels_button_press), self); g_signal_connect(G_OBJECT(c->area), "button-release-event", G_CALLBACK(dt_iop_levels_button_release), self); g_signal_connect(G_OBJECT(c->area), "motion-notify-event", G_CALLBACK(dt_iop_levels_motion_notify), self); g_signal_connect(G_OBJECT(c->area), "leave-notify-event", G_CALLBACK(dt_iop_levels_leave_notify), self); g_signal_connect(G_OBJECT(c->area), "scroll-event", G_CALLBACK(dt_iop_levels_scroll), self); GtkWidget *autobutton = gtk_button_new_with_label(_("auto")); gtk_widget_set_tooltip_text(autobutton, _("apply auto levels")); gtk_widget_set_size_request(autobutton, -1, DT_PIXEL_APPLY_DPI(24)); GtkWidget *blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); gtk_widget_set_tooltip_text(blackpick, _("pick black point from image")); GtkWidget *greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); gtk_widget_set_tooltip_text(greypick, _("pick medium gray point from image")); GtkWidget *whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); gtk_widget_set_tooltip_text(whitepick, _("pick white point from image")); GdkRGBA color = { 0 }; color.alpha = 1.0; dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(blackpick), &color); color.red = color.green = color.blue = 0.5; dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(greypick), &color); color.red = color.green = color.blue = 1.0; dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(whitepick), &color); GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10)); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(blackpick), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(greypick), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(whitepick), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_manual), box, TRUE, TRUE, 0); gtk_widget_show_all(vbox_manual); gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_manual, "manual"); c->percentile_black = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[0], 3); gtk_widget_set_tooltip_text(c->percentile_black, _("black percentile")); dt_bauhaus_slider_set_format(c->percentile_black, "%.1f%%"); dt_bauhaus_widget_set_label(c->percentile_black, NULL, _("black")); c->percentile_grey = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[1], 3); gtk_widget_set_tooltip_text(c->percentile_grey, _("gray percentile")); dt_bauhaus_slider_set_format(c->percentile_grey, "%.1f%%"); dt_bauhaus_widget_set_label(c->percentile_grey, NULL, _("gray")); c->percentile_white = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[2], 3); gtk_widget_set_tooltip_text(c->percentile_white, _("white percentile")); dt_bauhaus_slider_set_format(c->percentile_white, "%.1f%%"); dt_bauhaus_widget_set_label(c->percentile_white, NULL, _("white")); GtkWidget *vbox_automatic = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_black), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_grey), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_white), FALSE, FALSE, 0); gtk_widget_show_all(vbox_automatic); gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_automatic, "automatic"); switch(p->mode) { case LEVELS_MODE_AUTOMATIC: gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "automatic"); break; case LEVELS_MODE_MANUAL: default: gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "manual"); break; } g_signal_connect(G_OBJECT(c->mode), "value-changed", G_CALLBACK(dt_iop_levels_mode_callback), self); g_signal_connect(G_OBJECT(c->percentile_black), "value-changed", G_CALLBACK(dt_iop_levels_percentiles_callback), self); g_signal_connect(G_OBJECT(c->percentile_grey), "value-changed", G_CALLBACK(dt_iop_levels_percentiles_callback), self); g_signal_connect(G_OBJECT(c->percentile_white), "value-changed", G_CALLBACK(dt_iop_levels_percentiles_callback), self); g_signal_connect(G_OBJECT(autobutton), "clicked", G_CALLBACK(dt_iop_levels_autoadjust_callback), (gpointer)self); g_signal_connect(G_OBJECT(blackpick), "toggled", G_CALLBACK(dt_iop_levels_pick_black_callback), self); g_signal_connect(G_OBJECT(greypick), "toggled", G_CALLBACK(dt_iop_levels_pick_grey_callback), self); g_signal_connect(G_OBJECT(whitepick), "toggled", G_CALLBACK(dt_iop_levels_pick_white_callback), self); }
int display_init(GtkWindow *window) { /* Retrieve widgets */ display_window = window; display_label_mouse = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_mouse")); gtk_label_set_use_markup(display_label_mouse, TRUE); display_label_pixel = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_pixel")); display_label_selection = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_selection")); gtk_label_set_use_markup(display_label_selection, TRUE); /* Display refresh management */ display_refresh_init(window); /* Pattern display management */ display_pattern_init(); display_button_pattern = GTK_TOOL_BUTTON(lookup_widget(GTK_WIDGET(window), "button_pattern")); gtk_signal_connect_object(GTK_OBJECT(display_button_pattern), "clicked", GTK_SIGNAL_FUNC(display_pattern_popup), NULL); /* Screenshot grab management */ display_screenshot_init(window); /* Connect drawing area events */ display_darea = GTK_DRAWING_AREA(lookup_widget(GTK_WIDGET(window), "drawing_area")); display_darea_scroll = -1; gtk_signal_connect(GTK_OBJECT(display_darea), "expose_event", GTK_SIGNAL_FUNC(display_event_expose), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "enter_notify_event", GTK_SIGNAL_FUNC(display_event_crossing), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "leave_notify_event", GTK_SIGNAL_FUNC(display_event_crossing), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "motion_notify_event", GTK_SIGNAL_FUNC(display_event_motion), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "button_press_event", GTK_SIGNAL_FUNC(display_event_button), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "button_release_event", GTK_SIGNAL_FUNC(display_event_button), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "key_press_event", GTK_SIGNAL_FUNC(display_event_key), NULL); gtk_signal_connect(GTK_OBJECT(display_darea), "key_release_event", GTK_SIGNAL_FUNC(display_event_key), NULL); gtk_widget_set_events(GTK_WIDGET(display_darea), GDK_EXPOSURE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK); /* Record/playback management */ display_record_init(window); /* Setup selection box GC */ gtk_widget_realize(GTK_WIDGET(display_darea)); display_sel_init(display_darea); /* Init desktop selection */ display_desktop_init(window); /* Setup mouse/keyboard input management */ display_cursor_init(window, GTK_WIDGET(display_darea)); display_input_enabled = 0; display_input_focus = 0; display_button_input = GTK_TOGGLE_TOOL_BUTTON(lookup_widget(GTK_WIDGET(window), "button_input")); gtk_signal_connect_object(GTK_OBJECT(display_button_input), "clicked", GTK_SIGNAL_FUNC(display_input_clicked), NULL); gtk_toggle_tool_button_set_active(display_button_input, 0); gtk_widget_set_sensitive(GTK_WIDGET(display_button_input), 0); display_input_clicked(); /* Manual command entry */ display_command_init(window); return 0; }
static void blursk_init(void) { #if 0 if (blursk_window) return; #endif #ifdef DUMPCORE signal(SIGSEGV, SIG_DFL); #endif /* Get the configuration and create the image buffers */ //config_read(NULL, NULL); //preset_read(); config_default(&config); img_resize(config.width, config.height); #if 0 /* Create the window */ blursk_window = gtk_window_new(config.window_title ? GTK_WINDOW_TOPLEVEL : GTK_WINDOW_DIALOG); gtk_window_set_title(GTK_WINDOW(blursk_window), PACKAGE); gtk_window_set_policy(GTK_WINDOW(blursk_window), TRUE, TRUE, TRUE); gtk_signal_connect(GTK_OBJECT(blursk_window), "destroy", GTK_SIGNAL_FUNC(blursk_destroy_cb), NULL); gtk_signal_connect(GTK_OBJECT(blursk_window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &blursk_window); gtk_signal_connect(GTK_OBJECT(blursk_window), "configure_event", GTK_SIGNAL_FUNC(resize_cb), NULL); /* Put a drawing area in the window */ area = gtk_drawing_area_new(); gtk_drawing_area_size(GTK_DRAWING_AREA(area), img_physwidth, img_physheight); gtk_container_add(GTK_CONTAINER(blursk_window),area); gtk_widget_show(area); /* Arrange for key & mouse events to be detected */ gtk_signal_connect(GTK_OBJECT(blursk_window), "selection_received", GTK_SIGNAL_FUNC(selection_cb), NULL); gtk_signal_connect(GTK_OBJECT(blursk_window), "key_press_event", GTK_SIGNAL_FUNC(key_cb), NULL); gtk_signal_connect(GTK_OBJECT(blursk_window), "button_press_event", GTK_SIGNAL_FUNC(mousebutton_cb), NULL); gtk_signal_connect(GTK_OBJECT(blursk_window), "button_release_event", GTK_SIGNAL_FUNC(mousebutton_cb), NULL); gtk_signal_connect(GTK_OBJECT(blursk_window), "motion_notify_event", GTK_SIGNAL_FUNC(mousemove_cb), NULL); gtk_widget_set_events(blursk_window, GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK); /* Initialize the drawing area */ gtk_widget_realize(area); bg_pixmap = gdk_pixmap_create_from_xpm_d(area->window, NULL, NULL, blursk_xmms_logo_xpm); gdk_window_set_back_pixmap(area->window, bg_pixmap, 0); /* Move the window to its usual place, if any. If portions are beyond * the edge of the screen, then move it to make everything visible. */ if (config.x != -1 || config.y != -1) { if (config.x < 0) config.x = 0; else if (config.x + img_physwidth >= gdk_screen_width()) config.x = gdk_screen_width() - img_physwidth; if (config.y < 0) config.y = 0; else if (config.y + img_physheight >= gdk_screen_height()) config.y = gdk_screen_height() - img_physheight; gtk_widget_realize(blursk_window); gtk_window_reposition(GTK_WINDOW(blursk_window), config.x, config.y); } /* Show it! */ gtk_widget_show(blursk_window); /* Determine whether fullscreen operation is supported. */ can_fullscreen = xmms_fullscreen_init(blursk_window); #endif if( blursk_bitmap == NULL ) blursk_bitmap = new os::Bitmap( config.width, config.height, os::CS_RGB32 ); color_genmap(TRUE); }
int main( int argc, char *argv[] ) { GtkWidget *window; GtkWidget *vbox; char buf[G_ASCII_DTOSTR_BUF_SIZE]; GtkWidget *button; GtkWidget *entry; gtk_init (&argc, &argv); gdk_rgb_init(); pos_x[0] = 100; pos_y[0] = 100; pos_x[1] = 300; pos_y[1] = 300; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (window, "Test Input"); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (quit), NULL); /* Create the drawing area */ drawing_area = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 512, 512); gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show (drawing_area); /* Signals used to handle backing pixmap */ gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event", (GtkSignalFunc) expose_event, NULL); gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event", (GtkSignalFunc) configure_event, NULL); /* Event signals */ gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event", (GtkSignalFunc) motion_notify_event, NULL); gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event", (GtkSignalFunc) button_press_event, NULL); gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (entry), "activate", GTK_SIGNAL_FUNC (change_gradient), &a); gtk_entry_set_text (GTK_ENTRY (entry), g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, 1.0/a)); gtk_widget_show (entry); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (entry), "activate", GTK_SIGNAL_FUNC (change_gradient), &b); gtk_entry_set_text (GTK_ENTRY (entry), g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, 1.0/b)); gtk_widget_show (entry); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (entry), "activate", GTK_SIGNAL_FUNC (change_gradient), &c); gtk_entry_set_text (GTK_ENTRY (entry), g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, 1.0/c)); gtk_widget_show (entry); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (entry), "activate", GTK_SIGNAL_FUNC (change_spread), &spread); gtk_entry_set_text (GTK_ENTRY (entry), g_strdup_printf ("%d", spread)); gtk_widget_show (entry); /* .. And a quit button */ button = gtk_button_new_with_label ("Quit"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_widget_show (button); gtk_widget_show (window); gtk_main (); return 0; }
/*-----------------------------------------------------------------------------------*/ void ctk_gtksim_init(void) { GtkWidget *window; #if 0 GtkWidget *vbox; #endif window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(window, "Contiki GTKsim"); #if 0 vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); #endif gtk_signal_connect(GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (quit), NULL); /* Create the drawing area */ ctk_gtksim_drawing_area = gtk_drawing_area_new(); gtk_drawing_area_size(GTK_DRAWING_AREA (ctk_gtksim_drawing_area), CTK_GTKSIM_SCREEN_WIDTH, CTK_GTKSIM_SCREEN_HEIGHT); #if 0 gtk_box_pack_start(GTK_BOX(vbox), ctk_gtksim_drawing_area, TRUE, TRUE, 0); #else gtk_container_add(GTK_CONTAINER(window), ctk_gtksim_drawing_area); #endif gtk_widget_show(ctk_gtksim_drawing_area); /* Load a fixed width font. */ /* font = gdk_font_load("-*-gamow-medium-r-*-*-*-90-*-*-*-*-*-*");*/ /* font = gdk_font_load("-*-courier-*-r-normal-*-14-*-*-*-m-*-iso8859-1");*/ font = gdk_font_load("-*-courier-medium-r-*-*-12-*-*-*-*-*-iso8859-1"); if(font != NULL) { printf("Font loaded OK\n"); } else { printf("Font loading failed\n"); exit(1); } /* Signals used to handle backing pixmap */ gtk_signal_connect(GTK_OBJECT (ctk_gtksim_drawing_area), "expose_event", (GtkSignalFunc) expose_event, NULL); gtk_signal_connect(GTK_OBJECT (ctk_gtksim_drawing_area), "configure_event", (GtkSignalFunc) configure_event, NULL); /* Event signals */ gtk_signal_connect(GTK_OBJECT (window), "key_press_event", (GtkSignalFunc) key_press_event, NULL); gtk_signal_connect(GTK_OBJECT (window), "key_release_event", (GtkSignalFunc) key_release_event, NULL); gtk_signal_connect(GTK_OBJECT (ctk_gtksim_drawing_area), "motion_notify_event", (GtkSignalFunc) motion_notify_event, NULL); gtk_signal_connect(GTK_OBJECT (ctk_gtksim_drawing_area), "button_press_event", (GtkSignalFunc) button_press_event, NULL); gtk_signal_connect(GTK_OBJECT (ctk_gtksim_drawing_area), "button_release_event", (GtkSignalFunc) button_release_event, NULL); gtk_widget_set_events(ctk_gtksim_drawing_area, gtk_widget_get_events (ctk_gtksim_drawing_area) | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_widget_show(window); }
int main (int argc, char **argv) { GtkWidget *window, *table, *portplot_area_container, *countplot_area_container, *buttonbox; // Containers GtkWidget *portplot, *countplot, *zoom, *zoomlabel, *soundonoff, *soundlabel, *about, *quit; // Actual buttons gint x, y; guchar *pos; // Initialize variables packetcount = 0; sound_fd = -1; sound_onoff = FALSE; zoom_onoff = FALSE; //gnome_init("leak", VERSION, argc, argv); gtk_init(&argc, &argv); gdk_rgb_init(); // Initialize the window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), "The leak"); gtk_signal_connect(GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC(delete_event_close), NULL); // Set up containers table = gtk_table_new(4, 1, FALSE); gtk_container_add(GTK_CONTAINER (window), table); buttonbox = gtk_vbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE (table), buttonbox, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0); // Set up drawing areas countplot_area_container = gtk_event_box_new(); countplot = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER (countplot_area_container), countplot); gtk_container_set_border_width(GTK_CONTAINER (countplot_area_container), 2); gtk_drawing_area_size(GTK_DRAWING_AREA (countplot), PORT_WIDTH, PORT_HEIGHT); gtk_signal_connect(GTK_OBJECT (countplot), "expose-event", GTK_SIGNAL_FUNC (on_countplot_expose), NULL); gtk_table_attach(GTK_TABLE (table), countplot_area_container, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); portplot_area_container = gtk_event_box_new(); portplot = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER (portplot_area_container), portplot); gtk_container_set_border_width(GTK_CONTAINER (portplot_area_container), 2); gtk_drawing_area_size(GTK_DRAWING_AREA (portplot), PORT_WIDTH, PORT_HEIGHT); gtk_signal_connect(GTK_OBJECT (portplot), "expose-event", GTK_SIGNAL_FUNC (on_portplot_expose), NULL); gtk_signal_connect(GTK_OBJECT (portplot_area_container), "button_press_event", GTK_SIGNAL_FUNC (grap_location), NULL); gtk_table_attach(GTK_TABLE (table), portplot_area_container, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); // Zoom button zoomlabel = gtk_label_new("Zoom In"); zoom = gtk_button_new(); gtk_container_add(GTK_CONTAINER (zoom), zoomlabel); gtk_box_pack_start(GTK_BOX (buttonbox), zoom, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER (zoom), 0); gtk_signal_connect(GTK_OBJECT (zoom), "clicked", GTK_SIGNAL_FUNC(change_zoom_state), zoomlabel); // Sound button soundlabel = gtk_label_new("Activate\nAudio"); soundonoff = gtk_button_new(); gtk_container_add(GTK_CONTAINER (soundonoff), soundlabel); gtk_container_set_border_width(GTK_CONTAINER (soundonoff), 0); gtk_box_pack_start(GTK_BOX (buttonbox), soundonoff, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (soundonoff), "clicked", GTK_SIGNAL_FUNC(change_sound_state), soundlabel); // About button // Commented out for lack of Gnome support /* about = gtk_button_new_with_label("About..."); gtk_container_set_border_width(GTK_CONTAINER (about), 0); gtk_box_pack_start(GTK_BOX (buttonbox), about, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (about), "clicked", GTK_SIGNAL_FUNC(display_about), NULL); */ // Quit button quit = gtk_button_new_with_label("Quit"); gtk_container_set_border_width(GTK_CONTAINER (quit), 0); gtk_box_pack_start(GTK_BOX (buttonbox), quit, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (quit), "clicked", GTK_SIGNAL_FUNC(delete_event_close), NULL); // Scroll bar scroll_params = gtk_adjustment_new(1.0, 1, 1, 0, 0, 0); zoomscroll = gtk_vscrollbar_new(GTK_ADJUSTMENT (scroll_params)); gtk_table_attach(GTK_TABLE (table), zoomscroll, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_range_set_update_policy(GTK_RANGE (zoomscroll), GTK_UPDATE_DISCONTINUOUS); gtk_signal_connect(GTK_OBJECT (scroll_params), "value_changed", GTK_SIGNAL_FUNC(change_scroll_value), portplot); gtk_widget_show_all (window); // The speed issues is due to the parameters passed // to open_live. We have to optimize pcap_d = pcap_open_live("eth0",100,0,75,ebuf); gtk_idle_add((GtkFunction)packet_received,portplot); gtk_timeout_add(200,(GtkFunction)decay_portplot,portplot); gtk_timeout_add(3000, (GtkFunction)decay_countplot, countplot); gtk_main(); return 0; }
GtkWidget *setupLCD(GtkWidget *parent, int rows, int cols, char *font){ int i; int width; int wid, hgt; #ifdef GTK_VER_1_1 static GtkTargetEntry targetlist[] = { /* Target Flags Info */ { "STRING", 0, TARGET_STRING }, { "TEXT", 0, TARGET_TEXT }, { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT } }; static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]); #endif /* store arguments */ lcdWidth = cols; lcdHeight = rows; #ifdef USE_PANGO lcdDA = gtk_drawing_area_new(); pango_layout = gtk_widget_create_pango_layout(lcdDA, NULL); pango_desc = pango_font_description_from_string(font?font:"Liberation Mono 16"); pango_fontmap = pango_cairo_font_map_get_default(); pango_context = pango_cairo_font_map_create_context( (PangoCairoFontMap *)pango_fontmap ); pango_font = pango_context_load_font(pango_context, pango_desc); pango_metrics = pango_context_get_metrics(pango_context, pango_desc, pango_language_get_default()); fontW = (pango_font_metrics_get_approximate_digit_width(pango_metrics))/PANGO_SCALE; fontH = (pango_font_metrics_get_ascent(pango_metrics) + pango_font_metrics_get_descent(pango_metrics))/PANGO_SCALE; fontD = pango_font_metrics_get_descent(pango_metrics)/PANGO_SCALE; gtk_widget_modify_font(lcdDA, pango_desc); #else fontW = 0; fontH = 0; fontD = 0; /* get a font for the main window */ if(font != NULL){ if(NULL == (lcdFont = gdk_font_load(font))){ fprintf(stderr, "Unable to load font %s.\n", font); exit(0); } } else if(NULL == (lcdFont = gdk_font_load(FONT1)) && NULL == (lcdFont = gdk_font_load(FONT2)) && NULL == (lcdFont = gdk_font_load(FONT3)) && NULL == (lcdFont = gdk_font_load(FONT4)) && NULL == (lcdFont = gdk_font_load(FONT5)) && NULL == (lcdFont = gdk_font_load(FONT6))){ fprintf(stderr, "Unable to load a font.\n"); exit(0); } /* find max font width */ for(i=0; i<256; i++){ width = gdk_char_width(lcdFont, (gchar)i); if(width < 50 && width > fontW) fontW = width; } /* globals we use all over the place */ fontH = lcdFont->ascent + lcdFont->descent; fontD = lcdFont->descent; #endif if(fontW == 0 || fontH == 0){ fprintf(stderr, "Error: can not determine font dimentions.\n"); exit(0); } wid = (2 * BORDER) + (lcdWidth * fontW); hgt = (2 * BORDER) + (lcdHeight * fontH); #ifndef USE_PANGO lcdDA = gtk_drawing_area_new(); #endif gtk_drawing_area_size(GTK_DRAWING_AREA(lcdDA), wid, hgt); gtk_box_pack_start(GTK_BOX(parent), lcdDA, TRUE, TRUE, 0); /* Signals used to handle window ops */ gtk_signal_connect(GTK_OBJECT(lcdDA), "expose_event", (GtkSignalFunc)lcdExposeCB, NULL); gtk_signal_connect(GTK_OBJECT(lcdDA),"configure_event", (GtkSignalFunc)lcdResizeCB, NULL); /* Event signals (Selection) */ gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_received", (GtkSignalFunc)lcdPasteCB, NULL); gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_clear_event", (GtkSignalFunc)loseSelection, NULL); /* gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_request_event", (GtkSignalFunc)convertSelection, NULL); */ #ifdef GTK_VER_1_1 gtk_selection_add_targets(lcdDA, GDK_SELECTION_PRIMARY, targetlist, ntargets); gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_get", (GtkSignalFunc)convertSelection, NULL); #else gtk_selection_add_handler(lcdDA, GDK_SELECTION_PRIMARY, GDK_SELECTION_TYPE_STRING, convertSelection, NULL); #endif /* Event signals (Input) */ gtk_signal_connect(GTK_OBJECT(lcdDA), "motion_notify_event", (GtkSignalFunc)lcdMotionEvnt, NULL); gtk_signal_connect(GTK_OBJECT(lcdDA), "button_press_event", (GtkSignalFunc)lcdButtonPressEvnt, NULL); gtk_signal_connect(GTK_OBJECT(lcdDA), "button_release_event", (GtkSignalFunc)lcdButtonReleaseEvnt, NULL); gtk_signal_connect_after(GTK_OBJECT(lcdDA), "key_press_event", (GtkSignalFunc)lcdKeyPressEvnt, NULL); gtk_signal_connect_after(GTK_OBJECT(lcdDA), "key_release_event", (GtkSignalFunc)lcdKeyReleaseEvnt, NULL); gtk_widget_set_events(lcdDA, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); GTK_WIDGET_SET_FLAGS(lcdDA, GTK_CAN_FOCUS); gtk_widget_show(lcdDA); gtk_widget_grab_focus(lcdDA); return lcdDA; }
int GCsetwidgetattr(Gwidget_t * widget, int attrn, Gwattr_t * attrp) { PIXsize_t ps; int ai, r, g, b, color; GdkColor *cp; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRSIZE: GETSIZE(attrp[ai].u.s, ps, MINCWSIZE); gtk_drawing_area_size(GTK_DRAWING_AREA(widget->w), ps.x, ps.y); break; case G_ATTRBORDERWIDTH: break; case G_ATTRCURSOR: if (Strcmp(attrp[ai].u.t, "watch") == 0) { gdk_window_set_cursor(widget->w->window, gdk_cursor_new(GDK_WATCH)); } else { gdk_window_set_cursor(widget->w->window, gdk_cursor_new(GDK_LEFT_PTR)); } Gsync(); break; case G_ATTRCOLOR: color = attrp[ai].u.c.index; if (color < 0 || color > G_MAXCOLORS) { Gerr(POS, G_ERRBADCOLORINDEX, color); return -1; } r = attrp[ai].u.c.r * 257; g = attrp[ai].u.c.g * 257; b = attrp[ai].u.c.b * 257; cp = &WCU->colors[color].color; if (WCU->colors[color].inuse) if (cp->red != r || cp->green != g || cp->blue != b) if (color > 1 || WCU->allocedcolor[color]) gdk_colormap_free_colors(WCU->cmap, cp, 1); cp->red = r, cp->green = g, cp->blue = b; if (gdk_colormap_alloc_color(WCU->cmap, cp, TRUE, TRUE)) { WCU->colors[color].inuse = TRUE; if (color <= 1) WCU->allocedcolor[color] = TRUE; } cp->red = r, cp->green = g, cp->blue = b; if (color == WCU->gattr.color) WCU->gattr.color = -1; break; case G_ATTRVIEWPORT: WCU->vsize.x = (int) (attrp[ai].u.s.x + 0.5); WCU->vsize.y = (int) (attrp[ai].u.s.y + 0.5); break; case G_ATTRWINDOW: WCU->wrect = attrp[ai].u.r; adjustclip(widget); break; case G_ATTRWINDOWID: Gerr(POS, G_ERRCANNOTSETATTR2, "windowid"); return -1; case G_ATTREVENTCB: WCU->func = (Gcanvascb) attrp[ai].u.func; break; case G_ATTRUSERDATA: widget->udata = attrp[ai].u.u; break; default: Gerr(POS, G_ERRBADATTRID, attrp[ai].id); return -1; } } return 0; }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_tonecurve_gui_data_t)); dt_iop_tonecurve_gui_data_t *c = (dt_iop_tonecurve_gui_data_t *)self->gui_data; dt_iop_tonecurve_params_t *p = (dt_iop_tonecurve_params_t *)self->params; for (int ch=0; ch<ch_max; ch++) { c->minmax_curve[ch] = dt_draw_curve_new(0.0, 1.0, p->tonecurve_type[ch]); c->minmax_curve_nodes[ch] = p->tonecurve_nodes[ch]; c->minmax_curve_type[ch] = p->tonecurve_type[ch]; for(int k=0; k<p->tonecurve_nodes[ch]; k++) (void)dt_draw_curve_add_point(c->minmax_curve[ch], p->tonecurve[ch][k].x, p->tonecurve[ch][k].y); } c->channel = ch_L; c->mouse_x = c->mouse_y = -1.0; c->selected = -1; self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE); // tabs c->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new()); gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_(" L "))); g_object_set(G_OBJECT(gtk_notebook_get_tab_label(c->channel_tabs, gtk_notebook_get_nth_page(c->channel_tabs, -1))), "tooltip-text", _("tonecurve for L channel"), NULL); gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_(" a "))); g_object_set(G_OBJECT(gtk_notebook_get_tab_label(c->channel_tabs, gtk_notebook_get_nth_page(c->channel_tabs, -1))), "tooltip-text", _("tonecurve for a channel"), NULL); gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_(" b "))); g_object_set(G_OBJECT(gtk_notebook_get_tab_label(c->channel_tabs, gtk_notebook_get_nth_page(c->channel_tabs, -1))), "tooltip-text", _("tonecurve for b channel"), NULL); gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(c->channel_tabs, c->channel))); gtk_notebook_set_current_page(GTK_NOTEBOOK(c->channel_tabs), c->channel); g_object_set(G_OBJECT(c->channel_tabs), "homogeneous", TRUE, (char *)NULL); GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL); GtkWidget *notebook = gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(notebook), GTK_WIDGET(c->channel_tabs), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(notebook), GTK_WIDGET(tb), FALSE, FALSE, 0); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), vbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(notebook), TRUE, TRUE, 0); g_signal_connect(G_OBJECT(c->channel_tabs), "switch_page", G_CALLBACK (tab_switch), self); c->area = GTK_DRAWING_AREA(gtk_drawing_area_new()); //GtkWidget *asp = gtk_aspect_frame_new(NULL, 0.5, 0.5, 1.0, FALSE);//TRUE); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(c->area), TRUE, TRUE, 0); // gtk_box_pack_start(GTK_BOX(vbox), asp, TRUE, TRUE, 0); // gtk_container_add(GTK_CONTAINER(asp), GTK_WIDGET(c->area)); gtk_drawing_area_size(c->area, 0, 258); g_object_set (GTK_OBJECT(c->area), "tooltip-text", _("double click to reset curve"), (char *)NULL); gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK); g_signal_connect (G_OBJECT (c->area), "expose-event", G_CALLBACK (dt_iop_tonecurve_expose), self); g_signal_connect (G_OBJECT (c->area), "button-press-event", G_CALLBACK (dt_iop_tonecurve_button_press), self); g_signal_connect (G_OBJECT (c->area), "motion-notify-event", G_CALLBACK (dt_iop_tonecurve_motion_notify), self); g_signal_connect (G_OBJECT (c->area), "leave-notify-event", G_CALLBACK (dt_iop_tonecurve_leave_notify), self); g_signal_connect (G_OBJECT (c->area), "enter-notify-event", G_CALLBACK (dt_iop_tonecurve_enter_notify), self); g_signal_connect (G_OBJECT (c->area), "configure-event", G_CALLBACK (area_resized), self); g_signal_connect (G_OBJECT(tb), "toggled", G_CALLBACK (pick_toggled), self); g_signal_connect (G_OBJECT (c->area), "scroll-event", G_CALLBACK (scrolled), self); c->autoscale_ab = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(c->autoscale_ab, _("scale chroma")); dt_bauhaus_combobox_add(c->autoscale_ab, _("auto")); dt_bauhaus_combobox_add(c->autoscale_ab, _("manual")); gtk_box_pack_start(GTK_BOX(self->widget), c->autoscale_ab, TRUE, TRUE, 0); g_object_set (GTK_OBJECT(c->autoscale_ab), "tooltip-text", _("if set to auto, a and b curves have no effect and are not displayed. chroma values (a and b) of each pixel are then adjusted based on L curve data."), (char *)NULL); g_signal_connect(G_OBJECT(c->autoscale_ab), "value-changed", G_CALLBACK(autoscale_ab_callback), self); c->sizegroup = GTK_SIZE_GROUP(gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL)); gtk_size_group_add_widget(c->sizegroup, GTK_WIDGET(c->area)); gtk_size_group_add_widget(c->sizegroup, GTK_WIDGET(c->channel_tabs)); }
//called on the drawingArea's expose event gboolean drawingAreaExpose(GtkWidget *widgetDrawingArea, GdkEventExpose *event, gpointer data) { passToDrawingAreaExpose* passed = (passToDrawingAreaExpose*) data; bool* draw = passed->draw; if (*draw) { OwnRobot* ownRobotDraw = passed->ownRobotDraw; int myTeam = passed->myTeam; int numberOfRobots = passed->numberOfRobots; int *drawFactor = passed->drawFactor; int imageWidth = (VIEWDISTANCE+ROBOTDIAMETER) * (*drawFactor) * 2; int imageHeight = (VIEWDISTANCE+ROBOTDIAMETER) * (*drawFactor) * 2; //origin is the middle point where our viewed robot is located int origin[] = { imageWidth / 2, imageHeight / 2 }; cairo_t *cr = gdk_cairo_create(GTK_DRAWING_AREA(widgetDrawingArea)->widget.window); cairo_set_line_width(cr, 2); ColorObject color = colorFromTeam(myTeam); //draw our home if it is nearby (FIRST so it goes underneath) if (ownRobotDraw->homeRelX - ((HOMEDIAMETER / 2) + (ROBOTDIAMETER / 2)) < VIEWDISTANCE && ownRobotDraw->homeRelY - ((HOMEDIAMETER / 2) + (ROBOTDIAMETER / 2)) < VIEWDISTANCE) { cairo_set_source_rgb(cr, 0, 0, 0); cairo_arc(cr, origin[0] + ownRobotDraw->homeRelX * *drawFactor, origin[1] + ownRobotDraw->homeRelY * *drawFactor, HOMEDIAMETER * *drawFactor / 2, 0, 2 * M_PI); cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, color.r, color.g, color.b); cairo_fill(cr); } for (unsigned int i = 0; i < ownRobotDraw->seenRobots.size(); i++) { //robot Ids start at 1, team Ids start at 0. Must remember this. THIS is where the damn //blue robot and off coloring has been coming from. color = colorFromTeam(((ownRobotDraw->seenRobots.at(i)->id)-1) / numberOfRobots); cairo_set_source_rgb(cr, 0, 0, 0); cairo_arc(cr, origin[0] + ownRobotDraw->seenRobots.at(i)->relx * *drawFactor, origin[1] + ownRobotDraw->seenRobots.at(i)->rely * *drawFactor, ROBOTDIAMETER * *drawFactor / 2, 0, 2 * M_PI); cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, color.r, color.g, color.b); cairo_fill(cr); } //draw seen pucks cairo_set_source_rgb(cr, 0, 0, 0); for (unsigned int i = 0; i < ownRobotDraw->seenPucks.size(); i++) { cairo_arc(cr, origin[0] + ownRobotDraw->seenPucks.at(i)->relx * *drawFactor, origin[1] + ownRobotDraw->seenPucks.at(i)->rely * *drawFactor, PUCKDIAMETER * *drawFactor / 2, 0, 2 * M_PI); cairo_fill(cr); } //draw the currently viewed robot color = colorFromTeam(myTeam); cairo_set_source_rgb(cr, 0, 0, 0); cairo_arc(cr, origin[0], origin[1], ROBOTDIAMETER * *drawFactor / 2, 0, 2 * M_PI); cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, color.r, color.g, color.b); cairo_fill(cr); //ownRobot->angle does not provide a valid angle ( it's always zero )! //draw the line showing the angle that the robot is moving at if( !(ownRobotDraw->vx == 0 && ownRobotDraw->vy == 0 )) { int endX=origin[0] + ownRobotDraw->vx * *drawFactor * 4, endY=origin[1] + ownRobotDraw->vy * *drawFactor * 4; double x1, y1, x2, y2; calcVertexes(origin[0], origin[1], endX, endY, *drawFactor, x1, y1, x2, y2); cairo_set_source_rgba(cr, 0, 0, 0, 0.6); cairo_move_to(cr, origin[0], origin[1]); cairo_line_to(cr, endX, endY); cairo_line_to(cr, x1, y1); cairo_move_to(cr, x2, y2); cairo_line_to(cr, endX, endY); cairo_stroke(cr); } //if the robot has a puck then actually draw the puck in its center if (ownRobotDraw->hasPuck) { cairo_set_source_rgb(cr, 0, 0, 0); cairo_arc(cr, origin[0], origin[1], PUCKDIAMETER * *drawFactor, 0, 2 * M_PI); cairo_stroke(cr); } //draw the viewing area - cairo angles are stupid //bonus: not moving? 360 degree view cairo_set_source_rgba(cr, 0, 0, 0, 0.75); if(ownRobotDraw->vx == 0 && ownRobotDraw->vy == 0) { //draw the circle cairo_arc(cr, origin[0], origin[1], imageWidth/2, 0, 2 * M_PI); }else{ //draw the cone cairo_move_to(cr, origin[0], origin[1]); cairo_arc_negative(cr, origin[0], origin[1], imageWidth/2, (VIEWANGLE / 2.0) - ownRobotDraw->angle, (2 * M_PI) - (VIEWANGLE/2.0) - ownRobotDraw->angle); cairo_line_to(cr, origin[0], origin[1]); } cairo_stroke(cr); cairo_destroy(cr); *draw = false; if (gtk_toggle_tool_button_get_active(passed->info)) updateInfoWindow(ownRobotDraw, passed->builder); } return FALSE; }