Example #1
0
static void
gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
                             wxTopLevelWindowGTK *win )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    // All this is for Motif Window Manager "hints" and is supposed to be
    // recognized by other WM as well. Not tested.
    gdk_window_set_decorations(win->m_widget->window,
                               (GdkWMDecoration)win->m_gdkDecor);
    gdk_window_set_functions(win->m_widget->window,
                               (GdkWMFunction)win->m_gdkFunc);

    // GTK's shrinking/growing policy
    if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
    else
        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);

    // reset the icon
    wxIconBundle iconsOld = win->GetIcons();
    if ( !iconsOld.IsEmpty() )
    {
        win->SetIcon( wxNullIcon );
        win->SetIcons( iconsOld );
    }
}
Example #2
0
/**
 * Sets up the icon and canvas widgets.  This function was
 * generated by glade separatly from the main gui since the icon
 * widgets are independent of the rest of the gui, and there
 * are unresolved issues between GTK and GTK2.
 */
static void
create_icon(void)
{
    icon = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_name(icon, "icon");
    gtk_object_set_data(GTK_OBJECT(icon), "icon", icon);
    gtk_widget_set_usize(icon, ICON_WIDTH + 1, ICON_HEIGHT + 1);
    gtk_widget_set_sensitive(icon, FALSE);
    GTK_WIDGET_SET_FLAGS(icon, GTK_CAN_FOCUS);
    GTK_WIDGET_SET_FLAGS(icon, GTK_CAN_DEFAULT);
    gtk_widget_set_events(icon, GDK_VISIBILITY_NOTIFY_MASK);
    gtk_window_set_title(GTK_WINDOW(icon), "icon");
    gtk_window_set_default_size(GTK_WINDOW(icon),
                                ICON_WIDTH + 1, ICON_HEIGHT + 1);
    gtk_window_set_policy(GTK_WINDOW(icon), FALSE, FALSE, FALSE);

    canvas = gtk_drawing_area_new();
    gtk_widget_set_name(canvas, "canvas");
    gtk_widget_ref(canvas);
    gtk_object_set_data_full(GTK_OBJECT(icon), "canvas", canvas,
                             (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show(canvas);
    gtk_container_add(GTK_CONTAINER(icon), canvas);
    gtk_widget_set_events(canvas, GDK_EXPOSURE_MASK);

    gui_signal_connect(icon, "map_event", on_icon_map_event, NULL);
    gui_signal_connect(icon, "unmap_event", on_icon_unmap_event, NULL);
    gui_signal_connect(canvas, "expose_event", on_canvas_expose_event, NULL);
}
/**
    \fn GUI_gtk_grow_off
    \brief allow main window to grow or not
*/
void GUI_gtk_grow_off(int onoff)
{
  gtk_window_set_policy(GTK_WINDOW ( guiRootWindow ),
                                             0, //gint allow_shrink,
                                             onoff, //gint allow_grow,
                                             1);//gint auto_shrink);
}
Example #4
0
/*
 * Función mostrarConsultaWindow()
 *
 * Parámetros de entrada:
 *      char * dir[3]: nombre direccion y telefono a mostrar
 *      
 * Parámetros de salida:
 *      Ninguno
 *
 * Descripción: 
 *      Mostrar en la pantalla una única consulta
 */
void mostrarConsultaWindow(char* dir[3])
{
    GtkWidget *datos;
    GtkWidget *window;
  
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_usize (GTK_WIDGET (window), 300, 300);
    gtk_window_set_policy(GTK_WINDOW (window), TRUE, TRUE, FALSE);      
    gtk_window_set_title (GTK_WINDOW (window), "Libro de direcciones");
    gtk_container_border_width (GTK_CONTAINER (window), 10);    
    gtk_widget_set_uposition( window, 300, 300 );   
  
    datos=gtk_clist_new(3);
    gtk_clist_set_column_title(GTK_CLIST(datos),0,"Nombre");    
    gtk_clist_set_column_title(GTK_CLIST(datos),1,"Direccion");
    gtk_clist_set_column_title(GTK_CLIST(datos),2,"Telefono");
    gtk_clist_column_titles_show(GTK_CLIST(datos));
    gtk_clist_set_column_width(GTK_CLIST(datos),0,100);
    gtk_clist_set_column_width(GTK_CLIST(datos),1,100);
    gtk_clist_set_column_width(GTK_CLIST(datos),2,50);          
    gtk_container_add (GTK_CONTAINER (window), datos); 
    gtk_clist_append(GTK_CLIST(datos),dir);   
    gtk_widget_show(datos);
    gtk_grab_add(window);
    gtk_widget_show(window);
} 
Example #5
0
void wxTopLevelWindowGTK::GTKHandleRealized()
{
    wxNonOwnedWindow::GTKHandleRealized();

    gdk_window_set_decorations(gtk_widget_get_window(m_widget),
                               (GdkWMDecoration)m_gdkDecor);
    gdk_window_set_functions(gtk_widget_get_window(m_widget),
                               (GdkWMFunction)m_gdkFunc);

    // GTK's shrinking/growing policy
    if ( !(m_gdkFunc & GDK_FUNC_RESIZE) )
        gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE);
#ifndef __WXGTK3__
    else
        gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1);
#endif

    const wxIconBundle& icons = GetIcons();
    if (icons.GetIconCount())
        SetIcons(icons);

#ifdef __WXGTK3__
    if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget)))
    {
        // Grip window can end up obscured, probably due to deferred show.
        // Reset grip to ensure it is visible.
        gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false);
        gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true);
    }
