struct datawindow_priv *
gui_gtk_datawindow_new(struct gui_priv *gui, char *name, struct callback *click, struct callback *close, struct datawindow_methods *meth)
{
struct datawindow_priv *win;
*meth=gui_gtk_datawindow_meth;
win=g_new0(struct datawindow_priv, 1);
win->window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(win->window), 320, 200);
gtk_window_set_title(GTK_WINDOW(win->window), name);
gtk_window_set_wmclass (GTK_WINDOW (win->window), "navit", "Navit");
win->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win->scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(win->window), win->scrolled_window);
g_signal_connect(G_OBJECT(win->window), "key-press-event", G_CALLBACK(keypress), win);
win->treeview=NULL;
win->click=click;
win->close=close;
if (gui)
gtk_window_set_transient_for(GTK_WINDOW((GtkWidget *)(win->window)), GTK_WINDOW(gui->win));
g_signal_connect(G_OBJECT(win->window), "delete-event", G_CALLBACK(gui_gtk_datawindow_delete), win);
gtk_widget_show_all(win->window);
win->gui = gui;
gui->datawindow = win;
return win;
}
CajaDesktopWindow *
caja_desktop_window_new (CajaApplication *application,
GdkScreen *screen)
{
CajaDesktopWindow *window;
int width_request, height_request;
width_request = gdk_screen_get_width (screen);
height_request = gdk_screen_get_height (screen);
window = CAJA_DESKTOP_WINDOW
(gtk_widget_new (caja_desktop_window_get_type(),
"app", application,
"width_request", width_request,
"height_request", height_request,
"screen", screen,
NULL));
/* Special sawmill setting*/
gtk_window_set_wmclass (GTK_WINDOW (window), "desktop_window", "Caja");
g_signal_connect (window, "delete_event", G_CALLBACK (caja_desktop_window_delete_event), NULL);
/* Point window at the desktop folder.
* Note that caja_desktop_window_init is too early to do this.
*/
caja_desktop_window_update_directory (window);
return window;
}
static void
progress_ui_handler_ensure_window (NautilusProgressUIHandler *self)
{
GtkWidget *vbox, *progress_window;
if (self->priv->progress_window != NULL) {
return;
}
progress_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
self->priv->progress_window = progress_window;
gtk_window_set_resizable (GTK_WINDOW (progress_window),
FALSE);
gtk_container_set_border_width (GTK_CONTAINER (progress_window), 10);
gtk_window_set_title (GTK_WINDOW (progress_window),
_("File Operations"));
gtk_window_set_wmclass (GTK_WINDOW (progress_window),
"file_progress", "Nautilus");
gtk_window_set_position (GTK_WINDOW (progress_window),
GTK_WIN_POS_CENTER);
gtk_window_set_icon_name (GTK_WINDOW (progress_window),
"system-file-manager");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_spacing (GTK_BOX (vbox), 5);
gtk_container_add (GTK_CONTAINER (progress_window),
vbox);
self->priv->window_vbox = vbox;
gtk_widget_show (vbox);
g_signal_connect (progress_window,
"delete-event",
(GCallback) progress_window_delete_event, self);
}
GtkWidget * create_URL( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * hbuttonbox1;
GtkWidget * Ok;
GtkWidget * Cancel;
GtkAccelGroup * accel_group;
accel_group=gtk_accel_group_new();
URL=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( URL,"URL" );
gtk_object_set_data( GTK_OBJECT( URL ),"URL",URL );
gtk_widget_set_usize( URL,384,70 );
GTK_WIDGET_SET_FLAGS( URL,GTK_CAN_DEFAULT );
gtk_window_set_title( GTK_WINDOW( URL ),MSGTR_Network );
gtk_window_set_position( GTK_WINDOW( URL ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( URL ),TRUE,TRUE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( URL ),"Network","MPlayer" );
gtk_widget_realize( URL );
gtkAddIcon( URL );
vbox1=AddVBox( AddDialogFrame( URL ),0 );
hbox1=AddHBox( vbox1,1 );
AddLabel( "URL: ",hbox1 );
URLCombo=AddComboBox( hbox1 );
/*
gtk_combo_new();
gtk_widget_set_name( URLCombo,"URLCombo" );
gtk_widget_show( URLCombo );
gtk_box_pack_start( GTK_BOX( hbox1 ),URLCombo,TRUE,TRUE,0 );
*/
URLEntry=GTK_COMBO( URLCombo )->entry;
gtk_widget_set_name( URLEntry,"URLEntry" );
gtk_widget_show( URLEntry );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( URL ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&URL );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( on_Button_pressed ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( on_Button_pressed ),NULL );
gtk_widget_grab_focus( URLEntry );
gtk_window_add_accel_group( GTK_WINDOW( URL ),accel_group );
return URL;
}
widget_t *
widget_window(widget_t *w)
{
w->index = luaH_window_index;
w->newindex = luaH_window_newindex;
w->destructor = widget_destructor;
/* create and setup window widget */
w->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_object_set_data(G_OBJECT(w->widget), "lua_widget", (gpointer) w);
gtk_window_set_wmclass(GTK_WINDOW(w->widget), "luakit", "luakit");
gtk_window_set_default_size(GTK_WINDOW(w->widget), 800, 600);
gtk_window_set_title(GTK_WINDOW(w->widget), "luakit");
GdkGeometry hints;
hints.min_width = 1;
hints.min_height = 1;
gtk_window_set_geometry_hints(GTK_WINDOW(w->widget), NULL, &hints, GDK_HINT_MIN_SIZE);
g_object_connect(G_OBJECT(w->widget),
"signal::add", G_CALLBACK(add_cb), w,
"signal::destroy", G_CALLBACK(destroy_cb), w,
"signal::key-press-event", G_CALLBACK(key_press_cb), w,
"signal::remove", G_CALLBACK(remove_cb), w,
NULL);
/* add to global windows list */
g_ptr_array_add(globalconf.windows, w);
return w;
}
NemoDesktopWindow *
nemo_desktop_window_new (GdkScreen *screen)
{
NemoDesktopWindow *window;
int width_request, height_request;
width_request = gdk_screen_get_width (screen);
height_request = gdk_screen_get_height (screen);
GdkRGBA transparent = {0, 0, 0, 0};
window = g_object_new (NEMO_TYPE_DESKTOP_WINDOW,
"disable-chrome", TRUE,
"width_request", width_request,
"height_request", height_request,
"screen", screen,
NULL);
/* Special sawmill setting*/
gtk_window_set_wmclass (GTK_WINDOW (window), "desktop_window", "Nemo");
g_signal_connect (window, "delete_event", G_CALLBACK (nemo_desktop_window_delete_event), NULL);
/* Point window at the desktop folder.
* Note that nemo_desktop_window_init is too early to do this.
*/
nemo_desktop_window_update_directory (window);
gtk_widget_override_background_color (GTK_WIDGET (window), 0, &transparent);
return window;
}
// initiate player's window
int initializeWindow(GtkWidget **window, int player) {
// if not valid player, raise error
if (player != 1 && player != 2) {
printf("Error, invalid player number window opened\n");
return 0;
}
// initialize window
*window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// set title
char buf[50];
sprintf(buf, "megasenha - player %d", player);
gtk_window_set_title(GTK_WINDOW(*window), buf);
// set size and position and connects close window with destroy function
gtk_window_set_default_size(GTK_WINDOW(*window), 597, 177);
gtk_container_set_border_width (GTK_CONTAINER (*window), 10);
if(player == 1) {
gtk_window_move(GTK_WINDOW(*window), gdk_screen_width()*1/10, gdk_screen_height()/2 - 150);
gtk_signal_connect (GTK_OBJECT(*window), "destroy", GTK_SIGNAL_FUNC (destroy), (gpointer) "1");
} else {
gtk_window_move(GTK_WINDOW(*window), gdk_screen_width()*9/10 - 500, gdk_screen_height()/2 - 150);
gtk_signal_connect (GTK_OBJECT(*window), "destroy", GTK_SIGNAL_FUNC (destroy), (gpointer) "2");
}
// sets and creates icons for windows and tell windows manager not to put them together
sprintf(buf, "p%d.png", player);
gtk_window_set_icon(GTK_WINDOW(*window), createPixbuf(buf));
sprintf(buf, "player %d", player);
gtk_window_set_wmclass(GTK_WINDOW (*window), buf, "megasenha");
return 1;
}
static GtkWidget *
window_new (GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *win;
GList *tmp;
char *title = NULL;
char *wmclass = "";
info->visible = FALSE;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
switch (attr->name[0]) {
case 't':
if (!strcmp(attr->name, "title")) {
title = attr->value;
} else if (!strcmp(attr->name, "type")) {
if (strcmp(attr->value, "GTK_WINDOW_TOPLEVEL")) {
wmclass = "glclient-dialog";
}
}
break;
}
}
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
glade_xml_set_window_props(GTK_WINDOW(win), info);
glade_xml_set_toplevel(xml, GTK_WINDOW(win));
gtk_window_set_title(GTK_WINDOW(win), title);
gtk_window_set_wmclass(GTK_WINDOW(win), wmclass, wmclass);
return win;
}
/**
* gimp_dialog_newv:
* @title: The dialog's title which will be set with gtk_window_set_title().
* @wmclass_name: The dialog's @wmclass_name which will be set with
* gtk_window_set_wmclass(). The @wmclass_class will be
* automatically set to "Gimp".
* @help_func: The function which will be called if the user presses "F1".
* @help_data: The data pointer which will be passed to @help_func.
* @position: The dialog's initial position which will be set with
* gtk_window_set_position().
* @allow_shrink: The dialog's @allow_shrink flag, ...
* @allow_grow: ... it't @allow_grow flag and ...
* @auto_shrink: ... it's @auto_shrink flag which will all be set with
* gtk_window_set_policy().
* @args: A @va_list as obtained with va_start() describing the action_area
* buttons.
*
* This function performs all neccessary setps to set up a standard GIMP
* dialog.
*
* The @va_list describing the action_area buttons will be passed to
* gimp_dialog_create_action_areav().
*
* Returns: A #GtkDialog.
*
*/
GtkWidget *
gimp_dialog_newv (const gchar *title,
const gchar *wmclass_name,
GimpHelpFunc help_func,
const gchar *help_data,
GtkWindowPosition position,
gint allow_shrink,
gint allow_grow,
gint auto_shrink,
va_list args)
{
GtkWidget *dialog;
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (wmclass_name != NULL, NULL);
dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog), title);
gtk_window_set_wmclass (GTK_WINDOW (dialog), wmclass_name, PROGRAM_NAME);
gtk_window_set_position (GTK_WINDOW (dialog), position);
gtk_window_set_policy (GTK_WINDOW (dialog),
allow_shrink, allow_grow, auto_shrink);
/* prepare the action_area */
gimp_dialog_create_action_areav (GTK_DIALOG (dialog), args);
/* connect the "F1" help key */
# if 0
if (help_func)
gimp_help_connect_help_accel (dialog, help_func, help_data);
# endif
return dialog;
}
/**
* gwy_module_browser:
*
* Shows a simple module browser.
**/
void
gwy_module_browser(void)
{
GtkWidget *browser, *scroll, *paned, *info;
if (window) {
gtk_window_present(GTK_WINDOW(window));
return;
}
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 480, 480);
gtk_window_set_title(GTK_WINDOW(window), _("Module Browser"));
gtk_window_set_wmclass(GTK_WINDOW(window), "browser_module",
g_get_application_name());
paned = gtk_vpaned_new();
gtk_container_add(GTK_CONTAINER(window), paned);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_paned_pack1(GTK_PANED(paned), scroll, TRUE, FALSE);
browser = gwy_module_browser_construct(window);
gtk_container_add(GTK_CONTAINER(scroll), browser);
info = gwy_module_browser_info_table(window);
gtk_paned_pack2(GTK_PANED(paned), info, FALSE, FALSE);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroy), NULL);
g_signal_connect_swapped(window, "destroy",
G_CALLBACK(g_nullify_pointer), &window);
gtk_widget_show_all(window);
}
AthenaDesktopWindow *
athena_desktop_window_new (GdkScreen *screen)
{
AthenaDesktopWindow *window;
int width_request, height_request;
width_request = gdk_screen_get_width (screen);
height_request = gdk_screen_get_height (screen);
window = g_object_new (ATHENA_TYPE_DESKTOP_WINDOW,
"disable-chrome", TRUE,
"width_request", width_request,
"height_request", height_request,
"screen", screen,
NULL);
/* Special sawmill setting*/
gtk_window_set_wmclass (GTK_WINDOW (window), "desktop_window", "Athena");
g_signal_connect (window, "delete_event", G_CALLBACK (athena_desktop_window_delete_event), NULL);
/* Point window at the desktop folder.
* Note that athena_desktop_window_init is too early to do this.
*/
athena_desktop_window_update_directory (window);
return window;
}
static void
glade_keys_dialog_init (GladeKeysDialog *dialog)
{
GtkWidget *scrolled_win;
int i, row;
gchar *titles[1];
gtk_window_set_title (GTK_WINDOW (dialog), _("Select Accelerator Key"));
gtk_window_set_wmclass (GTK_WINDOW (dialog), "accelerator_key", "Glade");
titles[0] = _("Keys");
dialog->clist = gtk_clist_new_with_titles (1, titles);
gtk_clist_column_titles_passive (GTK_CLIST (dialog->clist));
gtk_widget_set_usize (dialog->clist, 200, 300);
gtk_widget_show (dialog->clist);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_win), dialog->clist);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win,
TRUE, TRUE, 0);
gtk_widget_show (scrolled_win);
/* Insert events & descriptions */
gtk_clist_freeze (GTK_CLIST (dialog->clist));
i = 0;
while (GbKeys[i].name)
{
row = gtk_clist_append (GTK_CLIST (dialog->clist),
(gchar**) (&GbKeys[i].name));
gtk_clist_set_row_data (GTK_CLIST (dialog->clist), row,
GINT_TO_POINTER (i));
i++;
}
gtk_clist_thaw (GTK_CLIST (dialog->clist));
#ifdef USE_GNOME
dialog->ok_button = gnome_stock_button (GNOME_STOCK_BUTTON_OK);
#else
dialog->ok_button = gtk_button_new_with_label (_ ("OK"));
#endif
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
dialog->ok_button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (dialog->ok_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (dialog->ok_button);
gtk_widget_show (dialog->ok_button);
#ifdef USE_GNOME
dialog->cancel_button = gnome_stock_button (GNOME_STOCK_BUTTON_CANCEL);
#else
dialog->cancel_button = gtk_button_new_with_label (_("Cancel"));
#endif
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
dialog->cancel_button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (dialog->cancel_button, GTK_CAN_DEFAULT);
gtk_widget_show (dialog->cancel_button);
}
static GtkWidget *CreateURLDialog(void)
{
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *hbuttonbox1;
GtkWidget *Ok;
GtkWidget *Cancel;
GtkAccelGroup *accel_group;
GdkGeometry geometry;
accel_group = gtk_accel_group_new();
URLDialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize(URLDialog, 384, -1);
gtk_window_set_title(GTK_WINDOW(URLDialog), MSGTR_Network);
gtk_window_set_position(GTK_WINDOW(URLDialog), GTK_WIN_POS_CENTER);
gtk_window_set_wmclass(GTK_WINDOW(URLDialog), "Network", MPlayer);
gtk_widget_realize(URLDialog);
gtkAddIcon(URLDialog);
vbox1 = gtkAddVBox(gtkAddDialogFrame(URLDialog), 0);
hbox1 = gtkAddHBox(vbox1, 1);
gtkAddLabel("URL: ", hbox1);
urlCombo = gtkAddCombo(hbox1);
/*
* gtk_combo_new();
* gtk_widget_show( urlCombo );
* gtk_box_pack_start( GTK_BOX( hbox1 ),urlCombo,TRUE,TRUE,0 );
*/
urlEntry = GTK_COMBO(urlCombo)->entry;
gtk_widget_show(urlEntry);
gtkAddHSeparator(vbox1);
hbuttonbox1 = gtkAddHButtonBox(vbox1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbuttonbox1), 10);
Ok = gtkAddButton(MSGTR_Ok, hbuttonbox1);
Cancel = gtkAddButton(MSGTR_Cancel, hbuttonbox1);
geometry.max_width = gdk_screen_get_width(gtk_widget_get_screen(URLDialog));
geometry.max_height = -1;
gtk_window_set_geometry_hints(GTK_WINDOW(URLDialog), NULL, &geometry, GDK_HINT_MAX_SIZE);
gtk_widget_add_accelerator(Ok, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(Cancel, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE);
gtk_signal_connect(GTK_OBJECT(URLDialog), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &URLDialog);
gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(button_clicked), Ok);
gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(button_clicked), NULL);
gtk_widget_grab_focus(urlEntry);
gtk_window_add_accel_group(GTK_WINDOW(URLDialog), accel_group);
return URLDialog;
}
void
ghid_dialog_export (void)
{
GtkWidget *vbox, *button;
GHidPort *out = &ghid_port;
int i;
HID **hids;
GtkTooltips *tips;
gboolean no_exporter = TRUE;
tips = gtk_tooltips_new ();
export_dialog = gtk_dialog_new_with_buttons (_("PCB Export Layout"),
GTK_WINDOW (out->top_window),
GTK_DIALOG_MODAL
|
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_wmclass (GTK_WINDOW (export_dialog), "PCB_Export", "PCB");
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (export_dialog)->vbox), vbox);
/*
* Iterate over all the export HID's and build up a dialog box that
* lets us choose which one we want to use.
* This way, any additions to the exporter HID's automatically are
* reflected in this dialog box.
*/
hids = hid_enumerate ();
for (i = 0; hids[i]; i++)
{
if (hids[i]->exporter)
{
no_exporter = FALSE;
button = gtk_button_new_with_label (hids[i]->name);
gtk_tooltips_set_tip (tips, button, hids[i]->description, NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (exporter_clicked_cb), hids[i]);
}
}
if (no_exporter)
{
gui->log (_("Can't find a suitable exporter HID"));
}
gtk_widget_show_all (export_dialog);
gtk_dialog_run (GTK_DIALOG (export_dialog));
if (export_dialog != NULL)
gtk_widget_destroy (export_dialog);
export_dialog = NULL;
}
/* Init function. Here we setup all the gtk stuff */
static GtkWidget *init_fftscope_window()
{
GtkWidget *fftscope_win;
GtkStyle *style;
GdkColor color;
guint32 colors[129];
int i;
pthread_mutex_init(&fftscope_mutex, NULL);
style = gtk_style_new();
fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope");
gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT);
gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope",
"AlsaPlayer");
gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE,
FALSE);
style =
gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win)));
color.red = SCOPE_BG_RED << 8;
color.blue = SCOPE_BG_BLUE << 8;
color.green = SCOPE_BG_GREEN << 8;
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_widget_set_style(GTK_WIDGET(fftscope_win), style);
for (i = 0; i < 32; i++) {
colors[i * 2] = colors[i * 2 + 1] =
((i * 8) << 16) + (255 << 8);
colors[i * 2 + 64] = colors[i * 2 + 65] =
(255 << 16) + (((31 - i) * 8) << 8);
}
colors[128] = 0;
color_map = gdk_rgb_cmap_new(colors, 129);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(fftscope_win), area);
gtk_widget_realize(area);
gdk_window_set_background(area->window, &color);
gtk_widget_show(area);
gtk_widget_show(fftscope_win);
/* Signals */
gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event",
GTK_SIGNAL_FUNC(close_fftscope_window),
fftscope_win);
/* Clear and show the window */
gdk_window_clear(fftscope_win->window);
gdk_flush();
ready_state = 1;
return fftscope_win;
}
/* If ghidgui->use_command_window is TRUE this will get called from
| ActionCommand() to show the command window.
*/
void
ghid_command_window_show (gboolean raise)
{
GtkWidget *vbox, *vbox1, *hbox, *button, *expander, *text;
gint i;
if (command_window)
{
if (raise)
gtk_window_present (GTK_WINDOW(command_window));
return;
}
command_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (command_window), "destroy",
G_CALLBACK (command_destroy_cb), NULL);
gtk_window_set_title (GTK_WINDOW (command_window), _("PCB Command Entry"));
gtk_window_set_wmclass (GTK_WINDOW (command_window), "PCB_Command", "PCB");
gtk_window_set_resizable (GTK_WINDOW (command_window), FALSE);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (command_window), vbox);
if (!ghidgui->command_combo_box)
command_combo_box_entry_create ();
gtk_box_pack_start (GTK_BOX (vbox), ghidgui->command_combo_box,
FALSE, FALSE, 0);
combo_vbox = vbox;
/* Make the command reference scrolled text view. Use high level
| utility functions in gui-utils.c
*/
expander = gtk_expander_new (_("Command Reference"));
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 2);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (expander), vbox1);
gtk_widget_set_size_request (vbox1, -1, 350);
text = ghid_scrolled_text_view (vbox1, NULL,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
for (i = 0; i < sizeof (command_ref_text) / sizeof (gchar *); ++i)
ghid_text_view_append (text, _(command_ref_text[i]));
/* The command window close button.
*/
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 3);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (command_window_close_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show_all (command_window);
}
/*
* The code in trash_empty_show_confirmation_dialog() was taken from
* libcaja-private/caja-file-operations.c (confirm_empty_trash)
* by Michiel Sikkes <*****@*****.**> and adapted for the applet.
*/
static void
trash_empty_show_confirmation_dialog (GtkWidget *parent)
{
GtkWidget *dialog;
GtkWidget *button;
GdkScreen *screen;
if (!trash_empty_require_confirmation ())
{
trash_empty_start (parent);
return;
}
screen = gtk_widget_get_screen (parent);
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
_("Empty all of the items from "
"the trash?"));
trash_empty_confirm_dialog = GTK_DIALOG (dialog);
g_object_add_weak_pointer (G_OBJECT (dialog),
(gpointer *) &trash_empty_confirm_dialog);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("If you choose to empty "
"the trash, all items in "
"it will be permanently "
"lost. Please note that "
"you can also delete them "
"separately."));
gtk_window_set_screen (GTK_WINDOW (dialog), screen);
atk_object_set_role (gtk_widget_get_accessible (dialog), ATK_ROLE_ALERT);
gtk_window_set_wmclass (GTK_WINDOW (dialog), "empty_trash", "Caja");
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
button = gtk_button_new_with_mnemonic (_("_Empty Trash"));
gtk_widget_show (button);
gtk_widget_set_can_default (button, TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
GTK_RESPONSE_YES);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_YES);
gtk_widget_show (dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (trash_empty_confirmation_response), NULL);
}
static void
progress_ui_handler_ensure_window (NemoProgressUIHandler *self)
{
NemoProgressUIHandlerPriv *priv = NEMO_PROGRESS_UI_HANDLER (self)->priv;
GtkWidget *main_box, *progress_window;
GtkWidget *w, *frame;
if (self->priv->progress_window != NULL) {
return;
}
progress_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
self->priv->progress_window = progress_window;
gtk_window_set_resizable (GTK_WINDOW (progress_window), FALSE);
gtk_window_set_default_size (GTK_WINDOW (progress_window), 400, -1);
gtk_window_set_title (GTK_WINDOW (progress_window),
_("File Operations"));
gtk_window_set_wmclass (GTK_WINDOW (progress_window),
"file_progress", "Nemo");
gtk_window_set_position (GTK_WINDOW (progress_window),
GTK_WIN_POS_CENTER);
gtk_window_set_icon_name (GTK_WINDOW (progress_window),
"system-run");
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (progress_window),
main_box);
self->priv->window_vbox = main_box;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
priv->list = w;
gtk_container_add (GTK_CONTAINER (frame), w);
g_object_set (priv->list,
"margin-left", 5,
"margin-right", 5,
"margin-top", 5,
"margin-bottom", 5,
NULL);
gtk_box_pack_start (GTK_BOX (main_box), frame, FALSE, FALSE, 0);
gtk_widget_show_all (main_box);
g_signal_connect (progress_window,
"delete-event",
(GCallback) progress_window_delete_event, self);
}
void
module_glist (struct session *sess)
{
gchar *titles[] = { _("Name"), _("Description") };
GtkWidget *okb, *ulb;
if (modlist)
return;
modlist = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (modlist), "delete_event",
GTK_SIGNAL_FUNC (module_glist_close), 0);
gtk_widget_set_usize (modlist, 350, 200);
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (modlist)->vbox),
4);
gtk_window_set_position (GTK_WINDOW (modlist), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (modlist), _("X-Chat Plugins"));
gtk_window_set_wmclass (GTK_WINDOW (modlist), "plugins", "X-Chat");
modclist = gtk_clist_new_with_titles (2, titles);
gtk_clist_set_selection_mode (GTK_CLIST (modclist), GTK_SELECTION_BROWSE);
gtk_clist_column_titles_passive (GTK_CLIST (modclist));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->vbox), modclist, 1, 1,
10);
gtk_widget_show (modclist);
gtk_clist_set_column_width (GTK_CLIST (modclist), 0, 40);
#ifdef USE_GNOME
okb = gnome_stock_button (GNOME_STOCK_BUTTON_OK);
#else
okb = gtk_button_new_with_label (_("Ok"));
#endif
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->action_area), okb, 1, 1,
10);
gtk_signal_connect (GTK_OBJECT (okb), "clicked",
GTK_SIGNAL_FUNC (module_glist_close),
(gpointer) modlist);
gtk_widget_show (okb);
ulb = gtk_button_new_with_label (_("Unload"));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->action_area), ulb, 1, 1,
10);
gtk_signal_connect (GTK_OBJECT (ulb), "clicked",
GTK_SIGNAL_FUNC (module_glist_unload),
(gpointer) sess);
gtk_widget_show (ulb);
fe_pluginlist_update ();
gtk_widget_show (modlist);
}
static GtkWidget *
create_dialog_with_treeview (GtkWindow *parent, gint width, gint height)
{
GtkWidget *dialog;
GtkWidget *scrolledwindow;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *treeview;
if (height < 250)
height = 250;
if (width < 400)
width = 400;
dialog = gtk_dialog_new_with_buttons (_("Information"), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 250);
gtk_window_set_wmclass (GTK_WINDOW (dialog), "infoless", "Anjuta");
gtk_widget_show (dialog);
/* Auto close */
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy), NULL);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
scrolledwindow);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolledwindow);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
treeview = gtk_tree_view_new_with_model (model);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Lines"), renderer,
"text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), FALSE);
gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview);
gtk_widget_show (treeview);
g_object_unref (G_OBJECT (model));
return treeview;
}
static gboolean
glide_window_show_quit_dialog (GlideWindow *w)
{
GtkWidget *dialog, *label;
gint response;
if (!w->priv->document)
return TRUE;
if (!glide_document_get_dirty (w->priv->document))
return TRUE;
dialog = gtk_dialog_new_with_buttons (_("Glide"),
GTK_WINDOW (w),
GTK_DIALOG_MODAL,
"Close without saving", GTK_RESPONSE_CLOSE,
"Save and close", GTK_RESPONSE_OK,
"Cancel", GTK_RESPONSE_CANCEL,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
label = gtk_label_new (_("Are you sure you want to quit?"));
gtk_misc_set_padding (GTK_MISC (label), 20, 20);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label,
TRUE, TRUE, 0);
gtk_widget_show (label);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_window_set_wmclass (GTK_WINDOW (dialog), "quit", "Glide");
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response == GTK_RESPONSE_CLOSE)
return TRUE;
else if (response == GTK_RESPONSE_OK)
{
const gchar *filename;
filename = glide_document_get_path (w->priv->document);
if (filename)
{
glide_window_save_document_real (w, filename);
return TRUE;
}
else
{
glide_gtk_util_show_save_dialog (G_CALLBACK (glide_window_save_and_quit_response_callback), w);
return FALSE;
}
}
return FALSE;
}
static void create_dialog()
{
GtkWidget *button;
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW (dialog), _("Object properties"));
gtk_window_set_wmclass(GTK_WINDOW (dialog),
"properties_window", "Dia");
gtk_window_set_policy(GTK_WINDOW (dialog),
FALSE, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER (dialog), 2);
dialog_vbox = GTK_DIALOG(dialog)->vbox;
button = gtk_button_new_with_label( _("OK") );
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(properties_okay),
GTK_OBJECT(dialog));
gtk_widget_show (button);
button = gtk_button_new_with_label(_("Apply"));
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(properties_apply),
NULL);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label( _("Close") );
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_hide),
GTK_OBJECT(dialog));
gtk_widget_show (button);
gtk_signal_connect(GTK_OBJECT (dialog), "delete_event",
GTK_SIGNAL_FUNC(gtk_widget_hide), NULL);
no_properties_dialog = gtk_label_new(_("This object has no properties."));
gtk_widget_show (no_properties_dialog);
}
static void
wncklet_display_about (GtkWidget *applet,
GtkWidget **dialog,
const char *name,
const char *copyright,
const char *comments,
const char **authors,
const char **documenters,
const char *translator_credits,
const char *icon_name,
const char *wmclass_name,
const char *wmclass_class)
{
if (*dialog) {
gtk_window_set_screen (GTK_WINDOW (*dialog),
gtk_widget_get_screen (applet));
gtk_window_present (GTK_WINDOW (*dialog));
return;
}
*dialog = gtk_about_dialog_new ();
g_object_set (*dialog,
"name", name,
"version", VERSION,
"copyright", copyright,
"comments", comments,
"authors", authors,
"documenters", documenters,
"translator-credits", translator_credits,
"logo-icon-name", icon_name,
NULL);
gtk_window_set_wmclass (GTK_WINDOW (*dialog),
wmclass_name, wmclass_class);
gtk_window_set_screen (GTK_WINDOW (*dialog),
gtk_widget_get_screen (applet));
gtk_window_set_icon_name (GTK_WINDOW (*dialog), icon_name);
g_signal_connect (*dialog, "destroy",
(GCallback) gtk_widget_destroyed, dialog);
g_signal_connect (*dialog, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_widget_show (*dialog);
}
static void
gnocam_applet_about_cb (BonoboUIComponent *uic, GnocamApplet *a,
const char *verbname)
{
static GtkWidget *about = NULL;
GdkPixbuf *pixbuf;
GError *e = NULL;
g_return_if_fail (GNOCAM_IS_APPLET (a));
static const gchar *authors[] = {
"Lutz Mueller <*****@*****.**>",
NULL
};
const gchar *documenters[] = {NULL};
const gchar *translator_credits = _("translator_credits");
/* Do we already have the widget? */
if (about) {
gtk_window_present (GTK_WINDOW (about));
return;
}
/* Create the widget. */
pixbuf = gdk_pixbuf_new_from_file (IMAGEDIR "gnocam-camera1.png", &e);
about = gnome_about_new (
_("Camera Applet"), VERSION,
_("Copyright © 2002 Lutz Mueller"),
_("Access your digital camera."),
authors, documenters,
(strcmp (translator_credits, "translator_credits") ?
translator_credits : NULL), pixbuf);
if (pixbuf)
g_object_unref (pixbuf);
/* Set up the widget. */
gtk_window_set_wmclass (GTK_WINDOW (about), "gnocam-applet",
"Camera Applet");
gnome_window_icon_set_from_file (GTK_WINDOW (about),
IMAGEDIR "gnocam-camera1.png");
g_signal_connect (about, "destroy", G_CALLBACK (gtk_widget_destroyed),
&about);
/* Show the widget. */
gtk_widget_show (about);
}
static GtkWidget *
get_progress_window (void)
{
static GtkWidget *progress_window = NULL;
GtkWidget *vbox;
if (progress_window != NULL)
{
return progress_window;
}
progress_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (progress_window),
FALSE);
gtk_container_set_border_width (GTK_CONTAINER (progress_window), 10);
gtk_window_set_title (GTK_WINDOW (progress_window),
_("File Operations"));
gtk_window_set_wmclass (GTK_WINDOW (progress_window),
"file_progress", "Caja");
gtk_window_set_position (GTK_WINDOW (progress_window),
GTK_WIN_POS_CENTER);
gtk_window_set_icon_name (GTK_WINDOW (progress_window),
"system-file-manager");
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_set_spacing (GTK_BOX (vbox), 5);
gtk_container_add (GTK_CONTAINER (progress_window),
vbox);
gtk_widget_show_all (progress_window);
g_signal_connect (progress_window,
"delete_event",
(GCallback)delete_event, NULL);
status_icon = gtk_status_icon_new_from_icon_name ("system-file-manager");
g_signal_connect (status_icon, "activate",
(GCallback)status_icon_activate_cb,
progress_window);
gtk_status_icon_set_visible (status_icon, FALSE);
return progress_window;
}
void
ghid_pinout_window_show (GHidPort * out, ElementType * element)
{
GtkWidget *button, *vbox, *hbox, *preview, *top_window;
gchar *title;
int width, height;
if (!element)
return;
title = g_strdup_printf ("%s [%s,%s]",
UNKNOWN (DESCRIPTION_NAME (element)),
UNKNOWN (NAMEONPCB_NAME (element)),
UNKNOWN (VALUE_NAME (element)));
top_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (top_window), title);
g_free (title);
gtk_window_set_wmclass (GTK_WINDOW (top_window), "PCB_Pinout", "PCB");
gtk_container_set_border_width (GTK_CONTAINER (top_window), 4);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (top_window), vbox);
preview = ghid_pinout_preview_new (element);
gtk_box_pack_start (GTK_BOX (vbox), preview, TRUE, TRUE, 0);
ghid_pinout_preview_get_natural_size (GHID_PINOUT_PREVIEW (preview),
&width, &height);
gtk_window_set_default_size (GTK_WINDOW (top_window),
width + 50, height + 50);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (pinout_close_cb), top_window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_realize (top_window);
if (Settings.AutoPlace)
gtk_window_move (GTK_WINDOW (top_window), 10, 10);
gtk_widget_show_all (top_window);
}
void
ghid_keyref_window_show (gboolean raise)
{
GtkWidget *vbox, *hbox, *button, *text;
gint i;
if (keyref_window)
{
if (raise)
gtk_window_present(GTK_WINDOW(keyref_window));
return;
}
keyref_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (keyref_window), "destroy",
G_CALLBACK (keyref_destroy_cb), NULL);
g_signal_connect (G_OBJECT (keyref_window), "configure_event",
G_CALLBACK (keyref_window_configure_event_cb), NULL);
gtk_window_set_title (GTK_WINDOW (keyref_window), _("PCB Key Reference"));
gtk_window_set_wmclass (GTK_WINDOW (keyref_window), "PCB_Keyref", "PCB");
gtk_window_set_default_size (GTK_WINDOW (keyref_window),
ghidgui->keyref_window_width,
ghidgui->keyref_window_height);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (keyref_window), vbox);
text = ghid_scrolled_text_view (vbox, NULL,
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
for (i = 0; i < sizeof (key_ref_text) / sizeof (gchar *); ++i)
ghid_text_view_append (text, _(key_ref_text[i]));
/* The keyref window close button.
*/
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 3);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (keyref_close_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show_all (keyref_window);
}
static GtkWidget *
create_dialog_with_textview (GtkWindow *parent, gint width, gint height)
{
GtkWidget *dialog;
GtkWidget *textview;
GtkWidget *scrolledwindow;
if (height < 250)
height = 250;
if (width < 400)
width = 400;
dialog = gtk_dialog_new_with_buttons (_("Information"), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 250);
gtk_window_set_wmclass (GTK_WINDOW (dialog), "infoless", "Anjuta");
gtk_widget_show (dialog);
/* Auto close */
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy), NULL);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
scrolledwindow);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_widget_show (scrolledwindow);
textview = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolledwindow), textview);
gtk_widget_show (textview);
gtk_widget_show (dialog);
return textview;
}
static void
glade_keys_dialog_init (GladeKeysDialog *dialog)
{
GtkWidget *scrolled_win;
int i, row;
gchar *titles[1];
gtk_window_set_title (GTK_WINDOW (dialog), _("Select Accelerator Key"));
gtk_window_set_wmclass (GTK_WINDOW (dialog), "accelerator_key", "Glade");
titles[0] = _("Keys");
dialog->clist = gtk_clist_new_with_titles (1, titles);
gtk_clist_column_titles_passive (GTK_CLIST (dialog->clist));
gtk_widget_set_usize (dialog->clist, 200, 300);
gtk_widget_show (dialog->clist);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_win), dialog->clist);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win,
TRUE, TRUE, 0);
gtk_widget_show (scrolled_win);
/* Insert events & descriptions */
gtk_clist_freeze (GTK_CLIST (dialog->clist));
i = 0;
while (GbKeys[i].name)
{
row = gtk_clist_append (GTK_CLIST (dialog->clist),
(gchar**) (&GbKeys[i].name));
gtk_clist_set_row_data (GTK_CLIST (dialog->clist), row,
GINT_TO_POINTER (i));
i++;
}
gtk_clist_thaw (GTK_CLIST (dialog->clist));
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
}
/*! \brief Creates a library dialog.
* \par Function Description
* This function create the library dialog if it is not already created.
* It does not show the dialog, use ghid_library_window_show for that.
*
*/
void
ghid_library_window_create (GHidPort * out)
{
GtkWidget *current_tab, *entry_filter;
GtkNotebook *notebook;
if (library_window)
return;
library_window = (GtkWidget *)g_object_new (GHID_TYPE_LIBRARY_WINDOW, NULL);
g_signal_connect (library_window,
"response",
G_CALLBACK (library_window_callback_response), NULL);
g_signal_connect (G_OBJECT (library_window), "configure_event",
G_CALLBACK (library_window_configure_event_cb), NULL);
gtk_window_set_default_size (GTK_WINDOW (library_window),
ghidgui->library_window_width,
ghidgui->library_window_height);
gtk_window_set_title (GTK_WINDOW (library_window), _("PCB Library"));
gtk_window_set_wmclass (GTK_WINDOW (library_window), "PCB_Library",
"PCB");
gtk_widget_realize (library_window);
if (Settings.AutoPlace)
gtk_widget_set_uposition (GTK_WIDGET (library_window), 10, 10);
gtk_editable_select_region (GTK_EDITABLE
(GHID_LIBRARY_WINDOW (library_window)->
entry_filter), 0, -1);
/* Set the focus to the filter entry only if it is in the current
displayed tab */
notebook = GTK_NOTEBOOK (GHID_LIBRARY_WINDOW (library_window)->viewtabs);
current_tab = gtk_notebook_get_nth_page (notebook,
gtk_notebook_get_current_page
(notebook));
entry_filter =
GTK_WIDGET (GHID_LIBRARY_WINDOW (library_window)->entry_filter);
if (gtk_widget_is_ancestor (entry_filter, current_tab))
{
gtk_widget_grab_focus (entry_filter);
}
}
