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); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *drawing_area; GtkWidget *vbox; GtkWidget *button; gtk_init (&argc, &argv); current_device = gdk_device_get_core_pointer (); 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); g_signal_connect (window, "destroy", G_CALLBACK (quit), NULL); /* Create the drawing area */ drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (drawing_area, 200, 200); gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show (drawing_area); /* Signals used to handle backing pixmap */ g_signal_connect (drawing_area, "expose_event", G_CALLBACK (expose_event), NULL); g_signal_connect (drawing_area, "configure_event", G_CALLBACK (configure_event), NULL); /* Event signals */ g_signal_connect (drawing_area, "motion_notify_event", G_CALLBACK (motion_notify_event), NULL); g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press_event), NULL); g_signal_connect (drawing_area, "key_press_event", G_CALLBACK (key_press_event), NULL); g_signal_connect (drawing_area, "leave_notify_event", G_CALLBACK (leave_notify_event), NULL); g_signal_connect (drawing_area, "proximity_out_event", G_CALLBACK (proximity_out_event), NULL); gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_PROXIMITY_OUT_MASK); /* The following call enables tracking and processing of extension events for the drawing area */ gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_ALL); gtk_widget_set_can_focus (drawing_area, TRUE); gtk_widget_grab_focus (drawing_area); /* .. And create some buttons */ button = gtk_button_new_with_label ("Input Dialog"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (create_input_dialog), NULL); gtk_widget_show (button); button = gtk_button_new_with_label ("Quit"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window); gtk_widget_show (button); gtk_widget_show (window); gtk_main (); return 0; }
int main( int argc,char *argv[] ) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget* menubar; GtkWidget* main_toolbar; GtkWidget* tools_toolbar; GtkWidget* colortable; GtkWidget* frame; gtk_init (&argc, &argv); modified=0; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(window), "Illuminati"); g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (delete_event), NULL); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (delete_event), NULL); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); /*To create the menu bar*/ menubar = get_menubar_menu (window); gtk_box_pack_start (GTK_BOX(vbox),menubar, FALSE, FALSE, 0); gtk_widget_show (menubar); main_toolbar=get_main_toolbar(); /* to make it nice we'll put the toolbar into the handle box, * so that it can be detached from the main window */ mainhandlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (vbox),mainhandlebox, FALSE, FALSE, 5); gtk_container_add (GTK_CONTAINER (mainhandlebox), main_toolbar); gtk_widget_show (main_toolbar); gtk_widget_show (mainhandlebox); /*hbox for tools_toolbar and drawing area*/ hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (vbox),hbox, FALSE, FALSE, 0); tools_toolbar=get_tools_toolbar(); toolhandlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX(hbox),toolhandlebox, FALSE, FALSE, 5); gtk_container_add (GTK_CONTAINER (toolhandlebox), tools_toolbar); gtk_widget_show (tools_toolbar); gtk_widget_show (toolhandlebox); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (GTK_WIDGET (scrolled_win),400,400); gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 1); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), scrolled_win, TRUE, TRUE, 0); drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (GTK_WIDGET (drawing_area),800,600); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),drawing_area); gtk_widget_show (drawing_area); gtk_widget_show (scrolled_win); gtk_widget_show (hbox); /* Signals used to handle backing pixmap */ g_signal_connect (G_OBJECT (drawing_area), "expose_event", G_CALLBACK (expose_event), NULL); g_signal_connect (G_OBJECT (drawing_area),"configure_event", G_CALLBACK (configure_event), NULL); /* Event signals */ g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event", G_CALLBACK (motion_notify_event), NULL); g_signal_connect (G_OBJECT (drawing_area), "button_press_event", G_CALLBACK (button_press_event), NULL); g_signal_connect (G_OBJECT (drawing_area), "button_release_event", G_CALLBACK(button_release_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 | GDK_BUTTON_RELEASE_MASK); hbox = gtk_hbox_new (FALSE,0); gtk_box_pack_start(GTK_BOX (vbox),hbox, FALSE, FALSE, 2); frame=get_fgbgframe(); gtk_box_pack_start(GTK_BOX (hbox),frame, FALSE, FALSE, 2); gtk_widget_show(frame); colortable=get_system_color_table(); frame=gtk_frame_new("select color"); gtk_widget_set_size_request (GTK_WIDGET (frame),400,75); gtk_box_pack_start(GTK_BOX (hbox),frame, TRUE, TRUE, 2); gtk_container_add(GTK_CONTAINER(frame),colortable); gtk_widget_show (colortable); gtk_widget_show(frame); gtk_widget_show (hbox); gtk_widget_show(vbox); gtk_widget_show(window); /*Initial tool set to PENCIL */ display=gdk_display_get_default(); cursor=gdk_cursor_new(GDK_PENCIL); gdk_window_set_cursor(drawing_area->window,cursor); tool=PENCIL; gtk_button_set_relief(GTK_BUTTON(pencil_button),GTK_RELIEF_NORMAL); filename=g_strdup("Untitled.jpeg"); pixmap = gdk_pixmap_new (drawing_area->window, drawing_area->allocation.width, drawing_area->allocation.height, -1); gdk_draw_rectangle (pixmap, drawing_area->style->white_gc, TRUE, 0, 0, drawing_area->allocation.width, drawing_area->allocation.height); gtk_main (); return 0; }
/********************************************* * AddReferenceImage関数 * * 参考用画像の表示を追加 * * 引数 * * reference : 参考用画像表示ウィンドウの情報 * * file_name : 追加するファイル名 * * pixels : 画像のピクセルデータ * * width : 画像の幅 * * height : 画像の高さ * * stride : 画像の1行分のバイト数 * * channel : 画像のチャンネル数 * *********************************************/ static void AddReferenceImage( REFERENCE_WINDOW* reference, const char* file_name, uint8* pixels, int width, int height, int stride, int channel ) { GtkWidget *tab_label; GtkWidget *alignment; cairo_format_t format = (stride / width == 4) ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24; REFERENCE_IMAGE *image; image = reference->data->images[reference->data->num_image] = (REFERENCE_IMAGE*)MEM_ALLOC_FUNC(sizeof(**reference->data->images)); image->pixels = pixels; image->width = width; image->height = height; image->stride = stride; image->channel = (uint8)channel; image->surface_p = cairo_image_surface_create_for_data(image->pixels, format, image->width, image->height, image->stride); image->zoom = image->rev_zoom = 1; image->app = reference->app; image->draw_area = gtk_drawing_area_new(); gtk_widget_set_size_request(image->draw_area, image->width, image->height); gtk_widget_set_events(image->draw_area, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); (void)g_signal_connect(G_OBJECT(image->draw_area), "destroy", G_CALLBACK(OnDestroyReferenceImageDrawArea), image); #if GTK_MAJOR_VERSION <= 2 (void)g_signal_connect(G_OBJECT(image->draw_area), "expose_event", G_CALLBACK(DisplayReferenceImage), image); #else (void)g_signal_connect(G_OBJECT(image->draw_area), "draw", G_CALLBACK(DisplayReferenceImage), image); #endif (void)g_signal_connect(G_OBJECT(image->draw_area), "button_press_event", G_CALLBACK(ReferenceImageButtonPress), image); alignment = gtk_alignment_new(0.5f, 0.5f, 0.0f, 0.0f); gtk_container_add(GTK_CONTAINER(alignment), image->draw_area); image->scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(image->scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(image->scroll), alignment); tab_label = CreateNotebookLabel(file_name, reference->data->note_book, reference->data->num_image, OnCloseReferenceImage, reference); gtk_notebook_append_page(GTK_NOTEBOOK(reference->data->note_book), image->scroll, tab_label); gtk_widget_show_all(image->scroll); gtk_widget_set_sensitive(reference->data->scale, TRUE); reference->data->active_image = reference->data->num_image; #if GTK_MAJOR_VERSION <= 2 gtk_notebook_set_page(GTK_NOTEBOOK(reference->data->note_book), reference->data->active_image); #else gtk_notebook_set_current_page(GTK_NOTEBOOK(reference->data->note_book), reference->data->active_image); #endif reference->data->num_image++; }
static int gtkFileDlgPopup(Ihandle* ih, int x, int y) { InativeHandle* parent = iupDialogGetNativeParent(ih); GtkWidget* dialog; GtkWidget* preview_canvas = NULL; GtkFileChooserAction action; IFnss file_cb; char* value; int response, filter_count = 0; iupAttribSetInt(ih, "_IUPDLG_X", x); /* used in iupDialogUpdatePosition */ iupAttribSetInt(ih, "_IUPDLG_Y", y); value = iupAttribGetStr(ih, "DIALOGTYPE"); if (iupStrEqualNoCase(value, "SAVE")) action = GTK_FILE_CHOOSER_ACTION_SAVE; else if (iupStrEqualNoCase(value, "DIR")) action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; else action = GTK_FILE_CHOOSER_ACTION_OPEN; value = iupAttribGet(ih, "TITLE"); if (!value) { GtkStockItem item; if (action == GTK_FILE_CHOOSER_ACTION_SAVE) value = GTK_STOCK_SAVE_AS; else value = GTK_STOCK_OPEN; gtk_stock_lookup(value, &item); value = item.label; iupAttribStoreStr(ih, "TITLE", iupgtkStrConvertFromUTF8(value)); value = iupAttribGet(ih, "TITLE"); iupStrRemoveChar(value, '_'); } dialog = gtk_file_chooser_dialog_new(iupgtkStrConvertToUTF8(value), (GtkWindow*)parent, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); if (!dialog) return IUP_ERROR; if (action == GTK_FILE_CHOOSER_ACTION_SAVE) gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_OK); else if (action == GTK_FILE_CHOOSER_ACTION_OPEN) gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OPEN, GTK_RESPONSE_OK); else gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); if (IupGetCallback(ih, "HELP_CB")) gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); #if GTK_CHECK_VERSION(2, 6, 0) if (iupAttribGetBoolean(ih, "SHOWHIDDEN")) gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE); #endif if (iupAttribGetBoolean(ih, "MULTIPLEFILES") && action == GTK_FILE_CHOOSER_ACTION_OPEN) gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); #if GTK_CHECK_VERSION(2, 8, 0) if (!iupAttribGetBoolean(ih, "NOOVERWRITEPROMPT") && action == GTK_FILE_CHOOSER_ACTION_SAVE) gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); #endif /* just check for the path inside FILE */ value = iupAttribGet(ih, "FILE"); if (value && (value[0] == '/' || value[1] == ':')) { char* dir = iupStrFileGetPath(value); int len = strlen(dir); iupAttribStoreStr(ih, "DIRECTORY", dir); free(dir); iupAttribStoreStr(ih, "FILE", value+len); } value = iupAttribGet(ih, "DIRECTORY"); if (value) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value)); value = iupAttribGet(ih, "FILE"); if (value) { if (action == GTK_FILE_CHOOSER_ACTION_SAVE) gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value)); else { if (iupdrvIsFile(value)) /* check if file exists */ gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value)); } } value = iupAttribGet(ih, "EXTFILTER"); if (value) { char *name, *pattern, *filters = iupStrDup(value), *p; char atrib[30]; int i; int filter_index = iupAttribGetInt(ih, "FILTERUSED"); if (!filter_index) filter_index = 1; filter_count = iupStrReplace(filters, '|', 0) / 2; p = filters; for (i=0; i<filter_count; i++) { GtkFileFilter *filter = gtk_file_filter_new(); gtkFileDlgGetNextFilter(&p, &name, &pattern); gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(name)); gtk_file_filter_add_pattern(filter, pattern); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); sprintf(atrib, "_IUPDLG_FILTER%d", i+1); iupAttribSetStr(ih, atrib, (char*)filter); if (i+1 == filter_index) gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); } free(filters); } else { value = iupAttribGet(ih, "FILTER"); if (value) { GtkFileFilter *filter = gtk_file_filter_new(); char* info = iupAttribGet(ih, "FILTERINFO"); if (!info) info = value; gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(info)); gtk_file_filter_add_pattern(filter, value); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); } } file_cb = (IFnss)IupGetCallback(ih, "FILE_CB"); if (file_cb && action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) { g_signal_connect(GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK(gtkFileDlgUpdatePreview), ih); g_signal_connect(dialog, "realize", G_CALLBACK(gtkFileDlgRealize), ih); if (iupAttribGetBoolean(ih, "SHOWPREVIEW")) { GtkWidget* frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN); gtk_widget_set_size_request(frame, 180, 150); preview_canvas = gtk_drawing_area_new(); gtk_widget_set_double_buffered(preview_canvas, FALSE); gtk_container_add(GTK_CONTAINER(frame), preview_canvas); gtk_widget_show(preview_canvas); g_signal_connect(preview_canvas, "configure-event", G_CALLBACK(gtkFileDlgPreviewConfigureEvent), ih); g_signal_connect(preview_canvas, "expose-event", G_CALLBACK(gtkFileDlgPreviewExposeEvent), ih); g_signal_connect(preview_canvas, "realize", G_CALLBACK(gtkFileDlgPreviewRealize), ih); iupAttribSetStr(ih, "_IUPDLG_FILE_CHOOSER", (char*)dialog); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), frame); } } /* initialize the widget */ gtk_widget_realize(GTK_WIDGET(dialog)); ih->handle = GTK_WIDGET(dialog); iupDialogUpdatePosition(ih); ih->handle = NULL; /* reset handle */ do { response = gtk_dialog_run(GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_HELP) { Icallback cb = IupGetCallback(ih, "HELP_CB"); if (cb && cb(ih) == IUP_CLOSE) response = GTK_RESPONSE_CANCEL; } else if (response == GTK_RESPONSE_OK) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); int file_exist = iupdrvIsFile(filename); int dir_exist = iupdrvIsDirectory(filename); g_free(filename); if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) { if (!dir_exist) { iupStrMessageShowError(ih, "IUP_INVALIDDIR"); response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } } else if (!iupAttribGetBoolean(ih, "MULTIPLEFILES")) { if (dir_exist) { iupStrMessageShowError(ih, "IUP_FILEISDIR"); response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } if (!file_exist) /* if do not exist check ALLOWNEW */ { value = iupAttribGet(ih, "ALLOWNEW"); if (!value) { if (action == GTK_FILE_CHOOSER_ACTION_SAVE) value = "YES"; else value = "NO"; } if (!iupStrBoolean(value)) { iupStrMessageShowError(ih, "IUP_FILENOTEXIST"); response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } } if (file_cb) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); int ret = file_cb(ih, iupgtkStrConvertFromFilename(filename), "OK"); g_free(filename); if (ret == IUP_IGNORE) { response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } } } } } while (response == GTK_RESPONSE_HELP); if (file_cb) { if (iupAttribGetBoolean(ih, "SHOWPREVIEW")) iupgtkReleaseNativeGraphicsContext(preview_canvas, (void*)iupAttribGet(ih, "PREVIEWDC")); file_cb(ih, NULL, "FINISH"); } if (response == GTK_RESPONSE_OK) { int file_exist, dir_exist; if (filter_count) { int i; char atrib[30]; GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog)); for (i=0; i<filter_count; i++) { sprintf(atrib, "_IUPDLG_FILTER%d", i+1); if (filter == (GtkFileFilter*)iupAttribGet(ih, atrib)) iupAttribSetInt(ih, "FILTERUSED", i+1); } } if (iupAttribGetBoolean(ih, "MULTIPLEFILES")) { GSList* file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); if (file_list->next) /* if more than one file */ gtkFileDlgGetMultipleFiles(ih, file_list); else { char* filename = (char*)file_list->data; iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename)); g_free(filename); /* store the DIRECTORY */ { char* dir = iupStrFileGetPath(iupAttribGet(ih, "VALUE")); iupAttribStoreStr(ih, "DIRECTORY", dir); free(dir); } } g_slist_free(file_list); file_exist = 1; dir_exist = 0; } else { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename)); file_exist = iupdrvIsFile(filename); dir_exist = iupdrvIsDirectory(filename); if (file_exist) { char* dir = iupStrFileGetPath(filename); iupAttribStoreStr(ih, "DIRECTORY", dir); free(dir); } g_free(filename); } if (dir_exist) { iupAttribSetStr(ih, "FILEEXIST", NULL); iupAttribSetStr(ih, "STATUS", "0"); } else { if (file_exist) /* check if file exists */ { iupAttribSetStr(ih, "FILEEXIST", "YES"); iupAttribSetStr(ih, "STATUS", "0"); } else { iupAttribSetStr(ih, "FILEEXIST", "NO"); iupAttribSetStr(ih, "STATUS", "1"); } } if (action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER && !iupAttribGetBoolean(ih, "NOCHANGEDIR")) /* do change the current directory */ { /* GtkFileChooser does not change the current directory */ char* dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog)); if (dir) { iupdrvSetCurrentDirectory(dir); g_free(dir); } } } else { iupAttribSetStr(ih, "FILTERUSED", NULL); iupAttribSetStr(ih, "VALUE", NULL); iupAttribSetStr(ih, "FILEEXIST", NULL); iupAttribSetStr(ih, "STATUS", "-1"); } gtk_widget_destroy(GTK_WIDGET(dialog)); return IUP_NOERROR; }
void add_notification_action(GtkWindow* nw, const char* text, const char* key, ActionInvokedCb cb) { WindowData* windata; GtkWidget* label; GtkWidget* button; GtkWidget* hbox; GdkPixbuf* pixbuf; char* buf; windata = g_object_get_data(G_OBJECT(nw), "windata"); g_assert(windata != NULL); if (!gtk_widget_get_visible(windata->actions_box)) { GtkWidget* alignment; gtk_widget_show(windata->actions_box); update_content_hbox_visibility(windata); alignment = gtk_alignment_new(1, 0.5, 0, 0); gtk_widget_show(alignment); gtk_box_pack_end(GTK_BOX(windata->actions_box), alignment, FALSE, TRUE, 0); windata->pie_countdown = gtk_drawing_area_new(); gtk_widget_show(windata->pie_countdown); gtk_container_add(GTK_CONTAINER(alignment), windata->pie_countdown); gtk_widget_set_size_request(windata->pie_countdown, PIE_WIDTH, PIE_HEIGHT); #if GTK_CHECK_VERSION (3, 0, 0) g_signal_connect (G_OBJECT (windata->pie_countdown), "draw", G_CALLBACK (on_countdown_draw), windata); #else g_signal_connect (G_OBJECT (windata->pie_countdown), "expose_event", G_CALLBACK (on_countdown_expose_event), windata); #endif } button = gtk_button_new(); gtk_widget_show(button); gtk_box_pack_start(GTK_BOX(windata->actions_box), button, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 6); gtk_widget_show(hbox); gtk_container_add(GTK_CONTAINER(button), hbox); /* Try to be smart and find a suitable icon. */ buf = g_strdup_printf("stock_%s", key); pixbuf = gtk_icon_theme_load_icon(gtk_icon_theme_get_for_screen(gdk_window_get_screen(gtk_widget_get_window(GTK_WIDGET(nw)))), buf, 16, GTK_ICON_LOOKUP_USE_BUILTIN, NULL); g_free(buf); if (pixbuf != NULL) { GtkWidget* image = gtk_image_new_from_pixbuf(pixbuf); gtk_widget_show(image); gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); #if GTK_CHECK_VERSION (3, 15, 2) gtk_widget_set_halign (image, GTK_ALIGN_CENTER); gtk_widget_set_valign (image, GTK_ALIGN_CENTER); #else gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.5); #endif } label = gtk_label_new(NULL); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); #if GTK_CHECK_VERSION (3, 15, 2) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); #endif buf = g_strdup_printf("<small>%s</small>", text); gtk_label_set_markup(GTK_LABEL(label), buf); g_free(buf); g_object_set_data(G_OBJECT(button), "_nw", nw); g_object_set_data_full(G_OBJECT(button), "_action_key", g_strdup(key), g_free); g_signal_connect(G_OBJECT(button), "button-release-event", G_CALLBACK(action_clicked_cb), cb); }
void (*clickCallback) (void *boss, GuiDrawingAreaClickEvent event), void (*keyCallback) (void *boss, GuiDrawingAreaKeyEvent event), void (*resizeCallback) (void *boss, GuiDrawingAreaResizeEvent event), void *boss, unsigned long flags) { GuiDrawingArea me = Melder_calloc_f (struct structGuiDrawingArea, 1); my exposeCallback = exposeCallback; my exposeBoss = boss; my clickCallback = clickCallback; my clickBoss = boss; my keyCallback = keyCallback; my keyBoss = boss; my resizeCallback = resizeCallback; my resizeBoss = boss; #if gtk my widget = gtk_drawing_area_new (); GdkEventMask mask = (GdkEventMask) (GDK_EXPOSURE_MASK // receive exposure events | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK // receive click events | GDK_BUTTON_MOTION_MASK // receive motion notifies when a button is pressed | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_HINT_MASK); // receive fewer motion notify events (the cb might take time) gtk_widget_set_events (GTK_WIDGET (my widget), mask); // TODO: maybe make this a composite widget and use connect_after for expose? // see http://library.gnome.org/devel/gdk/stable/gdk-Windows.html#COMPOSITED-WINDOWS g_signal_connect (G_OBJECT(my widget), "expose-event", G_CALLBACK (_GuiGtkDrawingArea_exposeCallback), me); g_signal_connect (G_OBJECT (my widget), "destroy", G_CALLBACK (_GuiGtkDrawingArea_destroyCallback), me); g_signal_connect (G_OBJECT (my widget), "button-press-event", G_CALLBACK (_GuiGtkDrawingArea_clickCallback), me); g_signal_connect (G_OBJECT (my widget), "button-release-event",
GtkWidget * do_drawingarea (GtkWidget *do_widget) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *da; GtkWidget *label; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Drawing Area"); g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); 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_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); da = gtk_drawing_area_new (); /* set a minimum size */ gtk_widget_set_size_request (da, 100, 100); gtk_container_add (GTK_CONTAINER (frame), da); g_signal_connect (da, "expose-event", G_CALLBACK (checkerboard_expose), NULL); /* * Create the scribble area */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Scribble area</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); da = gtk_drawing_area_new (); /* set a minimum size */ gtk_widget_set_size_request (da, 100, 100); gtk_container_add (GTK_CONTAINER (frame), da); /* Signals used to handle backing pixmap */ g_signal_connect (da, "expose-event", G_CALLBACK (scribble_expose_event), NULL); g_signal_connect (da,"configure-event", G_CALLBACK (scribble_configure_event), NULL); /* Event signals */ g_signal_connect (da, "motion-notify-event", G_CALLBACK (scribble_motion_notify_event), NULL); g_signal_connect (da, "button-press-event", G_CALLBACK (scribble_button_press_event), NULL); /* Ask to receive events the drawing area doesn't normally * subscribe to */ gtk_widget_set_events (da, gtk_widget_get_events (da) | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); return window; }
gint main (gint argc, gchar * argv[]) { GstStateChangeReturn ret; GstElement *pipeline; GstElement *filter, *sink; GstElement *sourcebin; GError *error = NULL; GtkWidget *window; GtkWidget *screen; GtkWidget *vbox, *combo; GtkWidget *hbox; GtkWidget *play, *pause, *null, *ready; gchar **source_desc_array = NULL; gchar *source_desc = NULL; GOptionContext *context; GOptionEntry options[] = { {"source-bin", 's', 0, G_OPTION_ARG_STRING_ARRAY, &source_desc_array, "Use a custom source bin description (gst-launch style)", NULL} , {NULL} }; context = g_option_context_new (NULL); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, gst_init_get_option_group ()); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("Inizialization error: %s\n", GST_STR_NULL (error->message)); return -1; } g_option_context_free (context); if (source_desc_array != NULL) { source_desc = g_strjoinv (" ", source_desc_array); g_strfreev (source_desc_array); } if (source_desc == NULL) { source_desc = g_strdup ("videotestsrc ! video/x-raw, width=352, height=288 ! identity"); } sourcebin = gst_parse_bin_from_description (g_strdup (source_desc), TRUE, &error); g_free (source_desc); if (error) { g_print ("Error while parsing source bin description: %s\n", GST_STR_NULL (error->message)); return -1; } g_set_application_name ("gst-gl-effects test app"); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 3); pipeline = gst_pipeline_new ("pipeline"); filter = gst_element_factory_make ("gleffects", "flt"); sink = gst_element_factory_make ("glimagesink", "glsink"); gst_bin_add_many (GST_BIN (pipeline), sourcebin, filter, sink, NULL); if (!gst_element_link_many (sourcebin, filter, sink, NULL)) { g_print ("Failed to link one or more elements!\n"); return -1; } g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (destroy_cb), pipeline); g_signal_connect (G_OBJECT (window), "destroy-event", G_CALLBACK (destroy_cb), pipeline); screen = gtk_drawing_area_new (); gtk_widget_set_size_request (screen, 640, 480); // 500 x 376 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_box_pack_start (GTK_BOX (vbox), screen, TRUE, TRUE, 0); combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "identity"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "mirror"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "squeeze"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "stretch"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "fisheye"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "twirl"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "bulge"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "tunnel"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "square"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "heat"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "xpro"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "lumaxpro"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "sepia"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "xray"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "sin"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "glow"); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (apply_fx), filter); gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); play = gtk_button_new_with_label ("PLAY"); g_signal_connect (G_OBJECT (play), "clicked", G_CALLBACK (play_cb), pipeline); pause = gtk_button_new_with_label ("PAUSE"); g_signal_connect (G_OBJECT (pause), "clicked", G_CALLBACK (pause_cb), pipeline); null = gtk_button_new_with_label ("NULL"); g_signal_connect (G_OBJECT (null), "clicked", G_CALLBACK (null_cb), pipeline); ready = gtk_button_new_with_label ("READY"); g_signal_connect (G_OBJECT (ready), "clicked", G_CALLBACK (ready_cb), pipeline); gtk_box_pack_start (GTK_BOX (hbox), null, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), ready, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), play, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), pause, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); g_signal_connect (screen, "realize", G_CALLBACK (expose_cb), pipeline); ret = gst_element_set_state (pipeline, GST_STATE_PLAYING); if (ret == GST_STATE_CHANGE_FAILURE) { g_print ("Failed to start up pipeline!\n"); return -1; } gtk_widget_show_all (GTK_WIDGET (window)); gtk_main (); return 0; }
/* adds the toolbar to a container */ void widgets_get_canvas(GtkWidget **canvas){ *canvas = gtk_drawing_area_new(); gtk_widget_set_size_request(*canvas, 700, 550); }
void gui_init () { GtkWidget *hbox = NULL, *vbox = NULL, *vbox1 = NULL, *frame = NULL; GtkWidget *separator; GtkAccelGroup *ag; GtkItemFactoryEntry game_items [num_games+1]; GtkItemFactoryEntry items[] = { #if GTK_MAJOR_VERSION == 1 /* { "/_File", NULL, NULL, 0, "<Branch>" }, { "/File/_Load game", "<control>L", menu_load_file_dialog, 0, "" }, { "/File/_Save game", NULL, NULL, 0, "" }, { "/File/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0, "" }, */ { "/_Game", NULL, NULL, 0, "<Branch>" }, { "/Game/Select _Game", NULL, NULL, 0, "<LastBranch>" }, { "/Game/_Levels", NULL, NULL, 0, "<Branch>"}, { "/Game/Sep1", NULL, NULL, 0, "<Separator>" }, { "/Game/_New", "<control>N", menu_start_stop_game, MENU_RESET_GAME, "" }, { "/Game/_Start", "<control>G", menu_start_stop_game, MENU_START_GAME, "" }, { "/Game/_Pause", "<control>P", menu_start_stop_game, MENU_STOP_GAME, "" }, { "/Game/Sep2", NULL, NULL, 0, "<Separator>" }, { "/Game/_Highscores", NULL, prefs_show_scores, 0, ""}, { "/Game/_Zap Highscores", NULL, prefs_zap_highscores, 0, ""}, { "/Game/Sep3", NULL, NULL, 0, "<Separator>" }, { "/Game/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0, "" }, { "/_Move", NULL, NULL, 0, "<Branch>" }, { "/Move/_Back", "<control>B", menu_back_forw, MENU_BACK, "" }, { "/Move/_Forward", "<control>F", menu_back_forw, MENU_FORW, "" }, { "/Move/Sep1", NULL, NULL, 0, "<Separator>" }, { "/Move/_Move Now", "<control>M", (GtkItemFactoryCallback) ui_move_now_cb, 0, "" }, #else /* { "/_File", NULL, NULL, 0, "<Branch>" }, { "/File/_Load game", "<control>L", menu_load_file_dialog, 0, "<StockItem>", GTK_STOCK_OPEN }, { "/File/_Save game", NULL, menu_save_file_dialog, 0, "<StockItem>", GTK_STOCK_SAVE }, { "/File/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0, "<StockItem>", GTK_STOCK_QUIT }, */ { "/_Game", NULL, NULL, 0, "<Branch>" }, { "/Game/Select _Game", NULL, NULL, 0, "<LastBranch>" }, { "/Game/Levels", NULL, NULL, 0, "<Branch>"}, { "/Game/Sep1", NULL, NULL, 0, "<Separator>" }, { "/Game/_New", "<control>N", menu_start_stop_game, MENU_RESET_GAME, "<StockItem>", GTK_STOCK_NEW }, { "/Game/_Start", "<control>G", menu_start_stop_game, MENU_START_GAME, "<StockItem>", GTK_STOCK_YES }, { "/Game/_Pause", "<control>P", menu_start_stop_game, MENU_STOP_GAME, "<StockItem>", GTK_STOCK_STOP }, { "/Game/Sep2", NULL, NULL, 0, "<Separator>" }, //FIXME: there's a scores stock item but I can't seem to find it { "/Game/_Highscores", NULL, prefs_show_scores, 0, ""}, { "/Game/_Zap Highscores", NULL, prefs_zap_highscores, 0, ""}, { "/Game/Sep3", NULL, NULL, 0, "<Separator>" }, { "/Game/_Quit", "<control>Q", (GtkSignalFunc) ui_cleanup, 0, "<StockItem>", GTK_STOCK_QUIT }, { "/_Move", NULL, NULL, 0, "<Branch>" }, { "/Move/_Back", "<control>B", menu_back_forw, 1, "<StockItem>", GTK_STOCK_GO_BACK }, { "/Move/_Forward", "<control>F", menu_back_forw, 2, "<StockItem>", GTK_STOCK_GO_FORWARD }, { "/Move/Sep1", NULL, NULL, 0, "<Separator>" }, { "/Move/_Move Now", "<control>M", (GtkItemFactoryCallback) ui_move_now_cb, 0, "" }, #endif { "/_Settings", NULL, NULL, 0, "<Branch>" }, { "/Settings/_Player", NULL, NULL, 0, "<Branch>" }, { "/Settings/Player/File", NULL, NULL, 0, "<RadioItem>" }, { "/Settings/Player/Human-Human", NULL, menu_set_player, 1, "/Settings/Player/File" }, { "/Settings/Player/Human-Machine", NULL, menu_set_player, 2, "/Settings/Player/File" }, { "/Settings/Player/Machine-Human", NULL, menu_set_player, 3, "/Settings/Player/File" }, { "/Settings/Player/Machine-Machine", NULL, menu_set_player, 4, "/Settings/Player/File" }, // { "/Settings/_Eval function", NULL, NULL, 0, "<Branch>" }, // { "/Settings/_Eval function/_White", NULL, NULL, 0, "<Branch>" }, // { "/Settings/_Eval function/_Black", NULL, NULL, 0, "<Branch>" }, { "/Settings/_Flip Board", "<control>T", menu_board_flip_cb, 0, "" }, { "/Settings/_Enable Sound", NULL, menu_enable_sound_cb, 1, ""}, { "/Settings/_Disable Sound", NULL, menu_enable_sound_cb, 0, ""}, { "/Settings/_Time per move", NULL, NULL, 0, "<Branch>" }, { "/Settings/_Time per move/Default", NULL, menu_set_delay_cb, DEF_TIME_PER_MOVE, "<RadioItem>" }, { "/Settings/_Time per move/100 milliseconds", NULL, menu_set_delay_cb, 100, "/Settings/Time per move/Default" }, { "/Settings/Time per move/200 milliseconds", NULL, menu_set_delay_cb, 200, "/Settings/Time per move/Default" }, { "/Settings/Time per move/500 milliseconds", NULL, menu_set_delay_cb, 500, "/Settings/Time per move/Default" }, { "/Settings/Time per move/1 second", NULL, menu_set_delay_cb, 1000, "/Settings/Time per move/Default" }, { "/Settings/Time per move/2 seconds", NULL, menu_set_delay_cb, 2000, "/Settings/Time per move/Default" }, { "/Settings/Time per move/5 seconds", NULL, menu_set_delay_cb, 5000, "/Settings/Time per move/Default" }, { "/Settings/Time per move/10 seconds", NULL, menu_set_delay_cb, 10000, "/Settings/Time per move/Default" }, { "/Settings/Time per move/30 seconds", NULL, menu_set_delay_cb, 30000, "/Settings/Time per move/Default" }, { "/Settings/Time per move/1 minute", NULL, menu_set_delay_cb, 600000, "/Settings/Time per move/Default" }, { "/_Help", NULL, NULL, 0, "<Branch>" }, { "/Help/_About", NULL, menu_show_about_dialog, 0, ""}, #ifdef HAVE_GNOME { "/Help/_Home Page", NULL, menu_help_home_page, 0, "<StockItem>", GTK_STOCK_HOME}, #endif // TODO: implement context help // { "/Help/_Context help", NULL, ui_set_context_help, 0, ""}, }; int i; gdk_rgb_init (); main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_policy (GTK_WINDOW (main_window), FALSE, FALSE, TRUE); gtk_signal_connect (GTK_OBJECT (main_window), "delete_event", GTK_SIGNAL_FUNC(ui_cleanup), NULL); gtk_window_set_title (GTK_WINDOW (main_window), "Gtkboard"); ag = gtk_accel_group_new(); menu_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", ag); gtk_window_add_accel_group (GTK_WINDOW (main_window), ag); gtk_item_factory_create_items (menu_factory, sizeof (items) / sizeof (items[0]), items, NULL); for (i=0; i<=num_games; i++) { if (i==0) game_items[i].path = "/Game/Select Game/none"; else { if (games[i-1]->group) { GtkItemFactoryEntry group_item = {NULL, NULL, NULL, 0, "<Branch>"}; group_item.path = g_strdup_printf ("/Game/Select Game/%s", games[i-1]->group); // FIXME: this is O(N^2) where N is the number of games if (gtk_item_factory_get_widget (menu_factory, group_item.path) == NULL) gtk_item_factory_create_item (menu_factory, &group_item, NULL, 1); game_items[i].path = g_strdup_printf ("/Game/Select Game/%s/%s", games[i-1]->group ? games[i-1]->group : "", games[i-1]->name); } else game_items[i].path = g_strdup_printf ("/Game/Select Game/%s", games[i-1]->name); } game_items[i].accelerator = NULL; game_items[i].callback = menu_set_game; game_items[i].callback_action = i-1; game_items[i].item_type = (i == 0 ? "<RadioItem>": "/Game/Select Game/none"); } gtk_item_factory_create_items (menu_factory, num_games+1, game_items, NULL); // ugly hack to create a group of radio button with no button selected by default gtk_item_factory_delete_item (menu_factory, "/Game/Select Game/none"); menu_main = gtk_item_factory_get_widget (menu_factory, "<main>"); gtk_widget_set_state (gtk_item_factory_get_widget (menu_factory, "/Settings/Player/File"), GTK_STATE_INSENSITIVE); for (i=1; i<=NUM_RECENT_GAMES; i++) { gchar *tmp; gchar *gamename; gamename = prefs_get_config_val (tmp = g_strdup_printf ("recent_game_%d", i)); g_free (tmp); if (gamename && gamename[0] != '\0') menu_insert_game_item (gamename, i); } menu_set_eval_function (); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox), menu_main, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); { GtkWidget *innerframe; board_colbox = gtk_vbox_new (FALSE, 0); board_area = gtk_drawing_area_new (); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), board_colbox, FALSE, FALSE, 0); vbox1 = gtk_vbox_new (FALSE, 0); board_rowbox = gtk_hbox_new (FALSE, 0); innerframe = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (innerframe), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (vbox1), innerframe); gtk_container_add (GTK_CONTAINER (innerframe), board_area); gtk_container_add (GTK_CONTAINER (vbox1), board_rowbox); gtk_box_pack_start (GTK_BOX (hbox), vbox1, TRUE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_signal_connect (GTK_OBJECT (board_area), "expose_event", GTK_SIGNAL_FUNC (board_redraw), NULL); gtk_widget_set_events(board_area, gtk_widget_get_events (board_area) | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK ); gtk_signal_connect (GTK_OBJECT (board_area), "leave_notify_event", GTK_SIGNAL_FUNC (board_signal_handler), NULL); gtk_signal_connect (GTK_OBJECT (board_area), "motion_notify_event", GTK_SIGNAL_FUNC (board_signal_handler), NULL); gtk_signal_connect (GTK_OBJECT (board_area), "button_release_event", GTK_SIGNAL_FUNC (board_signal_handler), NULL); gtk_signal_connect (GTK_OBJECT (board_area), "button_press_event", GTK_SIGNAL_FUNC (board_signal_handler), NULL); gtk_signal_connect (GTK_OBJECT (main_window), "key_press_event", GTK_SIGNAL_FUNC (board_signal_handler), NULL); gtk_signal_connect (GTK_OBJECT (main_window), "key_release_event", GTK_SIGNAL_FUNC (board_signal_handler), NULL); menu_info_bar = hbox = gtk_hbox_new (FALSE, 0); sb_game_label = gtk_label_new (opt_game ? opt_game->name : NULL); gtk_box_pack_start (GTK_BOX (hbox), sb_game_label, FALSE, FALSE, 3); sb_game_separator = gtk_vseparator_new (); gtk_box_pack_start (GTK_BOX (hbox), sb_game_separator, FALSE, FALSE, 0); sb_player_label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (hbox), sb_player_label, FALSE, FALSE, 3); sb_player_separator = gtk_vseparator_new (); gtk_box_pack_start (GTK_BOX (hbox), sb_player_separator, FALSE, FALSE, 0); sb_who_label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (hbox), sb_who_label, FALSE, FALSE, 3); sb_who_separator = gtk_vseparator_new (); gtk_box_pack_start (GTK_BOX (hbox), sb_who_separator, FALSE, FALSE, 0); sb_score_label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (hbox), sb_score_label, FALSE, FALSE, 3); sb_score_separator = gtk_vseparator_new (); gtk_box_pack_start (GTK_BOX (hbox), sb_score_separator, FALSE, FALSE, 0); #if GTK_MAJOR_VERSION == 2 sb_turn_image = gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_MENU); gtk_box_pack_end (GTK_BOX (hbox), sb_turn_image, FALSE, FALSE, 0); sb_turn_separator = gtk_vseparator_new (); gtk_box_pack_end (GTK_BOX (hbox), sb_turn_separator, FALSE, FALSE, 0); #endif sb_time_label = gtk_label_new (NULL); gtk_box_pack_end (GTK_BOX (hbox), sb_time_label, FALSE, FALSE, 0); sb_time_separator = gtk_vseparator_new (); gtk_box_pack_end (GTK_BOX (hbox), sb_time_separator, FALSE, FALSE, 0); } menu_info_separator = separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); menu_warning_bar = gtk_label_new ("Warning: this game has not yet been completely implemented."); gtk_box_pack_start (GTK_BOX (vbox), menu_warning_bar, FALSE, FALSE, 0); sb_warning_separator = separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); sb_message_label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (sb_message_label), 0, 0.5); hbox = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), sb_message_label, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (main_window), vbox); // FIXME: board_init() needs show() to be called to get a gc, but // leads to the whole window not popping up at once gtk_widget_show_all (main_window); if (!opt_game) board_init (); gtk_timeout_add (100, sb_update_periodic, NULL); // this should be called before setting state_gui_active = TRUE if (opt_game) menu_put_game (); state_gui_active = TRUE; if (opt_game) menu_start_game (); menu_put_player (TRUE); // if (!opt_game) sb_message ("Select a game from the Game menu", FALSE); sb_update (); }
void create_mainwindow (GooCanvasItem *rootitem) { GtkWidget *wdrawareagrande; GtkWidget *wdrawareapetite; /* GCompris : suppression of all menus */ g_assert(rootitem != NULL); wdrawareagrande = gtk_drawing_area_new (); gtk_widget_set_name (wdrawareagrande, "wdrawareagrande"); //gtk_widget_set_size_request (wdrawareagrande, // WIDTH_BIGAREA, // WIDTH_BIGAREA // ); //gtk_container_add (GTK_CONTAINER (aspectframe1), wdrawareagrande); gtk_widget_set_events (wdrawareagrande, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_STRUCTURE_MASK); /* Gcompris */ goo_canvas_widget_new ( rootitem, wdrawareagrande, X_BASE_BIGAREA, Y_BASE_BIGAREA, WIDTH_BIGAREA, WIDTH_BIGAREA, NULL ); gtk_widget_show (wdrawareagrande); wdrawareapetite = gtk_drawing_area_new (); gtk_widget_set_name (wdrawareapetite, "wdrawareapetite"); gtk_widget_set_events (wdrawareapetite, GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK); /* Gcompris */ goo_canvas_widget_new ( rootitem, wdrawareapetite, X_BASE_SMALLAREA, Y_BASE_SMALLAREA, WIDTH_SMALLAREA, WIDTH_SMALLAREA, NULL ); gtk_widget_show (wdrawareapetite); g_signal_connect (GTK_OBJECT (wdrawareagrande), "expose_event", GTK_SIGNAL_FUNC (on_wdrawareagrande_expose_event), NULL); g_signal_connect (GTK_OBJECT (wdrawareagrande), "configure_event", GTK_SIGNAL_FUNC (on_wdrawareagrande_configure_event), NULL); g_signal_connect (GTK_OBJECT (wdrawareagrande), "button_press_event", GTK_SIGNAL_FUNC (on_wdrawareagrande_button_press_event), NULL); g_signal_connect (GTK_OBJECT (wdrawareagrande), "button_release_event", GTK_SIGNAL_FUNC (on_wdrawareagrande_button_release_event), NULL); g_signal_connect (GTK_OBJECT (wdrawareagrande), "motion_notify_event", GTK_SIGNAL_FUNC (on_wdrawareagrande_motion_notify_event), NULL); g_signal_connect (GTK_OBJECT (wdrawareapetite), "configure_event", GTK_SIGNAL_FUNC (on_wdrawareapetite_configure_event), NULL); g_signal_connect (GTK_OBJECT (wdrawareapetite), "expose_event", GTK_SIGNAL_FUNC (on_wdrawareapetite_expose_event), NULL); /* Gcompris */ /* add here buttons */ GdkPixbuf *pixmap_show = NULL; GdkPixbuf *pixmap_outline = NULL; GdkPixbuf *pixmap_symetry = NULL; GooCanvasItem *previous_figure, *next_figure; GooCanvasItem *show_figure, *outline_figure, *symetry; previous_figure = goo_canvas_svg_new (rootitem, gc_skin_rsvg_get(), "svg-id", "#PREVIOUS", NULL); SET_ITEM_LOCATION_CENTER(previous_figure, X_BASE_SMALLAREA, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 30); next_figure = goo_canvas_svg_new (rootitem, gc_skin_rsvg_get(), "svg-id", "#NEXT", NULL); SET_ITEM_LOCATION_CENTER(next_figure, X_BASE_SMALLAREA + WIDTH_SMALLAREA, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 30); g_signal_connect(previous_figure, "button_press_event", (GCallback) on_arrow_clicked, (gpointer) FALSE); gc_item_focus_init(previous_figure, NULL); g_signal_connect(next_figure, "button_press_event", (GCallback) on_arrow_clicked, (gpointer) TRUE); gc_item_focus_init(next_figure, NULL); pixmap_show = gc_pixmap_load("tangram/gtans_show.png"); pixmap_outline = gc_pixmap_load("tangram/gtans_outline.png"); show_figure = goo_canvas_image_new (rootitem, pixmap_show, X_BASE_SMALLAREA, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 80, NULL); outline_figure = goo_canvas_image_new (rootitem, pixmap_outline, X_BASE_SMALLAREA, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 130, NULL); g_signal_connect(outline_figure, "button_press_event", (GCallback) on_outline_clicked, NULL); g_signal_connect(show_figure, "button_press_event", (GCallback) on_show_clicked, NULL); gc_item_focus_init(outline_figure, NULL); gc_item_focus_init(show_figure, NULL); pixmap_symetry = gc_pixmap_load("tangram/tool-flip.png"); symetry = goo_canvas_image_new (rootitem, pixmap_symetry, X_BASE_SMALLAREA + WIDTH_SMALLAREA - 50, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 180, NULL); g_signal_connect(symetry, "button_press_event", (GCallback) on_symetry_clicked, NULL); gc_item_focus_init(symetry, NULL); /* rotation buttons */ GdkPixbuf *right_rot = NULL; GdkPixbuf *left_rot = NULL; GdkPixbuf *right_rot_big = NULL; GdkPixbuf *left_rot_big = NULL; GooCanvasItem *l_rot_s, *r_rot_s, *l_rot_b, *r_rot_b; right_rot = gc_pixmap_load("tangram/gtans_rotate.png"); left_rot = gc_pixmap_load("tangram/gtans_rotate-left.png"); r_rot_s = goo_canvas_image_new (rootitem, right_rot, X_BASE_SMALLAREA + WIDTH_SMALLAREA, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 60, NULL); l_rot_s = goo_canvas_image_new (rootitem, left_rot, X_BASE_SMALLAREA + WIDTH_SMALLAREA - 100, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 60, NULL); #if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24 gdk_pixbuf_unref(right_rot); gdk_pixbuf_unref(left_rot); #else g_object_unref(right_rot); g_object_unref(left_rot); #endif right_rot_big = gc_pixmap_load("tangram/gtans_2x-rotate.png"); left_rot_big = gc_pixmap_load("tangram/gtans_2x-rotate-left.png"); r_rot_b = goo_canvas_image_new (rootitem, right_rot_big, X_BASE_SMALLAREA + WIDTH_SMALLAREA, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 120, NULL); l_rot_b = goo_canvas_image_new (rootitem, left_rot_big, X_BASE_SMALLAREA + WIDTH_SMALLAREA - 100, Y_BASE_SMALLAREA + WIDTH_SMALLAREA + 120, NULL); #if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24 gdk_pixbuf_unref(right_rot_big); gdk_pixbuf_unref(left_rot_big); #else g_object_unref(right_rot_big); g_object_unref(left_rot_big); #endif g_signal_connect(r_rot_s, "button_press_event", (GCallback) on_rotation_clicked, (gpointer) 0); gc_item_focus_init(r_rot_s, NULL); g_signal_connect(l_rot_s, "button_press_event", (GCallback) on_rotation_clicked, (gpointer) 1); gc_item_focus_init(l_rot_s, NULL); g_signal_connect(r_rot_b, "button_press_event", (GCallback) on_rotation_clicked, (gpointer) 2); gc_item_focus_init(r_rot_b, NULL); g_signal_connect(l_rot_b, "button_press_event", (GCallback) on_rotation_clicked, (gpointer) 3); gc_item_focus_init(l_rot_b, NULL); }
void gkrellm_panel_create(GtkWidget *vbox, GkrellmMonitor *mon, GkrellmPanel *p) { GtkWidget *hbox; GkrellmPiximage piximage; GtkWidget *top_win = gkrellm_get_top_window(); if (!vbox || !mon || !p) return; p->monitor = (gpointer) mon; if (!p->style) /* gkrellm_panel_configure() may not have been called. */ setup_panel_style(p, mon->privat->panel_style); if (!p->bg_piximage_override) { if (mon->privat->style_type == CHART_PANEL_TYPE) p->bg_piximage = gkrellm_bg_panel_piximage(mon->privat->style_id); else p->bg_piximage = gkrellm_bg_meter_piximage(mon->privat->style_id); } p->bg_piximage_override = FALSE; /* If not being called from rebuild or after a panel destroy, then panel | still has a height that must be accounted for. */ if (p->h && p->shown) gkrellm_monitor_height_adjust(- p->h); p->h = p->h_configure; p->w = _GK.chart_width; if (p->hbox == NULL) { hbox = gtk_hbox_new(FALSE, 0); gtk_container_add (GTK_CONTAINER(vbox), hbox); p->hbox = hbox; p->drawing_area = gtk_drawing_area_new(); p->layout = gtk_widget_create_pango_layout(top_win, NULL); gtk_widget_set_events (p->drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK); gtk_box_pack_start(GTK_BOX(p->hbox), p->drawing_area, FALSE, FALSE, 0); gtk_widget_show(p->drawing_area); gtk_widget_show(hbox); p->shown = TRUE; gtk_widget_realize(hbox); gtk_widget_realize(p->drawing_area); panel_list = g_list_append(panel_list, p); p->y_mapped = -1; g_signal_connect(G_OBJECT (p->drawing_area), "size_allocate", G_CALLBACK(cb_panel_size_allocate), p); } gtk_widget_set_size_request(p->drawing_area, p->w, p->h); if (_GK.frame_left_panel_overlap > 0 || _GK.frame_right_panel_overlap > 0) { piximage.pixbuf = gdk_pixbuf_new_subpixbuf(p->bg_piximage->pixbuf, _GK.frame_left_panel_overlap, 0, gdk_pixbuf_get_width(p->bg_piximage->pixbuf) - _GK.frame_left_panel_overlap - _GK.frame_right_panel_overlap, gdk_pixbuf_get_height(p->bg_piximage->pixbuf)); piximage.border = p->bg_piximage->border; gkrellm_border_adjust(&piximage.border, -_GK.frame_left_panel_overlap, -_GK.frame_right_panel_overlap, 0, 0); // gkrellm_scale_piximage_to_pixmap(&piximage, &p->bg_clean_pixmap, // &p->bg_mask, p->w, p->h); gkrellm_scale_theme_background(&piximage, &p->bg_clean_pixmap, &p->bg_mask, p->w, p->h); g_object_unref(G_OBJECT(piximage.pixbuf)); } else gkrellm_scale_theme_background(p->bg_piximage, &p->bg_clean_pixmap, &p->bg_mask, p->w, p->h); // gkrellm_scale_piximage_to_pixmap(p->bg_piximage, &p->bg_clean_pixmap, // &p->bg_mask, p->w, p->h); if (p->bg_text_layer_pixmap) g_object_unref(G_OBJECT(p->bg_text_layer_pixmap)); p->bg_text_layer_pixmap = gdk_pixmap_new(top_win->window, p->w, p->h, -1); if (p->bg_pixmap) g_object_unref(G_OBJECT(p->bg_pixmap)); p->bg_pixmap = gdk_pixmap_new(top_win->window, p->w, p->h, -1); if (p->pixmap) g_object_unref(G_OBJECT(p->pixmap)); p->pixmap = gdk_pixmap_new(top_win->window, p->w, p->h, -1); if (p->shown) { gkrellm_monitor_height_adjust(p->h); gkrellm_pack_side_frames(); } p->need_decal_overlap_check = TRUE; draw_panel(p, FALSE); gkrellm_panel_button_signals_connect(p); }
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; }
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; }
gint main (gint argc, gchar *argv[]) { #ifdef HAVE_X11 XInitThreads(); #endif gtk_init (&argc, &argv); gst_init (&argc, &argv); GstElement* pipeline = gst_pipeline_new ("pipeline"); //window that contains several ares where the video is drawn GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 640, 240); gtk_window_move (GTK_WINDOW (window), 300, 10); gtk_window_set_title (GTK_WINDOW (window), "click on left, right or outside the main window to switch the drawing area"); GdkGeometry geometry; geometry.min_width = 1; geometry.min_height = 1; geometry.max_width = -1; geometry.max_height = -1; gtk_window_set_geometry_hints (GTK_WINDOW (window), window, &geometry, GDK_HINT_MIN_SIZE); //window to control the states GtkWidget* window_control = gtk_window_new (GTK_WINDOW_TOPLEVEL); geometry.min_width = 1; geometry.min_height = 1; geometry.max_width = -1; geometry.max_height = -1; gtk_window_set_geometry_hints (GTK_WINDOW (window_control), window_control, &geometry, GDK_HINT_MIN_SIZE); gtk_window_set_resizable (GTK_WINDOW (window_control), FALSE); gtk_window_move (GTK_WINDOW (window_control), 10, 10); GtkWidget* table = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window_control), table); //control state null GtkWidget* button_state_null = gtk_button_new_with_label ("GST_STATE_NULL"); g_signal_connect (G_OBJECT (button_state_null), "clicked", G_CALLBACK (button_state_null_cb), pipeline); gtk_grid_attach (GTK_GRID (table), button_state_null, 0, 0, 1, 1); gtk_widget_show (button_state_null); //control state ready GtkWidget* button_state_ready = gtk_button_new_with_label ("GST_STATE_READY"); g_signal_connect (G_OBJECT (button_state_ready), "clicked", G_CALLBACK (button_state_ready_cb), pipeline); gtk_grid_attach (GTK_GRID (table), button_state_ready, 0, 1, 1, 1); gtk_widget_show (button_state_ready); //control state paused GtkWidget* button_state_paused = gtk_button_new_with_label ("GST_STATE_PAUSED"); g_signal_connect (G_OBJECT (button_state_paused), "clicked", G_CALLBACK (button_state_paused_cb), pipeline); gtk_grid_attach (GTK_GRID (table), button_state_paused, 0, 2, 1, 1); gtk_widget_show (button_state_paused); //control state playing GtkWidget* button_state_playing = gtk_button_new_with_label ("GST_STATE_PLAYING"); g_signal_connect (G_OBJECT (button_state_playing), "clicked", G_CALLBACK (button_state_playing_cb), pipeline); gtk_grid_attach (GTK_GRID (table), button_state_playing, 0, 3, 1, 1); gtk_widget_show (button_state_playing); gtk_widget_show (table); gtk_widget_show (window_control); //configure the pipeline g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(destroy_cb), pipeline); GstElement* videosrc = gst_element_factory_make ("videotestsrc", "videotestsrc"); GstElement* videosink = gst_element_factory_make ("glimagesink", "glimagesink"); gst_bin_add_many (GST_BIN (pipeline), videosrc, videosink, NULL); gboolean link_ok = gst_element_link_many(videosrc, videosink, NULL); if(!link_ok) { g_warning("Failed to link videosrc to videosink!\n") ; return -1; } //areas where the video is drawn GtkWidget* table_areas = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), table_areas); GtkWidget* area_top_left = gtk_drawing_area_new(); gtk_widget_add_events(area_top_left, GDK_BUTTON_PRESS_MASK); gtk_widget_set_size_request (area_top_left, 320, 240); gtk_grid_attach (GTK_GRID (table_areas), area_top_left, 0, 0, 1, 1); GtkWidget* area_top_right = gtk_drawing_area_new(); gtk_widget_add_events(area_top_right, GDK_BUTTON_PRESS_MASK); gtk_widget_set_size_request (area_top_right, 320, 240); gtk_grid_attach (GTK_GRID (table_areas), area_top_right, 1, 0, 1, 1); gtk_widget_set_redraw_on_allocate (area_top_left, TRUE); gtk_widget_set_redraw_on_allocate (area_top_right, TRUE); gtk_widget_realize(area_top_left); gtk_widget_realize(area_top_right); GstBus* bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, area_top_right, NULL); gst_bus_add_signal_watch (bus); g_signal_connect(bus, "message::error", G_CALLBACK(end_stream_cb), pipeline); g_signal_connect(bus, "message::warning", G_CALLBACK(end_stream_cb), pipeline); g_signal_connect(bus, "message::eos", G_CALLBACK(end_stream_cb), pipeline); gst_object_unref (bus); //needed when being in GST_STATE_READY, GST_STATE_PAUSED //or resizing/obscuring the window g_signal_connect(area_top_left, "draw", G_CALLBACK(expose_cb), videosink); g_signal_connect(area_top_left, "configure-event", G_CALLBACK(resize_cb), videosink); g_signal_connect(area_top_right, "draw", G_CALLBACK(expose_cb), videosink); g_signal_connect(area_top_right, "configure-event", G_CALLBACK(resize_cb), videosink); //switch the drawing area g_signal_connect(area_top_left, "button-press-event", G_CALLBACK(on_click_drawing_area), videosink); g_signal_connect(area_top_right, "button-press-event", G_CALLBACK(on_click_drawing_area), videosink); gtk_widget_show_all (window); gst_element_set_state(pipeline, GST_STATE_PLAYING); gtk_main(); return 0; }
gint main (gint argc, gchar * argv[]) { GstStateChangeReturn ret; GstElement *pipeline; GstElement *uload, *filter, *sink; GstElement *sourcebin; GstBus *bus; GError *error = NULL; GtkWidget *window; GtkWidget *screen; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *play, *pause, *null, *ready; gchar **source_desc_array = NULL; gchar *source_desc = NULL; GOptionContext *context; GOptionEntry options[] = { {"source-bin", 's', 0, G_OPTION_ARG_STRING_ARRAY, &source_desc_array, "Use a custom source bin description (gst-launch style)", NULL} , {"method", 'm', 0, G_OPTION_ARG_INT, &method, "1 for gstdifferencematte, 2 for gloverlay", "M"} , {"delay", 'd', 0, G_OPTION_ARG_INT, &delay, "Wait N seconds before to send the image to gstreamer (useful with differencematte)", "N"} , {NULL} }; g_thread_init (NULL); context = g_option_context_new (NULL); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, gst_init_get_option_group ()); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("Inizialization error: %s\n", GST_STR_NULL (error->message)); return -1; } g_option_context_free (context); if (source_desc_array != NULL) { source_desc = g_strjoinv (" ", source_desc_array); g_strfreev (source_desc_array); } if (source_desc == NULL) { source_desc = g_strdup ("videotestsrc ! video/x-raw-rgb, width=352, height=288 ! identity"); } sourcebin = gst_parse_bin_from_description (g_strdup (source_desc), TRUE, &error); g_free (source_desc); if (error) { g_print ("Error while parsing source bin description: %s\n", GST_STR_NULL (error->message)); return -1; } g_set_application_name ("gst-gl-effects test app"); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 3); pipeline = gst_pipeline_new ("pipeline"); uload = gst_element_factory_make ("glupload", "glu"); if (method == 2) { filter = gst_element_factory_make ("gloverlay", "flt"); } else { filter = gst_element_factory_make ("gldifferencematte", "flt"); } sink = gst_element_factory_make ("glimagesink", "glsink"); gst_bin_add_many (GST_BIN (pipeline), sourcebin, uload, filter, sink, NULL); if (!gst_element_link_many (sourcebin, uload, filter, sink, NULL)) { g_print ("Failed to link one or more elements!\n"); return -1; } g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (destroy_cb), pipeline); g_signal_connect (G_OBJECT (window), "destroy-event", G_CALLBACK (destroy_cb), pipeline); screen = gtk_drawing_area_new (); gtk_widget_set_size_request (screen, 640, 480); // 500 x 376 vbox = gtk_vbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (vbox), screen, TRUE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 0); play = gtk_button_new_with_label ("PLAY"); g_signal_connect (G_OBJECT (play), "clicked", G_CALLBACK (play_cb), pipeline); pause = gtk_button_new_with_label ("PAUSE"); g_signal_connect (G_OBJECT (pause), "clicked", G_CALLBACK (pause_cb), pipeline); null = gtk_button_new_with_label ("NULL"); g_signal_connect (G_OBJECT (null), "clicked", G_CALLBACK (null_cb), pipeline); ready = gtk_button_new_with_label ("READY"); g_signal_connect (G_OBJECT (ready), "clicked", G_CALLBACK (ready_cb), pipeline); gtk_box_pack_start (GTK_BOX (hbox), null, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), ready, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), play, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), pause, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, screen); gst_object_unref (bus); g_signal_connect (screen, "expose-event", G_CALLBACK (expose_cb), sink); gtk_drag_dest_set (screen, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets (screen); g_signal_connect (screen, "drag-data-received", G_CALLBACK (on_drag_data_received), filter); ret = gst_element_set_state (pipeline, GST_STATE_PLAYING); if (ret == GST_STATE_CHANGE_FAILURE) { g_print ("Failed to start up pipeline!\n"); return -1; } gtk_widget_show_all (GTK_WIDGET (window)); gtk_main (); return 0; }
/** * Initialize components for gtk window */ static Win* create_ui () { Win* w = malloc(sizeof(Win)); /* create a new window */ w->main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* area that will display our stream */ w->video_window = gtk_drawing_area_new (); /* ===== framerate settings ===== */ w->framerate_field = gtk_entry_new(); /* connect button event to callback function */ w->framerate_send_button = gtk_button_new_with_label("Set FrameRate"); g_signal_connect (G_OBJECT (w->framerate_send_button), "clicked", G_CALLBACK (framerate_value_changed), w); /* ===== exposure scale ===== */ w->exposure_label = gtk_label_new("Exposure:"); gdouble value; g_object_get (G_OBJECT (p.source), "exposure", &value, NULL); w->exposure_value_label = gtk_label_new("0.0"); /* the label should give enough space to not rezise */ gtk_label_set_width_chars (GTK_LABEL(w->exposure_value_label), 10); /* the scale will have a range from 0 to 100 to use the percentage to implement a log scale */ double rmin = 0; double rmax = 100; double rangelen2 = log(rmax) - log(rmin); double exposure_value = (ABSVAL_SLIDER_TICKS) / rangelen2 * ( log(value) - log(rmin) ); gdouble exposure_lower = 0.0; /* min value */ gdouble exposure_upper = 100.0; /* max value */ gdouble exposure_step_increment = 1.0; /* step size */ gdouble exposure_page_increment = -10.0; /* negatic value, to make page up increase value */ gdouble exposure_page_size = 0.0; GtkObject* wat = gtk_adjustment_new ( exposure_value, exposure_lower, exposure_upper, exposure_step_increment, exposure_page_increment, exposure_page_size); w->exposure_hscale = gtk_hscale_new (GTK_ADJUSTMENT(wat)); gtk_scale_set_draw_value(GTK_SCALE (w->exposure_hscale), FALSE); gtk_widget_set_usize (GTK_WIDGET (w->exposure_hscale), 400, 30); g_signal_connect (G_OBJECT(wat), "value-changed", G_CALLBACK (exposure_value_changed), w); set_slider_label (GTK_LABEL(w->exposure_value_label), value); /* ===== gain part ===== */ w->gain_label = gtk_label_new("Gain:"); double gain_value; gdouble gain_lower; /* min value */ gdouble gain_upper; /* max value */ w->gain_value_label = gtk_label_new("0.0"); g_object_get (G_OBJECT (p.source), "gain", &gain_value, NULL); arv_camera_get_gain_bounds (p.camera, &gain_lower, &gain_upper); set_slider_label (GTK_LABEL(w->gain_value_label), gain_value); gdouble gain_step_increment = 0.1; /* step size */ gdouble gain_page_increment = -1.0; gdouble gain_page_size = 0.0; GtkObject* range_gain = gtk_adjustment_new (gain_value, gain_lower, gain_upper, gain_step_increment, gain_page_increment, gain_page_size); w->gain_hscale = gtk_hscale_new (GTK_ADJUSTMENT(range_gain)); gtk_scale_set_draw_value(GTK_SCALE (w->gain_hscale), FALSE); gtk_widget_set_usize (GTK_WIDGET (w->gain_hscale), 400, 50); g_signal_connect (G_OBJECT(range_gain), "value-changed", G_CALLBACK (gain_value_changed), w); GtkWidget* toggle; toggle = gtk_button_new_with_label("Start/Stop"); g_signal_connect (G_OBJECT (toggle), "clicked", G_CALLBACK (togglePipelineState), NULL); /* ===== organize everything and place in window ===== */ w->controls = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (w->controls), toggle, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->framerate_field, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->framerate_send_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->exposure_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->exposure_value_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->exposure_hscale, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->gain_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->gain_value_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->gain_hscale, FALSE, FALSE, 2); w->main_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (w->main_hbox), w->video_window, TRUE, TRUE, 0); w->main_box = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (w->main_box), w->main_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (w->main_box), w->controls, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (w->main_window), w->main_box); gtk_window_set_default_size (GTK_WINDOW (w->main_window), HEIGHT, WIDTH); /* show all widgets we just added to out main window */ gtk_widget_show_all (w->main_window); return w; }
void remmina_rdp_event_init(RemminaProtocolWidget* gp) { gchar* s; gint flags; rfContext* rfi; GtkClipboard* clipboard; rfi = GET_DATA(gp); rfi->drawing_area = gtk_drawing_area_new(); gtk_widget_show(rfi->drawing_area); gtk_container_add(GTK_CONTAINER(gp), rfi->drawing_area); gtk_widget_add_events(rfi->drawing_area, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_SCROLL_MASK | GDK_FOCUS_CHANGE_MASK); gtk_widget_set_can_focus(rfi->drawing_area, TRUE); remmina_plugin_service->protocol_plugin_register_hostkey(gp, rfi->drawing_area); s = remmina_plugin_service->pref_get_value("rdp_use_client_keymap"); rfi->use_client_keymap = (s && s[0] == '1' ? TRUE : FALSE); g_free(s); #if GTK_VERSION == 3 g_signal_connect(G_OBJECT(rfi->drawing_area), "draw", G_CALLBACK(remmina_rdp_event_on_draw), gp); #elif GTK_VERSION == 2 g_signal_connect(G_OBJECT(rfi->drawing_area), "expose-event", G_CALLBACK(remmina_rdp_event_on_expose), gp); #endif g_signal_connect(G_OBJECT(rfi->drawing_area), "configure-event", G_CALLBACK(remmina_rdp_event_on_configure), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "motion-notify-event", G_CALLBACK(remmina_rdp_event_on_motion), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "button-press-event", G_CALLBACK(remmina_rdp_event_on_button), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "button-release-event", G_CALLBACK(remmina_rdp_event_on_button), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "scroll-event", G_CALLBACK(remmina_rdp_event_on_scroll), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "key-press-event", G_CALLBACK(remmina_rdp_event_on_key), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "key-release-event", G_CALLBACK(remmina_rdp_event_on_key), gp); g_signal_connect(G_OBJECT(rfi->drawing_area), "focus-in-event", G_CALLBACK(remmina_rdp_event_on_focus_in), gp); RemminaFile* remminafile = remmina_plugin_service->protocol_plugin_get_file(gp); if (!remmina_plugin_service->file_get_int(remminafile, "disableclipboard", FALSE)) { clipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD); rfi->clipboard_handler = g_signal_connect(clipboard, "owner-change", G_CALLBACK(remmina_rdp_event_on_clipboard), gp); } rfi->pressed_keys = g_array_new(FALSE, TRUE, sizeof (gint)); rfi->event_queue = g_async_queue_new_full(g_free); rfi->ui_queue = g_async_queue_new(); if (pipe(rfi->event_pipe)) { g_print("Error creating pipes.\n"); rfi->event_pipe[0] = -1; rfi->event_pipe[1] = -1; } else { flags = fcntl(rfi->event_pipe[0], F_GETFL, 0); fcntl(rfi->event_pipe[0], F_SETFL, flags | O_NONBLOCK); } rfi->object_table = g_hash_table_new_full(NULL, NULL, NULL, g_free); rfi->display = gdk_display_get_default(); rfi->bpp = gdk_visual_get_best_depth(); }
static gboolean preview_cb (GtkPrintOperation *op, GtkPrintOperationPreview *preview, GtkPrintContext *context, GtkWindow *parent, gpointer data) { GtkPrintSettings *settings; GtkWidget *window, *close, *page, *hbox, *vbox, *da; gdouble width, height; cairo_t *cr; PreviewOp *pop; PrintData *print_data = data; pop = g_new0 (PreviewOp, 1); pop->data = print_data; settings = gtk_print_operation_get_print_settings (op); width = 200; height = 300; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (main_window)); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); page = gtk_spin_button_new_with_range (1, 100, 1); gtk_box_pack_start (GTK_BOX (hbox), page, FALSE, FALSE, 0); close = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_box_pack_start (GTK_BOX (hbox), close, FALSE, FALSE, 0); da = gtk_drawing_area_new (); gtk_widget_set_size_request (GTK_WIDGET (da), width, height); gtk_box_pack_start (GTK_BOX (vbox), da, TRUE, TRUE, 0); gtk_widget_set_double_buffered (da, FALSE); gtk_widget_realize (da); cr = gdk_cairo_create (da->window); /* TODO: What dpi to use here? This will be used for pagination.. */ gtk_print_context_set_cairo_context (context, cr, 72, 72); cairo_destroy (cr); pop->op = g_object_ref (op); pop->preview = preview; pop->spin = page; pop->area = da; pop->page = 1; g_signal_connect (page, "value-changed", G_CALLBACK (update_page), pop); g_signal_connect_swapped (close, "clicked", G_CALLBACK (gtk_widget_destroy), window); g_signal_connect (preview, "ready", G_CALLBACK (preview_ready), pop); g_signal_connect (preview, "got-page-size", G_CALLBACK (preview_got_page_size), pop); g_signal_connect (window, "destroy", G_CALLBACK (preview_destroy), pop); gtk_widget_show_all (window); return TRUE; }
int main(int argc, char **argv) { char *socketname = get_config_name("control"); /* check if japlay is already running */ if (socketname && file_exists(socketname)) { int fd = unix_socket_connect(socketname); if (fd >= 0) { int i; for (i = 1; i < argc; ++i) { char *path = absolute_path(argv[i]); if (path) { sendto(fd, path, strlen(path), 0, NULL, 0); free(path); } } close(fd); return 0; } /* remove leftover socket */ unlink(socketname); } g_thread_init(NULL); gdk_threads_init(); gdk_threads_enter(); gtk_init(&argc, &argv); main_thread = g_thread_self(); if (japlay_init(&argc, argv)) { error("Can not initialize japlay\n"); return -1; } main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), APP_NAME); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(destroy_cb), NULL); g_signal_connect(G_OBJECT(main_window), "key-press-event", G_CALLBACK(key_pressed_cb), NULL); GtkWidget *menubar = gtk_menu_bar_new(); GtkWidget *file_menu = gtk_menu_new(); GtkWidget *item = gtk_menu_item_new_with_label("New playlist"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(new_playlist_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("Add directory to the playlist..."); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(add_dir_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("Clear playlist"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(clear_playlist_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_check_menu_item_new_with_label("Enable shuffle"); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_shuffle_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_check_menu_item_new_with_label("Enable automatic volume"); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_autovol_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); /*item = gtk_menu_item_new_with_label("Scan playlist"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(scan_playlist_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item);*/ item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("Quit"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(destroy_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), file_menu); gtk_menu_bar_append(GTK_MENU_BAR(menubar), item); static const struct button { const char *stockid; const char *help; void (*const cb)(GtkButton *button, gpointer ptr); } buttons[] = { {GTK_STOCK_MEDIA_PLAY, "Play", play_cb}, {GTK_STOCK_MEDIA_STOP, "stop", stop_cb}, {GTK_STOCK_MEDIA_PAUSE, "Pause", pause_cb}, {GTK_STOCK_MEDIA_NEXT, "Skip to the next song in the queue", next_cb}, {GTK_STOCK_OPEN, "Add files to the playlist", add_cb}, {GTK_STOCK_OK, "Add selected songs to the queue", enqueue_cb}, {GTK_STOCK_DELETE, "Remove selected songs", remove_cb}, {NULL, NULL, NULL} }; GtkWidget *toolbar = gtk_hbox_new(false, 0); int i; for (i = 0; buttons[i].stockid; ++i) { GtkWidget *button = gtk_button_new(); GtkWidget *image = gtk_image_new_from_stock(buttons[i].stockid, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image(GTK_BUTTON(button), image); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(buttons[i].cb), NULL); gtk_box_pack_start(GTK_BOX(toolbar), button, false, true, 0); gtk_widget_set_tooltip_text(button, buttons[i].help); } scope_area = gtk_drawing_area_new(); gtk_widget_set_size_request(scope_area, SCOPE_WIDTH, -1); gtk_box_pack_start(GTK_BOX(toolbar), scope_area, false, true, 0); g_signal_connect(G_OBJECT(scope_area), "expose_event", G_CALLBACK(expose_event_cb), NULL); seekbar = gtk_hscale_new_with_range(0, 1, 1); gtk_range_set_update_policy(GTK_RANGE(seekbar), GTK_UPDATE_DELAYED); g_signal_connect(G_OBJECT(seekbar), "change-value", G_CALLBACK(seek_cb), NULL); g_signal_connect(G_OBJECT(seekbar), "format-value", G_CALLBACK(format_seek_cb), NULL); notebook = gtk_notebook_new(); GtkWidget *vbox = gtk_vbox_new(false, 0); gtk_box_pack_start(GTK_BOX(vbox), menubar, false, true, 0); gtk_box_pack_start(GTK_BOX(vbox), toolbar, false, true, 0); gtk_box_pack_start(GTK_BOX(vbox), seekbar, false, true, 0); gtk_box_pack_start(GTK_BOX(vbox), notebook, true, true, 0); gtk_container_add(GTK_CONTAINER(main_window), vbox); gtk_widget_show_all(main_window); /* TODO: load all playlists */ main_playlist = new_playlist(); add_playlist_page(main_playlist, "Main"); add_playlist_page(japlay_queue, "Play queue"); add_playlist_page(japlay_history, "History"); char *playlistpath = get_config_name("main_playlist.m3u"); if (playlistpath) load_playlist(main_playlist, playlistpath); char *queuepath = get_config_name("queue.m3u"); if (queuepath) load_playlist(japlay_queue, queuepath); char *settingspath = get_config_name("settings.cfg"); if (settingspath) load_settings(settingspath); for (i = 1; i < argc; ++i) add_file_playlist(main_playlist, argv[i]); signal(SIGINT, handle_sigint); int fd = -1; if (socketname) { fd = unix_socket_create(socketname); if (fd >= 0) { GIOChannel *io = g_io_channel_unix_new(fd); g_io_add_watch(io, G_IO_IN, incoming_client, NULL); } } gtk_main(); if (fd >= 0) unlink(socketname); if (playlistpath) save_playlist_m3u(main_playlist, playlistpath); if (queuepath) save_playlist_m3u(japlay_queue, queuepath); if (settingspath) save_settings(settingspath); japlay_exit(); return 0; }
int dt_view_manager_switch (dt_view_manager_t *vm, int k) { // Before switching views, restore accelerators if disabled if(!darktable.control->key_accelerators_on) dt_control_key_accelerators_on(darktable.control); // destroy old module list int error = 0; dt_view_t *v = vm->view + vm->current_view; /* Special case when entering nothing (just before leaving dt) */ if ( k==DT_MODE_NONE ) { /* iterator plugins and cleanup plugins in current view */ GList *plugins = g_list_last(darktable.lib->plugins); while (plugins) { dt_lib_module_t *plugin = (dt_lib_module_t *)(plugins->data); if (!plugin->views) fprintf(stderr,"module %s doesnt have views flags\n",plugin->name()); /* does this module belong to current view ?*/ if (plugin->views() & v->view(v) ) { plugin->gui_cleanup(plugin); dt_accel_disconnect_list(plugin->accel_closures); plugin->accel_closures = NULL; } /* get next plugin */ plugins = g_list_previous(plugins); } /* leave the current view*/ if(vm->current_view >= 0 && v->leave) v->leave(v); /* remove all widets in all containers */ for(int l=0;l<DT_UI_CONTAINER_SIZE;l++) dt_ui_container_clear(darktable.gui->ui, l); vm->current_view = -1 ; return 0 ; } int newv = vm->current_view; if (k < vm->num_views) newv = k; dt_view_t *nv = vm->view + newv; if (nv->try_enter) error = nv->try_enter(nv); if (!error) { GList *plugins; /* cleanup current view before initialization of new */ if (vm->current_view >=0) { /* leave current view */ if(v->leave) v->leave(v); dt_accel_disconnect_list(v->accel_closures); v->accel_closures = NULL; /* iterator plugins and cleanup plugins in current view */ plugins = g_list_last(darktable.lib->plugins); while (plugins) { dt_lib_module_t *plugin = (dt_lib_module_t *)(plugins->data); if (!plugin->views) fprintf(stderr,"module %s doesnt have views flags\n",plugin->name()); /* does this module belong to current view ?*/ if (plugin->views() & v->view(v) ) { plugin->gui_cleanup(plugin); dt_accel_disconnect_list(plugin->accel_closures); plugin->accel_closures = NULL; } /* get next plugin */ plugins = g_list_previous(plugins); } /* remove all widets in all containers */ for(int l=0;l<DT_UI_CONTAINER_SIZE;l++) dt_ui_container_clear(darktable.gui->ui, l); } /* change current view to the new view */ vm->current_view = newv; /* restore visible stat of panels for the new view */ dt_ui_restore_panels(darktable.gui->ui); /* lets add plugins related to new view into panels */ plugins = g_list_last(darktable.lib->plugins); while (plugins) { dt_lib_module_t *plugin = (dt_lib_module_t *)(plugins->data); if( plugin->views() & nv->view(v) ) { /* module should be in this view, lets initialize */ plugin->gui_init(plugin); /* try get the module expander */ GtkWidget *w = NULL; w = dt_lib_gui_get_expander(plugin); if(plugin->connect_key_accels) plugin->connect_key_accels(plugin); dt_lib_connect_common_accels(plugin); /* if we dont got an expander lets add the widget */ if (!w) w = plugin->widget; /* add module to it's container */ dt_ui_container_add_widget(darktable.gui->ui, plugin->container(), w); } /* lets get next plugin */ plugins = g_list_previous(plugins); } /* hide/show modules as last config */ plugins = g_list_last(darktable.lib->plugins); while (plugins) { dt_lib_module_t *plugin = (dt_lib_module_t *)(plugins->data); if(plugin->views() & nv->view(v)) { /* set expanded if last mode was that */ char var[1024]; gboolean expanded = FALSE; gboolean visible = dt_lib_is_visible(plugin); if (plugin->expandable()) { snprintf(var, 1024, "plugins/lighttable/%s/expanded", plugin->plugin_name); expanded = dt_conf_get_bool(var); /* show expander if visible */ if(visible) { gtk_widget_show_all(GTK_WIDGET(plugin->expander)); // gtk_widget_show_all(plugin->widget); } else { gtk_widget_hide(GTK_WIDGET(plugin->expander)); // gtk_widget_hide_all(plugin->widget); } dt_lib_gui_set_expanded(plugin, expanded); } else { /* show/hide plugin widget depending on expanded flag or if plugin not is expandeable() */ if(visible) gtk_widget_show_all(plugin->widget); else gtk_widget_hide_all(plugin->widget); } } /* lets get next plugin */ plugins = g_list_previous(plugins); } /* enter view. crucially, do this before initing the plugins below, as e.g. modulegroups requires the dr stuff to be inited. */ if(newv >= 0 && nv->enter) nv->enter(nv); if(newv >= 0 && nv->connect_key_accels) nv->connect_key_accels(nv); /* raise view changed signal */ dt_control_signal_raise(darktable.signals, DT_SIGNAL_VIEWMANAGER_VIEW_CHANGED); /* add endmarkers to left and right center containers */ GtkWidget *endmarker = gtk_drawing_area_new(); dt_ui_container_add_widget(darktable.gui->ui, DT_UI_CONTAINER_PANEL_LEFT_CENTER, endmarker); g_signal_connect (G_OBJECT (endmarker), "expose-event", G_CALLBACK (dt_control_expose_endmarker), 0); gtk_widget_set_size_request(endmarker, -1, 50); gtk_widget_show(endmarker); endmarker = gtk_drawing_area_new(); dt_ui_container_add_widget(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER, endmarker); g_signal_connect (G_OBJECT (endmarker), "expose-event", G_CALLBACK (dt_control_expose_endmarker), (gpointer)1); gtk_widget_set_size_request(endmarker, -1, 50); gtk_widget_show(endmarker); } return error; }
static void main_window_init(MainWindow *wnd) { GdkRGBA vid_area_bg_color; wnd->fullscreen = FALSE; wnd->playlist_visible = FALSE; wnd->playlist_width = PLAYLIST_DEFAULT_WIDTH; wnd->timeout_tag = 0; wnd->settings = gtk_settings_get_default(); wnd->header_bar = gtk_header_bar_new(); wnd->open_hdr_btn = NULL; wnd->fullscreen_hdr_btn = NULL; wnd->menu_hdr_btn = NULL; wnd->main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); wnd->vid_area_paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); wnd->vid_area = gtk_drawing_area_new(); wnd->fs_control = gtk_window_new(GTK_WINDOW_POPUP); wnd->control_box = control_box_new(); wnd->playlist = playlist_widget_new(); gdk_rgba_parse(&vid_area_bg_color, VID_AREA_BG_COLOR); gtk_widget_add_events( wnd->fs_control, GDK_ENTER_NOTIFY_MASK |GDK_LEAVE_NOTIFY_MASK ); gtk_widget_add_events(wnd->vid_area, GDK_BUTTON_PRESS_MASK); gtk_header_bar_set_show_close_button( GTK_HEADER_BAR(wnd->header_bar), TRUE ); gtk_window_set_title(GTK_WINDOW(wnd), g_get_application_name()); gtk_paned_set_position( GTK_PANED(wnd->vid_area_paned), MAIN_WINDOW_DEFAULT_WIDTH -PLAYLIST_DEFAULT_WIDTH ); gtk_window_set_default_size( GTK_WINDOW(wnd), MAIN_WINDOW_DEFAULT_WIDTH, MAIN_WINDOW_DEFAULT_HEIGHT ); gtk_widget_override_background_color( wnd->vid_area, GTK_STATE_NORMAL, &vid_area_bg_color); gtk_box_pack_start (GTK_BOX(wnd->main_box), wnd->vid_area_paned, TRUE, TRUE, 0); gtk_paned_pack1 (GTK_PANED(wnd->vid_area_paned), wnd->vid_area, TRUE, TRUE); gtk_paned_pack2 (GTK_PANED(wnd->vid_area_paned), wnd->playlist, FALSE, TRUE); gtk_container_add (GTK_CONTAINER(wnd->main_box), wnd->control_box); gtk_container_add (GTK_CONTAINER(wnd), wnd->main_box); g_signal_connect( wnd, "focus-in-event", G_CALLBACK(focus_in_handler), wnd ); g_signal_connect( wnd, "focus-out-event", G_CALLBACK(focus_out_handler), wnd ); g_signal_connect( wnd->fs_control, "enter-notify-event", G_CALLBACK(fs_control_enter_handler), wnd->fs_control ); g_signal_connect( wnd->fs_control, "leave-notify-event", G_CALLBACK(fs_control_leave_handler), wnd->fs_control ); g_signal_connect( wnd, "motion-notify-event", G_CALLBACK(motion_notify_handler), wnd ); }
void ags_note_edit_init(AgsNoteEdit *note_edit) { GtkAdjustment *adjustment; note_edit->flags = 0; note_edit->ruler = ags_ruler_new(); gtk_table_attach(GTK_TABLE(note_edit), (GtkWidget *) note_edit->ruler, 0, 1, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); note_edit->drawing_area = (GtkDrawingArea *) gtk_drawing_area_new(); gtk_widget_set_style((GtkWidget *) note_edit->drawing_area, note_edit_style); gtk_widget_set_events (GTK_WIDGET (note_edit->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 ); gtk_table_attach(GTK_TABLE(note_edit), (GtkWidget *) note_edit->drawing_area, 0, 1, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); note_edit->control.note = ags_note_new(); note_edit->width = 0; note_edit->height = 0; note_edit->map_width = AGS_NOTE_EDIT_MAX_CONTROLS * 64; note_edit->map_height = 78; note_edit->control_height = 14; note_edit->control_margin_y = 2; note_edit->control_width = 16; note_edit->y0 = 0; note_edit->y1 = 0; note_edit->nth_y = 0; note_edit->stop_y = 0; /* AgsNoteEditControlCurrent is used by ags_note_edit_draw_segment */ note_edit->control_current.control_count = AGS_NOTE_EDIT_MAX_CONTROLS; note_edit->control_current.control_width = 64; note_edit->control_current.x0 = 0; note_edit->control_current.x1 = 0; note_edit->control_current.nth_x = 0; /* AgsNoteEditControlUnit is used by ags_note_edit_draw_notation */ note_edit->control_unit.control_count = 16 * AGS_NOTE_EDIT_MAX_CONTROLS; note_edit->control_unit.control_width = 1 * 4; note_edit->control_unit.x0 = 0; note_edit->control_unit.x1 = 0; note_edit->control_unit.nth_x = 0; note_edit->control_unit.stop_x = 0; /* offset for pasting from clipboard */ note_edit->selected_x = 0; note_edit->selected_y = 0; /* GtkScrollbars */ adjustment = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 1.0, 1.0, 1.0, 1.0); note_edit->vscrollbar = (GtkVScrollbar *) gtk_vscrollbar_new(adjustment); gtk_table_attach(GTK_TABLE(note_edit), (GtkWidget *) note_edit->vscrollbar, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); adjustment = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 1.0, 1.0, 1.0, 1.0); note_edit->hscrollbar = (GtkHScrollbar *) gtk_hscrollbar_new(adjustment); gtk_table_attach(GTK_TABLE(note_edit), (GtkWidget *) note_edit->hscrollbar, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); }
int main (int argc,char *argv[]) { Persona p; Familia f; open_file(&p,&f); make_tree(&f); set_position(&f); GtkWidget *window; GtkWidget *paned_container_horizontal; GtkWidget *paned_container_vertical; GtkWidget *fixed_container; GtkWidget *list_container; GtkWidget *drawing_area; GtkWidget *scroll_draw_zone; GtkWidget *scroll_tree_zone; GtkWidget *scroll_list_zone; GtkWidget *memberTextArea; GtkWidget *tree_box; GtkWidget *list_box; gtk_init (&argc, &argv); // Configuracion de Ventana main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = main_window; config_window(GTK_WINDOW(window),WIDTH,HEIGHT,"Arbol Genealogico",TRUE); // Configuracion de ventana que muestra los datos de las familias // Configuracion de Container paned_container_horizontal = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); paned_container_vertical = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER (window), 0); gtk_container_add (GTK_CONTAINER (window), paned_container_horizontal); fixed_container = gtk_fixed_new(); list_container = gtk_fixed_new(); drawing_area = gtk_drawing_area_new(); gtk_widget_set_size_request (GTK_WIDGET(drawing_area), 2000, 2000); scroll_draw_zone = gtk_scrolled_window_new(NULL, NULL); scroll_list_zone = gtk_scrolled_window_new(NULL, NULL); scroll_tree_zone = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW(scroll_draw_zone),800); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scroll_draw_zone),600 - 50); gtk_fixed_put(GTK_FIXED(fixed_container), GTK_WIDGET(scroll_draw_zone), 0, 20); gtk_fixed_put(GTK_FIXED(list_container), GTK_WIDGET(scroll_draw_zone), 0, 0); // Se configura la caja que contiene a las familias tree_box = setup_tree("FAMILIAS"); add_family_to_list(tree_box,&f); // Se configura la caja que muestr a las personas list_box = setup_tree("PERSONAS"); add_member_to_list(list_box,&p); gtk_container_add(GTK_CONTAINER(scroll_draw_zone), GTK_WIDGET(drawing_area)); gtk_container_add(GTK_CONTAINER(scroll_tree_zone), GTK_WIDGET(tree_box)); gtk_container_add(GTK_CONTAINER(scroll_list_zone), GTK_WIDGET(list_box)); // Se agregan los elementos a la ventana gtk_paned_add1(GTK_PANED(paned_container_vertical),scroll_tree_zone); gtk_paned_add2(GTK_PANED(paned_container_vertical),scroll_list_zone); gtk_paned_add1(GTK_PANED(paned_container_horizontal),paned_container_vertical); gtk_paned_add2(GTK_PANED(paned_container_horizontal),fixed_container); // se conecta la senial "destroy" con la funcion gtk_main_quit g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(drawing_area), "draw", G_CALLBACK(draw_tree), &f); g_signal_connect(G_OBJECT(tree_box), "row-activated", G_CALLBACK(show_family_info),GTK_WINDOW(window)); g_signal_connect(G_OBJECT(list_box), "row-activated", G_CALLBACK(show_member_info),NULL); // los widget GTK estan escondidos por defecto, con esto los volvemos visibles gtk_widget_show_all (window); gtk_main (); return 0; }
void gui_init (gui *g) { g->poly = poly_new (); g->selected = NULL; g->hovered = NULL; g->gc = NULL; g->canvas = NULL; g->pixmap = NULL; g->ctrl = false; g->pix_w = 0; g->pix_h = 0; /* Main window */ g->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (g->window, "[:Polytool:]"); /* Widget creation */ g->vbox = gtk_vbox_new (false, 0); g->box = gtk_hbox_new (false, 4); g->status = gtk_statusbar_new (); g->draw_zone = gtk_drawing_area_new (); /* Context menu */ g->menu = gtk_menu_new (); g->m_split = gtk_menu_item_new_with_label ("Split left/right chains"); g->m_mtr = gtk_menu_item_new_with_label ("Triangulate (monotone)"); g->m_rtr = gtk_menu_item_new_with_label ("Triangulate (generic)"); g->m_hull = gtk_menu_item_new_with_label ("Convex hull (Graham)"); g->m_sep1 = gtk_separator_menu_item_new (); g->m_clear = gtk_menu_item_new_with_label ("Clear"); g->m_draw = gtk_menu_item_new_with_label ("Redraw"); g->m_sep2 = gtk_separator_menu_item_new (); g->m_quit = gtk_menu_item_new_with_label ("Quit"); gtk_menu_append (g->menu, g->m_split); gtk_menu_append (g->menu, g->m_mtr); gtk_menu_append (g->menu, g->m_rtr); gtk_menu_append (g->menu, g->m_hull); gtk_menu_append (g->menu, g->m_sep1); gtk_menu_append (g->menu, g->m_clear); gtk_menu_append (g->menu, g->m_draw); gtk_menu_append (g->menu, g->m_sep2); gtk_menu_append (g->menu, g->m_quit); gtk_widget_show_all (g->menu); /* Drawing area */ gtk_drawing_area_size (g->draw_zone, 200, 200); gtk_widget_set_events (g->draw_zone, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); /* Packing */ gtk_container_set_border_width (g->box, 4); gtk_box_pack_start (g->box, g->draw_zone, true, true, 0); gtk_box_pack_start (g->vbox, g->box, true, true, 0); gtk_box_pack_start (g->vbox, g->status, false, false, 0); gtk_container_add (g->window, g->vbox); g->cid = gtk_statusbar_get_context_id (g->status, "default"); gui_connect_signals (g); }
GtkWidget * do_colorsel (GtkWidget *do_widget) { GtkWidget *vbox; GtkWidget *button; GtkWidget *alignment; if (!window) { color.red = 0; color.blue = 65535; color.green = 0; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Color Selection"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); /* * Create the color swatch area */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); da = gtk_drawing_area_new (); g_signal_connect (da, "expose_event", G_CALLBACK (expose_event_callback), NULL); /* set a minimum size */ gtk_widget_set_size_request (da, 200, 200); /* set the color */ gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &color); gtk_container_add (GTK_CONTAINER (frame), da); alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0); button = gtk_button_new_with_mnemonic ("_Change the above color"); gtk_container_add (GTK_CONTAINER (alignment), button); gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (change_color_callback), NULL); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
static void create_window (GdkWindowHints mask) { GtkWidget *window; GtkWidget *drawing_area; GtkWidget *grid; GtkWidget *label; GtkWidget *button; GdkGeometry geometry; GString *label_text = g_string_new (NULL); int border = 0; if ((mask & GDK_HINT_RESIZE_INC) != 0) g_string_append (label_text, "Gridded\n"); if ((mask & GDK_HINT_BASE_SIZE) != 0) g_string_append (label_text, "Base\n"); if ((mask & GDK_HINT_MIN_SIZE) != 0) { g_string_append (label_text, "Minimum\n"); if ((mask & GDK_HINT_BASE_SIZE) == 0) g_string_append (label_text, "(base=min)\n"); } if ((mask & GDK_HINT_MAX_SIZE) != 0) g_string_append (label_text, "Maximum\n"); if (label_text->len > 0) g_string_erase (label_text, label_text->len - 1, 1); else g_string_append (label_text, "No Options"); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (on_window_destroy), NULL); grid = gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (grid), 10); label = gtk_label_new (label_text->str); gtk_widget_set_hexpand (label, TRUE); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); label = gtk_label_new ("A\nB\nC\nD\nE"); gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1); drawing_area = gtk_drawing_area_new (); g_signal_connect (drawing_area, "draw", G_CALLBACK (on_drawing_area_draw), GUINT_TO_POINTER (mask)); gtk_widget_set_hexpand (drawing_area, TRUE); gtk_widget_set_vexpand (drawing_area, TRUE); gtk_grid_attach (GTK_GRID (grid), drawing_area, 0, 1, 1, 1); button = gtk_button_new_with_label ("Resize"); g_signal_connect (button, "clicked", G_CALLBACK (on_resize_clicked), GUINT_TO_POINTER (mask)); gtk_widget_set_hexpand (button, TRUE); gtk_grid_attach (GTK_GRID (grid), button, 0, 2, 1, 1); gtk_container_add (GTK_CONTAINER (window), grid); if ((mask & GDK_HINT_BASE_SIZE) != 0) { border = BORDER; geometry.base_width = border * 2; geometry.base_height = border * 2; } if ((mask & GDK_HINT_RESIZE_INC) != 0) { geometry.width_inc = GRID_SIZE; geometry.height_inc = GRID_SIZE; } if ((mask & GDK_HINT_MIN_SIZE) != 0) { geometry.min_width = 5 * GRID_SIZE + 2 * border; geometry.min_height = 5 * GRID_SIZE + 2 * border; } if ((mask & GDK_HINT_MAX_SIZE) != 0) { geometry.max_width = 15 * GRID_SIZE + 2 * border; geometry.max_height = 15 * GRID_SIZE + 2 * border; } /* Contents must be set up before gtk_window_parse_geometry() */ gtk_widget_show_all (grid); gtk_window_set_geometry_hints (GTK_WINDOW (window), drawing_area, &geometry, mask); if ((mask & GDK_HINT_RESIZE_INC) != 0) { if (geometry_string) gtk_window_parse_geometry (GTK_WINDOW (window), geometry_string); else gtk_window_set_default_geometry (GTK_WINDOW (window), 10, 10); } else { gtk_window_set_default_geometry (GTK_WINDOW (window), 10 * GRID_SIZE, 10 * GRID_SIZE); } gtk_widget_show (window); window_count++; }
/** * @brief Build the GUI * * @return */ GtkWidget* buildVfoUI() { GtkWidget* label; vfoFixed=gtk_fixed_new(); //gtk_widget_modify_bg(vfoFixed,GTK_STATE_NORMAL,&background); // vfoA vfoAFrame=gtk_frame_new("VFO A"); label=gtk_frame_get_label_widget((GtkFrame*)vfoAFrame); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(vfoAFrame),258,40); #else gtk_widget_set_size_request(GTK_WIDGET(vfoAFrame),300,80); #endif vfoAFrequency=gtk_drawing_area_new(); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(vfoAFrequency),240,75); #else //gtk_widget_set_size_request(GTK_WIDGET(vfoAFrequency),250,35); #endif g_signal_connect(G_OBJECT (vfoAFrequency),"configure_event",G_CALLBACK(vfoAFrequency_configure_event),NULL); g_signal_connect(G_OBJECT (vfoAFrequency),"expose_event",G_CALLBACK(vfoAFrequency_expose_event),NULL); g_signal_connect(G_OBJECT(vfoAFrequency),"scroll_event",G_CALLBACK(frequency_scroll_event),NULL); gtk_widget_set_events(vfoAFrequency,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK); gtk_widget_show(vfoAFrequency); gtk_widget_show(vfoAFrame); gtk_container_add((GtkContainer*)vfoAFrame,vfoAFrequency); gtk_fixed_put((GtkFixed*)vfoFixed,vfoAFrame,0,0); // vfoB vfoBFrame=gtk_frame_new("VFO B"); label=gtk_frame_get_label_widget((GtkFrame*)vfoBFrame); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(vfoBFrame),258,40); #else gtk_widget_set_size_request(GTK_WIDGET(vfoBFrame),300,80); #endif vfoBFrequency=gtk_drawing_area_new(); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(vfoBFrequency),240,35); #else //gtk_widget_set_size_request(GTK_WIDGET(vfoBFrequency),300,35); #endif g_signal_connect(G_OBJECT (vfoBFrequency),"configure_event",G_CALLBACK(vfoBFrequency_configure_event),NULL); g_signal_connect(G_OBJECT (vfoBFrequency),"expose_event",G_CALLBACK(vfoBFrequency_expose_event),NULL); g_signal_connect(G_OBJECT(vfoBFrequency),"scroll_event",G_CALLBACK(frequency_scroll_event),NULL); gtk_widget_set_events(vfoBFrequency,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK); gtk_widget_show(vfoBFrequency); gtk_widget_show(vfoBFrame); gtk_container_add((GtkContainer*)vfoBFrame,vfoBFrequency); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,vfoBFrame,456,0); #else gtk_fixed_put((GtkFixed*)vfoFixed,vfoBFrame,500,0); #endif // vfo control vfoControlFrame=gtk_frame_new(NULL); buttonAtoB = gtk_button_new_with_label ("A>B"); //gtk_widget_modify_bg(buttonAtoB, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonAtoB); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonAtoB),50,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonAtoB),45,25); #endif g_signal_connect(G_OBJECT(buttonAtoB),"clicked",G_CALLBACK(vfoCallback),NULL); gtk_widget_show(buttonAtoB); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonAtoB,258,0); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonAtoB,300,0); #endif buttonAswapB = gtk_button_new_with_label ("A<>B"); //gtk_widget_modify_bg(buttonAswapB, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonAswapB); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonAswapB),49,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonAswapB),60,25); #endif g_signal_connect(G_OBJECT(buttonAswapB),"clicked",G_CALLBACK(vfoCallback),NULL); gtk_widget_show(buttonAswapB); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonAswapB,308,0); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonAswapB,345,0); #endif buttonBtoA = gtk_button_new_with_label ("A<B"); //gtk_widget_modify_bg(buttonBtoA, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonBtoA); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonBtoA),49,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonBtoA),45,25); #endif g_signal_connect(G_OBJECT(buttonBtoA),"clicked",G_CALLBACK(vfoCallback),NULL); gtk_widget_show(buttonBtoA); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonBtoA,357,0); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonBtoA,405,0); #endif buttonSplit = gtk_button_new_with_label ("Split"); //gtk_widget_modify_bg(buttonSplit, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonSplit); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonSplit),50,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonSplit),50,25); #endif g_signal_connect(G_OBJECT(buttonSplit),"clicked",G_CALLBACK(vfoCallback),NULL); gtk_widget_show(buttonSplit); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonSplit,406,0); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonSplit,450,0); #endif buttonFrequencyUp = gtk_button_new_with_label ("^"); //gtk_widget_modify_bg(buttonFrequencyUp, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonFrequencyUp); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyUp),30,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyUp),30,25); #endif g_signal_connect(G_OBJECT(buttonFrequencyUp),"pressed",G_CALLBACK(frequencyUpCallback),NULL); g_signal_connect(G_OBJECT(buttonFrequencyUp),"released",G_CALLBACK(frequencyReleasedCallback),NULL); gtk_widget_show(buttonFrequencyUp); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyUp,258,20); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyUp,300,25); #endif buttonIncrementPlus = gtk_button_new_with_label ("+"); //gtk_widget_modify_bg(buttonIncrementPlus, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonIncrementPlus); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementPlus),20,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementPlus),20,25); #endif g_signal_connect(G_OBJECT(buttonIncrementPlus),"clicked",G_CALLBACK(buttonIncrementPlusCallback),NULL); gtk_widget_show(buttonIncrementPlus); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementPlus,288,20); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementPlus,330,25); #endif incrementDisplay=gtk_drawing_area_new(); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(incrementDisplay),98,20); #else gtk_widget_set_size_request(GTK_WIDGET(incrementDisplay),100,25); #endif gtk_widget_show(incrementDisplay); g_signal_connect(G_OBJECT (incrementDisplay),"configure_event",G_CALLBACK(incrementDisplay_configure_event),NULL); g_signal_connect(G_OBJECT (incrementDisplay),"expose_event",G_CALLBACK(incrementDisplay_expose_event),NULL); g_signal_connect(G_OBJECT(incrementDisplay),"scroll_event",G_CALLBACK(increment_scroll_event),NULL); gtk_widget_set_events(incrementDisplay,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK); gtk_widget_show(incrementDisplay); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,incrementDisplay,308,20); #else gtk_fixed_put((GtkFixed*)vfoFixed,incrementDisplay,350,25); #endif buttonIncrementMinus = gtk_button_new_with_label ("-"); //gtk_widget_modify_bg(buttonIncrementMinus, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonIncrementMinus); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementMinus),20,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementMinus),20,25); #endif g_signal_connect(G_OBJECT(buttonIncrementMinus),"clicked",G_CALLBACK(buttonIncrementMinusCallback),NULL); gtk_widget_show(buttonIncrementMinus); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementMinus,406,20); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementMinus,450,25); #endif buttonFrequencyDown = gtk_button_new_with_label ("v"); //gtk_widget_modify_bg(buttonFrequencyDown, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonFrequencyDown); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyDown),30,20); #else gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyDown),30,25); #endif g_signal_connect(G_OBJECT(buttonFrequencyDown),"pressed",G_CALLBACK(frequencyDownCallback),NULL); g_signal_connect(G_OBJECT(buttonFrequencyDown),"released",G_CALLBACK(frequencyReleasedCallback),NULL); gtk_widget_show(buttonFrequencyDown); #ifdef NETBOOK gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyDown,426,20); #else gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyDown,470,25); #endif #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(vfoFixed),714,40); #else gtk_widget_set_size_request(GTK_WIDGET(vfoFixed),800,50); #endif gtk_widget_show(vfoFixed); return vfoFixed; }
static void pidgin_media_ready_cb(PurpleMedia *media, PidginMedia *gtkmedia, const gchar *sid) { GtkWidget *send_widget = NULL, *recv_widget = NULL, *button_widget = NULL; PurpleMediaSessionType type = purple_media_get_session_type(media, sid); GdkPixbuf *icon = NULL; if (gtkmedia->priv->recv_widget == NULL && type & (PURPLE_MEDIA_RECV_VIDEO | PURPLE_MEDIA_RECV_AUDIO)) { recv_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display), recv_widget, TRUE, TRUE, 0); gtk_widget_show(recv_widget); } else { recv_widget = gtkmedia->priv->recv_widget; } if (gtkmedia->priv->send_widget == NULL && type & (PURPLE_MEDIA_SEND_VIDEO | PURPLE_MEDIA_SEND_AUDIO)) { send_widget = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(gtkmedia->priv->display), send_widget, FALSE, TRUE, 0); button_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_end(GTK_BOX(recv_widget), button_widget, FALSE, TRUE, 0); gtk_widget_show(send_widget); /* Hold button */ gtkmedia->priv->hold = gtk_toggle_button_new_with_mnemonic("_Hold"); gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->hold, FALSE, FALSE, 0); gtk_widget_show(gtkmedia->priv->hold); g_signal_connect(gtkmedia->priv->hold, "toggled", G_CALLBACK(pidgin_media_hold_toggled), gtkmedia); } else { send_widget = gtkmedia->priv->send_widget; button_widget = gtkmedia->priv->button_widget; } if (type & PURPLE_MEDIA_RECV_VIDEO) { PidginMediaRealizeData *data; GtkWidget *aspect; GtkWidget *remote_video; GdkColor color = {0, 0, 0, 0}; aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, FALSE); gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(recv_widget), aspect, TRUE, TRUE, 0); data = g_new0(PidginMediaRealizeData, 1); data->gtkmedia = gtkmedia; data->session_id = g_strdup(sid); data->participant = g_strdup(gtkmedia->priv->screenname); remote_video = gtk_drawing_area_new(); gtk_widget_modify_bg(remote_video, GTK_STATE_NORMAL, &color); g_signal_connect(G_OBJECT(remote_video), "realize", G_CALLBACK(realize_cb), data); gtk_container_add(GTK_CONTAINER(aspect), remote_video); gtk_widget_set_size_request (GTK_WIDGET(remote_video), 320, 240); gtk_widget_show(remote_video); gtk_widget_show(aspect); gtkmedia->priv->remote_video = remote_video; } if (type & PURPLE_MEDIA_SEND_VIDEO) { PidginMediaRealizeData *data; GtkWidget *aspect; GtkWidget *local_video; GdkColor color = {0, 0, 0, 0}; aspect = gtk_aspect_frame_new(NULL, 0, 0, 4.0/3.0, TRUE); gtk_frame_set_shadow_type(GTK_FRAME(aspect), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(send_widget), aspect, FALSE, TRUE, 0); data = g_new0(PidginMediaRealizeData, 1); data->gtkmedia = gtkmedia; data->session_id = g_strdup(sid); data->participant = NULL; local_video = gtk_drawing_area_new(); gtk_widget_modify_bg(local_video, GTK_STATE_NORMAL, &color); g_signal_connect(G_OBJECT(local_video), "realize", G_CALLBACK(realize_cb), data); gtk_container_add(GTK_CONTAINER(aspect), local_video); gtk_widget_set_size_request (GTK_WIDGET(local_video), 80, 60); gtk_widget_show(local_video); gtk_widget_show(aspect); gtkmedia->priv->pause = gtk_toggle_button_new_with_mnemonic(_("_Pause")); gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->pause, FALSE, FALSE, 0); gtk_widget_show(gtkmedia->priv->pause); g_signal_connect(gtkmedia->priv->pause, "toggled", G_CALLBACK(pidgin_media_pause_toggled), gtkmedia); gtkmedia->priv->local_video = local_video; } if (type & PURPLE_MEDIA_RECV_AUDIO) { gtk_box_pack_end(GTK_BOX(recv_widget), pidgin_media_add_audio_widget(gtkmedia, PURPLE_MEDIA_RECV_AUDIO), FALSE, FALSE, 0); } if (type & PURPLE_MEDIA_SEND_AUDIO) { gtkmedia->priv->mute = gtk_toggle_button_new_with_mnemonic("_Mute"); gtk_box_pack_end(GTK_BOX(button_widget), gtkmedia->priv->mute, FALSE, FALSE, 0); gtk_widget_show(gtkmedia->priv->mute); g_signal_connect(gtkmedia->priv->mute, "toggled", G_CALLBACK(pidgin_media_mute_toggled), gtkmedia); gtk_box_pack_end(GTK_BOX(recv_widget), pidgin_media_add_audio_widget(gtkmedia, PURPLE_MEDIA_SEND_AUDIO), FALSE, FALSE, 0); } if (type & PURPLE_MEDIA_AUDIO && gtkmedia->priv->level_handler_id == 0) { gtkmedia->priv->level_handler_id = g_signal_connect( media, "level", G_CALLBACK(level_message_cb), gtkmedia); } if (send_widget != NULL) gtkmedia->priv->send_widget = send_widget; if (recv_widget != NULL) gtkmedia->priv->recv_widget = recv_widget; if (button_widget != NULL) { gtkmedia->priv->button_widget = button_widget; gtk_widget_show(GTK_WIDGET(button_widget)); } if (purple_media_is_initiator(media, sid, NULL) == FALSE) { if (gtkmedia->priv->timeout_id != 0) g_source_remove(gtkmedia->priv->timeout_id); gtkmedia->priv->request_type |= type; gtkmedia->priv->timeout_id = g_timeout_add(500, (GSourceFunc)pidgin_request_timeout_cb, gtkmedia); } /* set the window icon according to the type */ if (type & PURPLE_MEDIA_VIDEO) { icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia), PIDGIN_STOCK_TOOLBAR_VIDEO_CALL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL); } else if (type & PURPLE_MEDIA_AUDIO) { icon = gtk_widget_render_icon(GTK_WIDGET(gtkmedia), PIDGIN_STOCK_TOOLBAR_AUDIO_CALL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), NULL); } if (icon) { gtk_window_set_icon(GTK_WINDOW(gtkmedia), icon); g_object_unref(icon); } gtk_widget_show(gtkmedia->priv->display); }