#endif
}
Example #6
0
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;
}
Example #7
0
/**
 * 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;
}
Example #8
0
GTKWindow::GTKWindow(Theme *pTheme, string &oName)
          :Window(pTheme, oName)
{
    m_theme = pTheme;
    m_pCanvas = new GTKCanvas(this);
    m_pMindMeldMutex = new Mutex();

    lastDockPos.x = -1;
    lastDockPos.y = -1;

    gdk_threads_enter();
    mainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_app_paintable(mainWindow, TRUE);
    gtk_window_set_title(GTK_WINDOW(mainWindow), BRANDING);
    gtk_window_set_policy(GTK_WINDOW(mainWindow), TRUE, TRUE, TRUE);
    gtk_widget_set_events(mainWindow, GDK_STRUCTURE_MASK
                          | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK |
                          GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
                          GDK_KEY_PRESS_MASK); 
    gtk_widget_realize(mainWindow);
    gdk_window_set_decorations(mainWindow->window, (GdkWMDecoration)0);
    gdk_threads_leave();

    initialized = false;
    m_bMouseInWindow = false;
}
static GtkWidget *autoenc_processing_dialog_create(void)
{
	GtkWidget *dialog;
	GtkWidget *hbox;
	GtkWidget *spinner;
	GtkWidget *label;

	dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width(GTK_CONTAINER(dialog), 16);
	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
	gtk_window_set_title(GTK_WINDOW(dialog), _("Encrypting attachments"));
	gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
	gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
	syl_plugin_manage_window_set_transient(GTK_WINDOW(dialog));
	//g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_true), NULL);

	hbox = gtk_hbox_new(FALSE, 12);
	gtk_container_add(GTK_CONTAINER(dialog), hbox);
	gtk_widget_show(hbox);

	spinner = gtk_spinner_new();
	gtk_widget_set_size_request(spinner, 16, 16);
	gtk_box_pack_start(GTK_BOX(hbox), spinner, FALSE, FALSE, 0);
	gtk_widget_show(spinner);

	label = gtk_label_new(_("Encrypting attachments..."));
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
	gtk_widget_show(label);

	gtk_widget_show(dialog);

	gtk_spinner_start(GTK_SPINNER(spinner));

	return dialog;
}
Example #10
0
void entrybox(char *title, int width, char *default_text, int maxch, GtkSignalFunc func)
{
    GtkWidget *vbox, *hbox;
    GtkWidget *button1, *button2;

    cleanup=func;

    /* create a new modal window */
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_grab_add(window);
    gtk_widget_set_usize( GTK_WIDGET (window), width, 60);
    gtk_window_set_title(GTK_WINDOW (window), title);
    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
                       (GtkSignalFunc) destroy_callback, NULL);
    gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);

    vbox = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (window), vbox);
    gtk_widget_show (vbox);

    entry = gtk_entry_new_with_max_length (maxch);
    gtk_signal_connect(GTK_OBJECT(entry), "activate",
		       GTK_SIGNAL_FUNC(enter_callback),
		       entry);
    gtk_entry_set_text (GTK_ENTRY (entry), default_text);
    gtk_entry_select_region (GTK_ENTRY (entry),
			     0, GTK_ENTRY(entry)->text_length);
    gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
    gtk_widget_show (entry);

    hbox = gtk_hbox_new (FALSE, 1);
    gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
    gtk_widget_show (hbox);

    button1 = gtk_button_new_with_label ("OK");
    gtk_widget_set_usize(button1, 100, -1);
    gtk_signal_connect(GTK_OBJECT (button1), "clicked",
			       GTK_SIGNAL_FUNC(enter_callback),
			       NULL);
    gtk_widget_show (button1);
    gtk_container_add (GTK_CONTAINER (hbox), button1);
    GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
    gtk_signal_connect_object (GTK_OBJECT (button1),
                                "realize",
                             (GtkSignalFunc) gtk_widget_grab_default,
                             GTK_OBJECT (button1));


    button2 = gtk_button_new_with_label ("Cancel");
    gtk_widget_set_usize(button2, 100, -1);
    gtk_signal_connect(GTK_OBJECT (button2), "clicked",
			       GTK_SIGNAL_FUNC(destroy_callback),
			       NULL);
    GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
    gtk_widget_show (button2);
    gtk_container_add (GTK_CONTAINER (hbox), button2);

    gtk_widget_show(window);
}
Example #11
0
GnomeDialog *
gnocam_camera_selector_new (void)
{
	GnoCamCameraSelector *selector;
	const gchar *buttons[] = {GNOME_STOCK_BUTTON_OK,
				  GNOME_STOCK_BUTTON_CANCEL, NULL};
	GtkWidget *hbox, *pixmap, *vbox, *widget, *label;
	Bonobo_PropertyBag pb;
	CORBA_Environment ev;
	
	selector = gtk_type_new (GNOCAM_TYPE_CAMERA_SELECTOR);
	gnome_dialog_constructv (GNOME_DIALOG (selector), _("Select a Camera"),
				 buttons);
	gnome_dialog_set_default (GNOME_DIALOG (selector), 0);
	gtk_window_set_policy (GTK_WINDOW (selector), TRUE, TRUE, TRUE);
	gtk_widget_set_usize (GTK_WIDGET (selector), 400, 300);

	hbox = gtk_hbox_new (FALSE, 10);
	gtk_widget_show (hbox);
	gtk_container_add (GTK_CONTAINER (GNOME_DIALOG (selector)->vbox), hbox);
	
	vbox = gtk_vbox_new (FALSE, 10);
	gtk_widget_show (vbox);
	gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);

	/* The camera picture */
	pixmap = gnome_pixmap_new_from_file (IMAGEDIR "/gnocam.png");
	gtk_widget_show (pixmap);
	gtk_box_pack_start (GTK_BOX (vbox), pixmap, FALSE, FALSE, 0);

	/* The "Autodetect" check button */
	CORBA_exception_init (&ev);
	pb = bonobo_get_object ("config:/apps/" PACKAGE,
				"Bonobo/PropertyBag", &ev);
	if (BONOBO_EX (&ev)) {
		g_warning ("Could not get property bag: %s", 
			   bonobo_exception_get_text (&ev));
	} else {
		GtkObject *ed;

		ed = bonobo_peditor_new (pb, "autodetect", TC_boolean, NULL);
		bonobo_object_release_unref (pb, NULL);
		widget = bonobo_peditor_get_widget (BONOBO_PEDITOR (ed));
		gtk_widget_show (widget);
		gtk_box_pack_end (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
		label = gtk_label_new (_("Autodetect"));
		gtk_widget_show (label);
		gtk_container_add (GTK_CONTAINER (widget), label);
	}
	CORBA_exception_free (&ev);

	/* The camera list */
	selector->priv->table = gnocam_capplet_table_scrolled_new (NULL);
	gtk_widget_show (selector->priv->table);
	gtk_box_pack_start (GTK_BOX (hbox), selector->priv->table,
			    TRUE, TRUE, 0);
	
	return (GNOME_DIALOG (selector));
}
Example #12
0
/* 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;
}
Example #13
0
static void define_scope_windows(void)
{
    GtkWidget *hbox, *vboxleft, *vboxright, *hboxright;

    /* create main window, set it's size */
    ctrl_usr->main_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* set the minimum size */
