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