//    gtk_widget_set_usize(GTK_WIDGET(ctrl_usr->main_win), 500, 350);
    /* allow the user to expand it */
    gtk_window_set_policy(GTK_WINDOW(ctrl_usr->main_win), FALSE, TRUE, FALSE);
    /* set main window title */
    gtk_window_set_title(GTK_WINDOW(ctrl_usr->main_win), "HAL Oscilloscope");

    /* top level - one big hbox */
    hbox = gtk_hbox_new(FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(hbox), 0);
    /* add the hbox to the main window */
    gtk_container_add(GTK_CONTAINER(ctrl_usr->main_win), hbox);
    gtk_widget_show(hbox);
    /* end of top level */

    /* second level of windows */
    vboxleft = gtk_vbox_new_in_box(FALSE, 0, 0, hbox, TRUE, TRUE, 0);
    hboxright = gtk_hbox_new_in_box(TRUE, 0, 0, hbox, FALSE, FALSE, 0);

    /* third level of windows */
    /* left side */
    ctrl_usr->horiz_info_win =
	gtk_vbox_framed_new_in_box("Horizontal", FALSE, 0, 0, vboxleft, FALSE,
	FALSE, 1);
    /* horizontal row of select buttons */
    ctrl_usr->waveform_win =
	gtk_vbox_new_in_box(FALSE, 0, 0, vboxleft, TRUE, TRUE, 0);
    ctrl_usr->chan_sel_win =
	gtk_hbox_new_in_box(TRUE, 0, 0, vboxleft, FALSE, FALSE, 0);
    ctrl_usr->chan_info_win =
	gtk_hbox_framed_new_in_box("Selected Channel", FALSE, 0, 0, vboxleft,
	FALSE, FALSE, 0);
    /* right side */
    vboxleft = gtk_vbox_new_in_box(FALSE, 0, 0, hboxright, FALSE, FALSE, 0);
    vboxright = gtk_vbox_new_in_box(FALSE, 0, 0, hboxright, FALSE, FALSE, 0);
    ctrl_usr->run_mode_win =
	gtk_vbox_framed_new_in_box("Run Mode", TRUE, 0, 0, vboxleft, FALSE,
	FALSE, 0);
    ctrl_usr->trig_info_win =
	gtk_vbox_framed_new_in_box("Trigger", FALSE, 0, 0, vboxright, TRUE,
	TRUE, 0);
    ctrl_usr->trig_mode_win =
	gtk_vbox_new_in_box(TRUE, 0, 0, ctrl_usr->trig_info_win, FALSE,
	FALSE, 0);
    ctrl_usr->vert_info_win =
	gtk_vbox_framed_new_in_box("Vertical", FALSE, 0, 0, vboxleft, TRUE,
	TRUE, 0);
    /* all windows are now defined */
}
Example #14
0
static void
gtk_combo_button_init (GtkComboButton * combo_button)
{
  GtkWidget *event_box;
  GdkCursor *cursor;
  GtkWidget *widget;
  GtkWidget *arrow;

  widget=GTK_WIDGET(combo_button);

  GTK_BOX(widget)->homogeneous = FALSE;

  combo_button->button = gtk_button_new ();
  combo_button->arrow = gtk_toggle_button_new ();

  arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
  gtk_widget_show (arrow);
  gtk_container_add (GTK_CONTAINER (combo_button->arrow), arrow);

  gtk_box_pack_start (GTK_BOX (combo_button), combo_button->button, TRUE, TRUE, 0);
  gtk_box_pack_end (GTK_BOX (combo_button), combo_button->arrow, FALSE, FALSE, 0);

  gtk_widget_show (combo_button->button);
  gtk_widget_show (combo_button->arrow);

  gtk_signal_connect (GTK_OBJECT (combo_button->arrow), "toggled",
		      (GtkSignalFunc) gtk_combo_button_arrow_press, combo_button);

                       
  combo_button->popwin = gtk_window_new (GTK_WINDOW_POPUP);
  gtk_widget_ref (combo_button->popwin);
  gtk_window_set_resizable (GTK_WINDOW (combo_button->popwin), FALSE);
  gtk_window_set_policy (GTK_WINDOW (combo_button->popwin), 1, 1, 0);
  gtk_widget_set_events (combo_button->popwin, GDK_KEY_PRESS_MASK);
 
  event_box = gtk_event_box_new ();
  gtk_container_add (GTK_CONTAINER (combo_button->popwin), event_box);
  gtk_widget_show (event_box);

  gtk_widget_realize (event_box);
  cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
  gdk_window_set_cursor (event_box->window, cursor);
  gdk_cursor_destroy (cursor);

  combo_button->frame = gtk_frame_new (NULL);
  gtk_container_add (GTK_CONTAINER (event_box), combo_button->frame);
  gtk_frame_set_shadow_type (GTK_FRAME (combo_button->frame), GTK_SHADOW_OUT);
  gtk_widget_show (combo_button->frame);

  gtk_signal_connect (GTK_OBJECT (combo_button->popwin), "button_press_event",
		      GTK_SIGNAL_FUNC (gtk_combo_button_button_press), combo_button);
  

}
Example #15
0
static void sanalyzer_init(void)
{
	GdkColor color;
	int i;
	if(window)
		return;
	window = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
	gtk_widget_realize(window);
	bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
	gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
	gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
	gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
	gtk_widget_set_usize(window, WIDTH, HEIGHT);
	gc = gdk_gc_new(window->window);
	draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
	
	bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
	for(i = 0; i < HEIGHT / 2; i++)
	{
		color.red = 0xFFFF;
		color.green = ((i * 255) / (HEIGHT / 2)) << 8;
		color.blue = 0;
		
		gdk_color_alloc(gdk_colormap_get_system(),&color);
		gdk_gc_set_foreground(gc,&color);
		gdk_draw_line(bar,gc,0,i,24,i);
	}
	for(i = 0; i < HEIGHT / 2; i++)
	{
		color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
		color.green = 0xFFFF;
		color.blue = 0;
		
		gdk_color_alloc(gdk_colormap_get_system(),&color);
		gdk_gc_set_foreground(gc,&color);
		gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
	}
	scale = HEIGHT / log(256);
	gdk_color_black(gdk_colormap_get_system(),&color);
	gdk_gc_set_foreground(gc,&color);
	
	area = gtk_drawing_area_new();
	gtk_container_add(GTK_CONTAINER(window),area);
	gtk_widget_realize(area);
	gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
	
	gtk_widget_show(area);
	gtk_widget_show(window);
	gdk_window_clear(window->window);
	gdk_window_clear(area->window);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setResizable
  (JNIEnv *env, jobject obj, jboolean resize)
{
  void *ptr;
  
  ptr = NSA_GET_PTR (env, obj);
  
  gdk_threads_enter ();
  gtk_window_set_policy (GTK_WINDOW (ptr), resize, resize, 0);
  gdk_threads_leave ();
}
Example #17
0
void confir_save_dlg(NKEdit *doc, gint from)
{
  GtkWidget *dialog;
  GtkWidget *label;
  GtkWidget *button;

  file_dlg = gtk_dialog_new();
  dialog = file_dlg;
  gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  GTK_WINDOW(dialog)->type = GTK_WINDOW_DIALOG;
  gtk_window_set_title(GTK_WINDOW(dialog), _("Confirmation"));
  gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, TRUE);
  gtk_container_set_border_width(GTK_CONTAINER(dialog),10);

  label = gtk_label_new(_("The document is not saved. Do you save it?"));
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE,
		     10);
  gtk_widget_show(label);

  button = gtk_button_new_with_label(_("Yes"));
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),button,
                     TRUE, TRUE, 2);
  gtk_signal_connect(GTK_OBJECT(button), "clicked",
		     GTK_SIGNAL_FUNC(confir_save_yes), doc);

  gtk_widget_show(button);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);

  button = gtk_button_new_with_label(_("No"));
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),button,
                     TRUE, TRUE, 2);
  if (from == FROM_OPEN_FILE_DLG) {
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
		       GTK_SIGNAL_FUNC(confir_save_no_from_open_file_dlg), doc);
  } else if (from == FROM_NEW_CB) {
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
		       GTK_SIGNAL_FUNC(confir_save_no_from_new_cb), doc);
  }
  gtk_widget_show(button);

  button = gtk_button_new_with_label(_("Cancel"));
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button,
		     TRUE, TRUE, 2);
  gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
		     GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dialog));
  gtk_widget_show(button);

  gtk_widget_show(dialog);

  return;
}
Example #18
0
void interface (gint argc, gchar *argv[])
{
  GtkWidget *MenuBar;
  GtkWidget *VBox;
  GtkWidget *HandleBox;

  gtk_set_locale();  
  gtk_init (&argc, &argv);
  Settings = init_settings ();
  MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW(MainWindow), g_strconcat
			(WELCOME_MSG, " ", APP_NAME, " ",
			 VERSION_NUMBER, NULL));
  gtk_window_set_policy (GTK_WINDOW(MainWindow), TRUE, TRUE, FALSE);
  gtk_widget_set_usize (MainWindow, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT);
  gtk_signal_connect (GTK_OBJECT(MainWindow), "delete_event",
		      (GtkSignalFunc) quit, NULL); 
  gtk_signal_connect (GTK_OBJECT(MainWindow), "destroy",
		      (GtkSignalFunc) quit, NULL);
  FileProperties = g_array_new (TRUE, FALSE, sizeof(t_fprops));
  VBox = gtk_vbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER(MainWindow), VBox);
  HandleBox = gtk_handle_box_new();
  gtk_container_set_border_width (GTK_CONTAINER(HandleBox), 2);
  gtk_box_pack_start (GTK_BOX(VBox), HandleBox, FALSE, FALSE, 0);
  init_toolbar (GTK_BOX(VBox));
  MainNotebook = gtk_notebook_new ();
  read_uedit_wordfile (WORDFILE);
  editor_init();
  MenuBar = menubar_new (MainWindow);
  gtk_container_add (GTK_CONTAINER(HandleBox), MenuBar);
  gtk_notebook_popup_enable (GTK_NOTEBOOK(MainNotebook));
  gtk_notebook_set_homogeneous_tabs (GTK_NOTEBOOK(MainNotebook), TRUE);
  gtk_notebook_set_scrollable (GTK_NOTEBOOK(MainNotebook), TRUE);
  gtk_box_pack_start (GTK_BOX(VBox), MainNotebook, TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT(MainNotebook), "switch_page",
		      (GtkSignalFunc) set_title, NULL);
  init_msgbar (GTK_BOX(VBox));
  print_msg ("You're the welcome...");
  command_line (argc, argv);
  autosave (AUTOSAVE_DELAY);
  gtk_widget_show_all (MainWindow);
  if (!MSGBAR_DISPLAY) hide_msgbar ();
  if (!TOOLBAR_DISPLAY) hide_toolbar ();
  gtk_timeout_add (80, (GtkFunction)display_line_column, NULL);
  gtk_main ();
  set_preferences_to_disk (&Settings, NULL);
  gtk_item_factory_dump_rc (g_strconcat (g_get_home_dir (), PATH_SEP_STRING,
					 CONF_DIR, PATH_SEP_STRING,
					 "AccelRC", NULL), NULL, FALSE);
}
Example #19
0
void about (void)
{
  GtkWidget *AboutWindow;
  GtkWidget *PixmapWidget;
  GtkWidget *HSeparator;
  GdkPixmap *Pixmap;
  GdkBitmap *Mask;
  GtkStyle  *Style;
  GtkWidget *Button;
  GtkWidget *AboutLabel;  
  
  AboutWindow = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW(AboutWindow), "About " APP_NAME); 
  gtk_window_set_policy (GTK_WINDOW(AboutWindow), FALSE, FALSE, FALSE);
  gtk_window_set_position (GTK_WINDOW(AboutWindow), GTK_WIN_POS_CENTER);
  gtk_window_set_modal (GTK_WINDOW(AboutWindow), TRUE);
  gtk_window_set_transient_for (GTK_WINDOW(AboutWindow),
				GTK_WINDOW(MainWindow));
  gtk_signal_connect_object (GTK_OBJECT(AboutWindow), "delete_event",
			     (GtkSignalFunc) gtk_widget_destroy,
			     GTK_OBJECT(AboutWindow));
  gtk_signal_connect_object (GTK_OBJECT (AboutWindow), "destroy",
			     (GtkSignalFunc) gtk_widget_destroy,
			     GTK_OBJECT(AboutWindow));
  gtk_widget_realize (AboutWindow);
  Style = gtk_widget_get_style (AboutWindow);
  Pixmap = gdk_pixmap_create_from_xpm_d (AboutWindow->window, &Mask,
					 &Style->bg[GTK_STATE_NORMAL],
					 about_xpm);
  PixmapWidget = gtk_pixmap_new (Pixmap, Mask);
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
		      PixmapWidget, FALSE, FALSE, 0);
  HSeparator = gtk_hseparator_new ();
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
		      HSeparator, FALSE, FALSE, 0);
  AboutLabel = gtk_label_new (APP_NAME " " VERSION_NUMBER "\n"
			      APP_MOTTO "\n\n" APP_URL);
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
		      AboutLabel, FALSE, FALSE, 10);
  Button = gtk_button_new_with_label (" Resume ");
  gtk_signal_connect_object (GTK_OBJECT(Button), "clicked",
			     (GtkSignalFunc) gtk_widget_destroy,
			     GTK_OBJECT(AboutWindow));
  GTK_WIDGET_SET_FLAGS (Button, GTK_CAN_DEFAULT);
  gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> action_area),
		      Button, TRUE, TRUE, 0);
  gtk_widget_grab_default (Button);
  gtk_widget_show_all (AboutWindow);
  print_msg ("Display About window...");
}
static void
gal_define_views_dialog_init (GalDefineViewsDialog *dialog)
{
	GladeXML *gui;
	GtkWidget *widget;

	gchar *filename = g_build_filename (EVOLUTION_GLADEDIR,
					    "gal-define-views.glade",
					    NULL);

	dialog->collection = NULL;

	gui = glade_xml_new (filename, NULL, GETTEXT_PACKAGE);
	g_free (filename);
	dialog->gui = gui;

	widget = glade_xml_get_widget(gui, "table-top");
	if (!widget) {
		return;
	}

	g_object_ref (widget);
	gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
	gtk_window_set_default_size (GTK_WINDOW (dialog), 360, 270);
	gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
	gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), widget, TRUE, TRUE, 0);
	g_object_unref(widget);

	gtk_dialog_add_buttons (GTK_DIALOG (dialog),
				GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
				NULL);

	dialog->treeview = GTK_TREE_VIEW (glade_xml_get_widget (dialog->gui, "treeview1"));
        gtk_tree_view_set_reorderable (GTK_TREE_VIEW (dialog->treeview), FALSE);
	gtk_tree_view_set_headers_visible (dialog->treeview, TRUE);

	gtk_window_set_policy (GTK_WINDOW (dialog), FALSE, TRUE, FALSE);

	gdvd_connect_signal(dialog, "button-new",    "clicked", G_CALLBACK(gdvd_button_new_callback));
	gdvd_connect_signal(dialog, "button-modify", "clicked", G_CALLBACK(gdvd_button_modify_callback));
	gdvd_connect_signal(dialog, "button-delete", "clicked", G_CALLBACK(gdvd_button_delete_callback));
#if 0
	gdvd_connect_signal(dialog, "button-copy",   "clicked", G_CALLBACK(gdvd_button_copy_callback));
#endif
	gdvd_connect_signal(dialog, "treeview1", "cursor-changed", G_CALLBACK(gdvd_cursor_changed_callback));
	g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), NULL);

	gtk_widget_show (GTK_WIDGET (dialog));
}
Example #21
0
void preference_dlg(void) {
  GtkWidget *button;
  GtkWidget *bbox;
  GtkWidget *frame;

  prefer_dialog = gtk_dialog_new();
  gtk_window_set_modal(GTK_WINDOW(prefer_dialog), TRUE);
  GTK_WINDOW(prefer_dialog)->type = GTK_WINDOW_DIALOG;
  gtk_window_set_title(GTK_WINDOW(prefer_dialog), _("Preference"));
  gtk_window_set_policy(GTK_WINDOW(prefer_dialog), FALSE, FALSE, TRUE);
  gtk_container_set_border_width(GTK_CONTAINER(prefer_dialog), 10);
  gtk_window_position(GTK_WINDOW(prefer_dialog), GTK_WIN_POS_MOUSE);
  gtk_widget_show(prefer_dialog);
  
  frame = gtk_frame_new(_("Not implemented!!"));
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(prefer_dialog)->vbox), frame , TRUE, TRUE, 2);
  gtk_widget_show(frame);

  bbox = gtk_hbutton_box_new();
  gtk_container_set_border_width(GTK_CONTAINER(bbox), 0);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(prefer_dialog)->action_area), bbox, TRUE, TRUE, 2);
  gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
  gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 10);
  gtk_button_box_set_child_size(GTK_BUTTON_BOX(bbox), 85, 20);
  gtk_widget_show(bbox);
  button = gtk_button_new_with_label(_("OK"));
  gtk_container_add(GTK_CONTAINER(bbox),button);
  gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
		     GTK_SIGNAL_FUNC(gtk_widget_destroy),
		     GTK_OBJECT(prefer_dialog));
  gtk_widget_show(button);
  GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default(button);

  button = gtk_button_new_with_label(_("Apply"));
  gtk_container_add(GTK_CONTAINER(bbox),button);
  gtk_signal_connect(GTK_OBJECT(button), "clicked",
		     GTK_SIGNAL_FUNC(prefer_dlg_apply),
		     NULL);
  gtk_widget_show(button);

  button = gtk_button_new_with_label(_("Close"));
  gtk_container_add(GTK_CONTAINER(bbox),button);
  gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
		     GTK_SIGNAL_FUNC(gtk_widget_destroy),
		     GTK_OBJECT(prefer_dialog));
  gtk_widget_show(button);

  return;
}
Example #22
0
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);
}
Example #23
0
void 
ghack_menu_window_start_menu (GtkWidget *menuWin, gpointer data)
{
    GtkWidget *frame1, *swin, *clist;
    MenuWinType isMenu;
    
    g_assert (menuWin != NULL);
    g_assert (data == NULL);

    /* destroy existing menu data, if any */
    frame1 = gtk_object_get_data (GTK_OBJECT (menuWin), "frame1");
    if (frame1)
      gtk_widget_destroy (frame1);
 
    isMenu = MenuMenu;
    gtk_object_set_data (GTK_OBJECT (menuWin), "isMenu",
    			 GINT_TO_POINTER (isMenu));

    gtk_widget_set_usize (GTK_WIDGET (menuWin), 500, 400);
    gtk_window_set_policy (GTK_WINDOW (menuWin), TRUE, TRUE, FALSE);

    frame1 = gtk_frame_new ("Make your selection");
    g_assert (frame1 != NULL);
    gtk_object_set_data (GTK_OBJECT(menuWin), "frame1", frame1);
    gtk_widget_show (GTK_WIDGET (frame1));
    gtk_container_set_border_width (GTK_CONTAINER (frame1), 5);
    gtk_box_pack_start (GTK_BOX (GNOME_DIALOG(menuWin)->vbox), frame1,
                        TRUE, TRUE, 0);
    
    swin = gtk_scrolled_window_new (NULL, NULL);
    g_assert (swin != NULL);
    gtk_object_set_data (GTK_OBJECT(menuWin), "swin", swin);
    gtk_widget_show (GTK_WIDGET (swin));
    gtk_container_add (GTK_CONTAINER (frame1), swin);

    clist = gtk_clist_new (4);
    g_assert (clist != NULL);
    gtk_object_set_data (GTK_OBJECT(menuWin), "clist", clist);
    gtk_widget_show (GTK_WIDGET (clist));
    gtk_container_add (GTK_CONTAINER (swin), clist);

    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
	    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

    gtk_signal_connect (GTK_OBJECT (clist), "select_row",
	    GTK_SIGNAL_FUNC (ghack_menu_row_selected), NULL);
    gtk_object_set_data (GTK_OBJECT (clist), "numItems",
			    GINT_TO_POINTER (-1));
}    
Example #24
0
static void show_options_window()
{
   GtkWidget *box, *vbox, *pop_window;
   static int show = 0;

   if (show) return;
   if (verbose) g_print("Showing options window\n");
   show=1;

   pop_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

   gtk_window_set_title (GTK_WINDOW(pop_window), "Linux Video Studio TV - Control");
   gtk_container_set_border_width (GTK_CONTAINER (pop_window), 15);

   vbox = gtk_vbox_new(FALSE, 20);

   box = get_video_sliders_widget();
   gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 0);
   gtk_widget_show(box);

   box = gtk_hseparator_new();
   gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 0);
   gtk_widget_show(box);

   box = get_video_channels_widget();
   gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 0);
   gtk_widget_show(box);

//   box = gtk_hseparator_new();
//   gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 0);
//   gtk_widget_show(box);

   box = get_settings_button_widget();
   gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 0);
   gtk_widget_show(box);

   gtk_container_add (GTK_CONTAINER (pop_window), vbox);
   gtk_widget_show(vbox);

   gtk_signal_connect(GTK_OBJECT(pop_window), "unrealize",
      GTK_SIGNAL_FUNC(settings_window_unrealize), (gpointer)(&show));

   gtk_window_set_policy(GTK_WINDOW(pop_window), 0, 0, 0);
   gtk_window_set_transient_for(GTK_WINDOW(pop_window), GTK_WINDOW(window)); /* ? */
   gtk_widget_show(pop_window);
}
Example #25
0
void prefs_dialog_create(PrefsDialog *dialog)
{
	GtkWidget *window;
	GtkWidget *vbox;
	GtkWidget *notebook;

	GtkWidget *confirm_area;
	GtkWidget *ok_btn;
	GtkWidget *cancel_btn;
	GtkWidget *apply_btn;

	g_return_if_fail(dialog != NULL);

	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width (GTK_CONTAINER (window), 6);
	gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_modal (GTK_WINDOW (window), TRUE);
	gtk_window_set_policy (GTK_WINDOW(window), FALSE, TRUE, FALSE);

	vbox = gtk_vbox_new (FALSE, 6);
	gtk_widget_show(vbox);
	gtk_container_add (GTK_CONTAINER (window), vbox);

	notebook = gtk_notebook_new ();
	gtk_widget_show(notebook);
	gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (notebook), 2);
	/* GTK_WIDGET_UNSET_FLAGS (notebook, GTK_CAN_FOCUS); */
	gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);

	gtkut_stock_button_set_create(&confirm_area,
				      &ok_btn, GTK_STOCK_OK,
				      &cancel_btn, GTK_STOCK_CANCEL,
				      &apply_btn, GTK_STOCK_APPLY);
	gtk_widget_show(confirm_area);
	gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
	gtk_widget_grab_default(ok_btn);

	dialog->window       = window;
	dialog->notebook     = notebook;
	dialog->confirm_area = confirm_area;
	dialog->ok_btn       = ok_btn;
	dialog->cancel_btn   = cancel_btn;
	dialog->apply_btn    = apply_btn;
}
Example #26
0
static gint
gtk_dialog_realized_callback( GtkWidget * WXUNUSED(widget), wxPopupWindow *win )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    /* all this is for Motif Window Manager "hints" and is supposed to be
       recognized by other WM as well. not tested. */
    long decor = (long) GDK_DECOR_BORDER;
    long func = (long) GDK_FUNC_MOVE ;

    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);

    gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);

    return FALSE;
}
Example #27
0
/* Sets resize policy */
int
clip_GTK_WINDOWSETPOLICY(ClipMachine * cm)
{
	C_widget *cwin = _fetch_cw_arg(cm);
	gboolean AutoShrink = FALSE, AllowShrink = TRUE, AllowGrow = TRUE;
	CHECKOPT(2,LOGICAL_t);
	CHECKOPT(3,LOGICAL_t);
	CHECKOPT(4,LOGICAL_t);
	CHECKCWID(cwin,GTK_IS_WINDOW);
	if (_clip_parinfo(cm,2)==LOGICAL_t) AutoShrink  = _clip_parl(cm,2);
	if (_clip_parinfo(cm,3)==LOGICAL_t) AllowGrow   = _clip_parl(cm,3);
	if (_clip_parinfo(cm,4)==LOGICAL_t) AllowShrink = _clip_parl(cm,4);
	gtk_window_set_policy(GTK_WINDOW(cwin->widget),
		AllowShrink,AllowGrow,AutoShrink);
	return 0;
err:
	return 1;
}
Example #28
0
void
sp_help_about (void)
{
	SPDocument *doc;
	SPObject *title;
	GtkWidget *v;
	gint width, height;

	if (!w) {

	doc = sp_document_new (INKSCAPE_PIXMAPDIR "/about.svg", FALSE, TRUE);
	g_return_if_fail (doc != NULL);
	title = sp_document_lookup_id (doc, "title");
	if (title && SP_IS_TEXT (title)) {
		gchar *t;
		t = g_strdup_printf ("Inkscape %s", INKSCAPE_VERSION);
		sp_text_set_repr_text_multiline (SP_TEXT (title), t);
		g_free (t);
	}
	sp_document_ensure_up_to_date (doc);

	w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (w), _("About Inkscape"));

        width = INK_STATIC_CAST( gint, CLAMP( sp_document_width(doc), WINDOW_MIN, WINDOW_MAX ) );
        height = INK_STATIC_CAST( gint, CLAMP( sp_document_height(doc), WINDOW_MIN, WINDOW_MAX ) );
        gtk_window_set_default_size (GTK_WINDOW (w), width, height );
				gtk_window_set_position(GTK_WINDOW(w), GTK_WIN_POS_CENTER);

#if 1
	gtk_window_set_policy (GTK_WINDOW (w), TRUE, TRUE, FALSE);
#endif
	gtk_signal_connect (GTK_OBJECT (w), "delete_event", GTK_SIGNAL_FUNC (sp_help_about_delete), NULL);

	v = sp_svg_view_widget_new (doc);
	sp_svg_view_widget_set_resize (SP_SVG_VIEW_WIDGET (v), FALSE, sp_document_width (doc), sp_document_height (doc));
	sp_document_unref (doc);
	gtk_widget_show (v);
	gtk_container_add (GTK_CONTAINER (w), v);

	}

	gtk_window_present ((GtkWindow *) w);
}
Example #29
0
/**
 * crée la fenêtre principale de grisbi.
 *
 *
 *
 * */
GtkWidget *gsb_main_create_main_window ( void )
{
    GtkWidget *vbox;
    GtkWidget *status_bar;

    /* create the toplevel window */
    run.window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );

    g_signal_connect ( G_OBJECT ( run.window ),
                        "delete_event",
                        G_CALLBACK ( main_window_delete_event ),
                        NULL);
    g_signal_connect ( G_OBJECT ( run.window ),
                        "destroy",
                        G_CALLBACK ( main_window_destroy_event ),
                        NULL);
    g_signal_connect ( G_OBJECT ( run.window ),
                        "window-state-event",
                        G_CALLBACK (gsb_grisbi_change_state_window),
                        NULL );

    g_signal_connect ( G_OBJECT ( run.window ),
                        "key-press-event",
                        G_CALLBACK ( main_window_key_press_event ),
                        NULL );

    gtk_window_set_policy ( GTK_WINDOW ( run.window ), TRUE, TRUE, FALSE );

    /* create the main window : a vbox */
    vbox = gtk_vbox_new ( FALSE, 0 );
    g_object_set_data ( G_OBJECT ( run.window ), "main_vbox", vbox );
    gtk_container_add ( GTK_CONTAINER ( run.window ), vbox );
    g_signal_connect ( G_OBJECT ( vbox ),
                        "destroy",
                        G_CALLBACK ( gtk_widget_destroyed ),
                        &vbox );
    gtk_widget_show ( vbox );

    /* We create the statusbar first. */
    status_bar = gsb_new_statusbar ( );
    gtk_box_pack_end ( GTK_BOX ( vbox ), status_bar, FALSE, FALSE, 0 );

    return vbox;
}
Example #30
0
void ghack_menu_window_put_string(GtkWidget *menuWin, int attr,
                                  const char* text, gpointer data)
{
    GnomeLess *gless;
    MenuWinType isMenu;

    if (text == NULL)
        return;
    
    isMenu = (MenuWinType) GPOINTER_TO_INT
    	(gtk_object_get_data (GTK_OBJECT (menuWin), "isMenu"));

    if (isMenu == MenuText) {
      gless = GNOME_LESS (gtk_object_get_data (GTK_OBJECT (menuWin), "gless"));
      g_assert (gless != NULL);
      g_assert (gless->text != NULL);
      g_assert (GTK_IS_TEXT (gless->text));

      /* Don't bother with attributes yet */
      gtk_text_insert (GTK_TEXT (gless->text), NULL, NULL, NULL, text, -1);
      gtk_text_insert (GTK_TEXT (gless->text), NULL, NULL, NULL, "\n", -1);

    }

    else if (isMenu == MenuUnknown) {
      isMenu = MenuText;
      gtk_object_set_data (GTK_OBJECT (menuWin), "isMenu",
      			   GINT_TO_POINTER (isMenu));

      gtk_widget_set_usize (GTK_WIDGET (menuWin), 500, 400);
      gtk_window_set_policy (GTK_WINDOW (menuWin), TRUE, TRUE, FALSE);
    
      gless = GNOME_LESS (gnome_less_new ());
      g_assert (gless != NULL);
      gtk_object_set_data (GTK_OBJECT (menuWin), "gless", gless);
      gtk_widget_show (GTK_WIDGET (gless));

      gnome_less_show_string (gless, text);
      gtk_text_insert (GTK_TEXT (gless->text), NULL, NULL, NULL, "\n", -1);

      gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (menuWin)->vbox),
      			  GTK_WIDGET (gless), TRUE, TRUE, 0);
    }
}