Beispiel #1
0
void orcaGtk::alloc()/*{{{*/
{
	switch(type)
	{
	case GUI_WINDOW:
		handle = gtk_window_new(GTK_WINDOW_TOPLEVEL);
		gtk_window_set_title(GTK_WINDOW(handle), text.c_str());
		gtk_window_set_default_size(GTK_WINDOW(handle), 800, 600);
		gtk_window_set_position(GTK_WINDOW(handle), GTK_WIN_POS_CENTER);
		g_signal_connect_swapped(G_OBJECT(handle), "destroy",
								 G_CALLBACK(gtk_main_quit), G_OBJECT(handle));
		break;

	case GUI_FIXED:
		handle = gtk_fixed_new();
		break;

	case GUI_VBOX:
		handle = gtk_vbox_new(FALSE, 0);
		break;

	case GUI_HBOX:
		handle = gtk_hbox_new(FALSE, 0);
		break;

	case GUI_HSEP:
		handle = gtk_hseparator_new();
		break;

	case GUI_BUTTON:
		handle = gtk_button_new_with_label(text.c_str());
		gtk_widget_set_size_request(handle, 100, 100);
		break;

	case GUI_CHECK:
		handle = gtk_check_button_new_with_label(text.c_str());
		break;

	case GUI_RADIO:
		handle = gtk_radio_button_new_with_label (NULL, text.c_str());
		break;

	case GUI_COMBO:
		handle = gtk_combo_box_new_text();
		break;

	case GUI_LABEL:
		handle = gtk_label_new(text.c_str());
		break;

	case GUI_ENTRY:
		handle = gtk_entry_new();
		break;

	case GUI_TEXT:
		handle = gtk_text_view_new();
		break;

	case GUI_MENUBAR:
		handle = gtk_menu_bar_new();
		break;

	case GUI_LIST:
	case GUI_TREE:
		handle = gtk_tree_view_new();
		gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(handle), TRUE);
		break;

	case GUI_SCROLL:
		handle = gtk_scrolled_window_new(NULL, NULL);
		break;

	case GUI_TABLE:
		handle = NULL;
		break;

	case GUI_IMAGE:
		handle = gtk_image_new();
		break;

	case GUI_STATUSBAR:
		handle = gtk_statusbar_new();
		break;
	}
}
Beispiel #2
0
static int gtkToggleMapMethod(Ihandle* ih)
{
  Ihandle* radio = iupRadioFindToggleParent(ih);
  char *value;
  int is3state = 0;

  if (!ih->parent)
    return IUP_ERROR;

  value = iupAttribGet(ih, "IMAGE");
  if (value)
    ih->data->type = IUP_TOGGLE_IMAGE;
  else
    ih->data->type = IUP_TOGGLE_TEXT;

  if (radio)
  {
    GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON");
    if (last_tg)
      ih->handle = gtk_radio_button_new_from_widget(last_tg);
    else
      ih->handle = gtk_radio_button_new(NULL);
    iupAttribSet(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle);

    /* make sure it has at least one name */
    if (!iupAttribGetHandleName(ih))
      iupAttribSetHandleName(ih);

    ih->data->is_radio = 1;
  }
  else
  {
    if (ih->data->type == IUP_TOGGLE_TEXT)
    {
      ih->handle = gtk_check_button_new();

      if (iupAttribGetBoolean(ih, "3STATE"))
        is3state = 1;
    }
    else
      ih->handle = gtk_toggle_button_new();
  }

  if (!ih->handle)
    return IUP_ERROR;

  if (ih->data->type == IUP_TOGGLE_TEXT)
  {
    gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL));
    gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE);
  }
  else
  {
    gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new());
    gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE);
  }

  iupgtkClearSizeStyleCSS(ih->handle);

  /* add to the parent, all GTK controls must call this. */
  iupgtkAddToParent(ih);

  if (!iupAttribGetBoolean(ih, "CANFOCUS"))
    iupgtkSetCanFocus(ih->handle, 0);

  if (ih->data->type == IUP_TOGGLE_IMAGE && ih->data->flat)
  {
    gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE);

    g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih);
    g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih);
  }
  else
  {
    g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
    g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
  }

  g_signal_connect(G_OBJECT(ih->handle), "focus-in-event",     G_CALLBACK(iupgtkFocusInOutEvent), ih);
  g_signal_connect(G_OBJECT(ih->handle), "focus-out-event",    G_CALLBACK(iupgtkFocusInOutEvent), ih);
  g_signal_connect(G_OBJECT(ih->handle), "key-press-event",    G_CALLBACK(iupgtkKeyPressEvent), ih);
  g_signal_connect(G_OBJECT(ih->handle), "show-help",          G_CALLBACK(iupgtkShowHelp), ih);

  g_signal_connect(G_OBJECT(ih->handle), "toggled",            G_CALLBACK(gtkToggleToggled), ih);

  if (ih->data->type == IUP_TOGGLE_IMAGE || is3state)
  {
    g_signal_connect(G_OBJECT(ih->handle), "button-press-event",  G_CALLBACK(gtkToggleButtonEvent), ih);
    g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih);
  }

  if (is3state)
  {
    g_signal_connect(G_OBJECT(ih->handle), "key-press-event",  G_CALLBACK(gtkToggleKeyEvent), ih);
    g_signal_connect(G_OBJECT(ih->handle), "key-release-event",  G_CALLBACK(gtkToggleKeyEvent), ih);
  }

  gtk_widget_realize(ih->handle);

  /* update a mnemonic in a label if necessary */
  iupgtkUpdateMnemonic(ih);

  return IUP_NOERROR;
}
Beispiel #3
0
GtkWindow* create_notification(Settings settings) {
    WindowData *windata;

    GtkWidget   *win;

#ifdef USE_COMPOSITE
    GdkColormap *colormap;
    GdkScreen   *screen;
#endif

    // create WindowData object
    windata = g_new0(WindowData, 1);

    // create GTK window
    win = gtk_window_new(GTK_WINDOW_POPUP);
    gtk_window_set_resizable(GTK_WINDOW (win), FALSE);
    gtk_widget_set_app_paintable(win, TRUE);
    windata->win = win;
    windata->settings = settings;

    // connect signals
    g_signal_connect (G_OBJECT (win),
                      "style-set",
                      G_CALLBACK (on_style_set),
                      windata);
    g_signal_connect (G_OBJECT (win),
                      "map-event",
                      G_CALLBACK (on_window_map),
                      windata);
    g_signal_connect (G_OBJECT (win),
                      "expose-event",
                      G_CALLBACK (on_window_expose),
                      windata);
    g_signal_connect (G_OBJECT (win),
                      "realize",
                      G_CALLBACK (on_window_realize),
                      windata);

    // prepare composite
    windata->composited = FALSE;
#ifdef USE_COMPOSITE
    screen = gtk_window_get_screen (GTK_WINDOW (win));
    colormap = gdk_screen_get_rgba_colormap (screen);
    if (colormap != NULL) {
        gtk_widget_set_colormap (win, colormap);
        if (gdk_screen_is_composited (screen)) {
            windata->composited = TRUE;
        }
    }
    g_signal_connect(win,
                     "composited-changed",
                     G_CALLBACK (on_composited_changed),
                     windata);
#endif

    gtk_window_set_title(GTK_WINDOW (win), "Notification");
    gtk_window_set_type_hint(GTK_WINDOW (win),
                             GDK_WINDOW_TYPE_HINT_NOTIFICATION);
    gtk_window_set_default_size(GTK_WINDOW(win), 400, 400);
    gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_CENTER);

    g_object_set_data_full (G_OBJECT (win),
                            "windata", windata,
                            (GDestroyNotify)destroy_windata);

    g_signal_connect (G_OBJECT (win),
                      "configure-event",
                      G_CALLBACK (on_configure_event),
                      windata);

    windata->main_vbox = gtk_vbox_new(FALSE, 0);
    g_signal_connect(G_OBJECT(windata->main_vbox),
                     "style-set",
                     G_CALLBACK(on_style_set),
                     windata);
    gtk_widget_show(windata->main_vbox);
    gtk_container_add(GTK_CONTAINER(win), windata->main_vbox);
    gtk_container_set_border_width(GTK_CONTAINER(windata->main_vbox), DEFAULT_BORDER);

//    windata->main_hbox = gtk_hbox_new (FALSE, 0);
//    gtk_widget_show (windata->main_hbox);
//    gtk_box_pack_start (GTK_BOX (main_vbox),
//                        windata->main_hbox,
//                        FALSE, FALSE, 0);

    // icon box
    windata->iconbox = gtk_alignment_new (0.5f, 0, 0, 0);
    gtk_widget_show (windata->iconbox);
    gtk_alignment_set_padding (GTK_ALIGNMENT (windata->iconbox),
                               0, IMAGE_PADDING, 0, 0);
    gtk_box_pack_start (GTK_BOX (windata->main_vbox),
                        windata->iconbox,
                        FALSE, FALSE, 0);
    gtk_widget_set_size_request (windata->iconbox, BODY_X_OFFSET, -1);

    // icon
    windata->icon = gtk_image_new ();
    gtk_widget_show (windata->icon);
    gtk_container_add (GTK_CONTAINER (windata->iconbox), windata->icon);

    // progress bar box
    windata->progressbarbox = gtk_alignment_new (0.5f, 0, 0, 0);
    gtk_widget_show (windata->progressbarbox);
//    gtk_alignment_set_padding (GTK_ALIGNMENT (windata->iconbox),
//                               5, 0, 0, 0);
    gtk_box_pack_start (GTK_BOX (windata->main_vbox),
                        windata->progressbarbox,
                        FALSE, FALSE, 0);
    gtk_widget_set_size_request (windata->progressbarbox, BODY_X_OFFSET, -1);

    // progress bar
    windata->progressbar = gtk_image_new ();
    gtk_widget_show (windata->progressbar);
    gtk_container_add (GTK_CONTAINER (windata->progressbarbox), windata->progressbar);

    return GTK_WINDOW(win);
}
Beispiel #4
0
static void prefs_themes_create_widget(PrefsPage *page, GtkWindow *window, gpointer data)
{
	ThemesPage *prefs_themes = (ThemesPage *)page;
	ThemesData *tdata = prefs_themes_data;

	GtkWidget *vbox1;
	GtkWidget *frame1;
	GtkWidget *vbox2;
	GtkWidget *hbox3;
	GtkWidget *menu_themes;
	GtkWidget *btn_install;
	GtkWidget *btn_more;
	GtkWidget *label_global_status;
	GtkWidget *frame_info;
	GtkWidget *table1;
	GtkWidget *label1;
	GtkWidget *label2;
	GtkWidget *label3;
	GtkWidget *label_name;
	GtkWidget *label_author;
	GtkWidget *label_url;
	GtkWidget *label4;
	GtkWidget *label_status;
	GtkWidget *frame_preview;
	GtkWidget *hbox1;
	GtkWidget *icon_1;
	GtkWidget *icon_2;
	GtkWidget *icon_3;
	GtkWidget *icon_4;
	GtkWidget *icon_5;
	GtkWidget *icon_6;
	GtkWidget *icon_7;
	GtkWidget *frame_buttons;
	GtkWidget *hbuttonbox1;
	GtkWidget *btn_use;
	GtkWidget *btn_remove;
	GtkCellRenderer *renderer;

	vbox1 = gtk_vbox_new (FALSE, VSPACING);
	gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
	gtk_widget_show (vbox1);

	vbox2 = gtkut_get_options_frame(vbox1, &frame1, _("Selector"));

	hbox3 = gtk_hbox_new (FALSE, 5);
	gtk_widget_show (hbox3);
	gtk_box_pack_start (GTK_BOX (vbox2), hbox3, FALSE, FALSE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (hbox3), 5);

	menu_themes = gtk_combo_box_new();
	gtk_widget_show (menu_themes);
	gtk_box_pack_start (GTK_BOX (hbox3), menu_themes, FALSE, FALSE, 0);

	btn_install = gtk_button_new_with_label (_("Install new..."));
	gtk_widget_show (btn_install);
	gtk_box_pack_start (GTK_BOX (hbox3), btn_install, FALSE, FALSE, 0);
	gtkut_widget_set_can_default (btn_install, TRUE);

	btn_more = gtkut_get_link_btn((GtkWidget *)window, THEMES_URI, _("Get more..."));
	gtk_widget_show (btn_more);
	gtk_box_pack_start (GTK_BOX (hbox3), btn_more, FALSE, FALSE, 0);

	label_global_status = gtk_label_new ("");
	gtk_widget_show (label_global_status);
	gtk_box_pack_start (GTK_BOX (vbox2), label_global_status, FALSE, FALSE, 0);
	gtk_label_set_justify (GTK_LABEL (label_global_status), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment (GTK_MISC (label_global_status), 0, 0.5);
	gtk_misc_set_padding (GTK_MISC (label_global_status), 6, 0);

	PACK_FRAME(vbox1, frame_info, _("Information"));

	table1 = gtk_table_new (4, 2, FALSE);
	gtk_widget_show (table1);
	gtk_container_add (GTK_CONTAINER (frame_info), table1);

	label1 = gtk_label_new (_("Name: "));
	gtk_widget_show (label1);
	gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 8, 2);
	gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);

	label2 = gtk_label_new (_("Author: "));
	gtk_widget_show (label2);
	gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 8, 2);
	gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);

	label3 = gtk_label_new (_("URL:"));
	gtk_widget_show (label3);
	gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 8, 2);
	gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);

	label_name = gtk_label_new ("");
	gtk_widget_show (label_name);
	gtk_table_attach (GTK_TABLE (table1), label_name, 1, 2, 0, 1,
			(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
			(GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label_name), 0, 0.5);

	label_author = gtk_label_new ("");
	gtk_widget_show (label_author);
	gtk_table_attach (GTK_TABLE (table1), label_author, 1, 2, 1, 2,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label_author), 0, 0.5);

	label_url = gtk_label_new ("");
	gtk_widget_show (label_url);
	gtk_table_attach (GTK_TABLE (table1), label_url, 1, 2, 2, 3,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label_url), 0, 0.5);

	label4 = gtk_label_new (_("Status:"));
	gtk_widget_show (label4);
	gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 8, 2);
	gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);

	label_status = gtk_label_new ("");
	gtk_widget_show (label_status);
	gtk_table_attach (GTK_TABLE (table1), label_status, 1, 2, 3, 4,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (0), 0, 0);
	gtk_misc_set_alignment (GTK_MISC (label_status), 0, 0.5);

	PACK_FRAME(vbox1, frame_preview, _("Preview"));

	hbox1 = gtk_hbox_new (FALSE, 0);
	gtk_widget_show (hbox1);
	gtk_container_add (GTK_CONTAINER (frame_preview), hbox1);

	icon_1 = gtk_image_new();
	gtk_widget_show (icon_1);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_1, TRUE, TRUE, 2);
	gtk_misc_set_padding (GTK_MISC (icon_1), 0, 5);

	icon_2 = gtk_image_new();
	gtk_widget_show (icon_2);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_2, TRUE, TRUE, 2);
	gtk_misc_set_padding (GTK_MISC (icon_2), 0, 5);

	icon_3 = gtk_image_new();
	gtk_widget_show (icon_3);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_3, TRUE, TRUE, 2);
	gtk_misc_set_padding (GTK_MISC (icon_3), 0, 5);

	icon_4 = gtk_image_new();
	gtk_widget_show (icon_4);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_4, TRUE, TRUE, 2);
	gtk_misc_set_padding (GTK_MISC (icon_4), 0, 5);

	icon_5 = gtk_image_new();
	gtk_widget_show (icon_5);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_5, TRUE, TRUE, 2);
	gtk_misc_set_padding (GTK_MISC (icon_5), 0, 5);

	icon_6 = gtk_image_new();
	gtk_widget_show (icon_6);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_6, TRUE, TRUE, 0);
	gtk_misc_set_padding (GTK_MISC (icon_6), 0, 5);

	icon_7 = gtk_image_new();
	gtk_widget_show (icon_7);
	gtk_box_pack_start (GTK_BOX (hbox1), icon_7, TRUE, TRUE, 0);
	gtk_misc_set_padding (GTK_MISC (icon_7), 0, 5);

	PACK_FRAME(vbox1, frame_buttons, _("Actions"));

	hbuttonbox1 = gtk_hbutton_box_new ();
	gtk_widget_show (hbuttonbox1);
	gtk_container_add (GTK_CONTAINER (frame_buttons), hbuttonbox1);
	gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 5);
	gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_START);
	gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 5);

	btn_use = gtk_button_new_with_label (_("Use this"));
	gtk_widget_show (btn_use);
	gtk_container_add (GTK_CONTAINER (hbuttonbox1), btn_use);
	gtkut_widget_set_can_default (btn_use, TRUE);

	btn_remove = gtk_button_new_with_label (_("Remove"));
	gtk_widget_show (btn_remove);
	gtk_container_add (GTK_CONTAINER (hbuttonbox1), btn_remove);
	gtkut_widget_set_can_default (btn_remove, TRUE);

	g_signal_connect(G_OBJECT(btn_use), "clicked",
			 G_CALLBACK(prefs_themes_btn_use_clicked_cb),
			 NULL);
	g_signal_connect(G_OBJECT(btn_remove), "clicked",
			 G_CALLBACK(prefs_themes_btn_remove_clicked_cb),
			 NULL);
	g_signal_connect(G_OBJECT(btn_install), "clicked",
			 G_CALLBACK(prefs_themes_btn_install_clicked_cb),
			 NULL);

	prefs_themes->window = GTK_WIDGET(window);
	
	prefs_themes->name   = label_name;
	prefs_themes->author = label_author;
	prefs_themes->url    = label_url;
	prefs_themes->status = label_status;
	prefs_themes->global = label_global_status;

	prefs_themes->icons[0] = icon_1;
	prefs_themes->icons[1] = icon_2;
	prefs_themes->icons[2] = icon_3;
	prefs_themes->icons[3] = icon_4;
	prefs_themes->icons[4] = icon_5;
	prefs_themes->icons[5] = icon_6;
	prefs_themes->icons[6] = icon_7;
	
	prefs_themes->btn_use     = btn_use;
	prefs_themes->btn_remove  = btn_remove;
	prefs_themes->btn_install = btn_install;
	prefs_themes->btn_more    = btn_more;

	prefs_themes->op_menu     = menu_themes;

	prefs_themes->page.widget = vbox1;
	
	prefs_themes_set_themes_menu(GTK_COMBO_BOX(menu_themes), tdata);
	renderer = gtk_cell_renderer_text_new();
	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(menu_themes), renderer, TRUE);
	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(menu_themes), renderer,
					"text", 0, NULL);
	
	prefs_themes_get_theme_info(tdata);
	prefs_themes_display_global_stats(tdata);
}
Beispiel #5
0
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
                           const wxString& defaultDir,
                           const wxString& defaultFileName,
                           const wxString& wildCard,
                           long style, const wxPoint& pos,
                           const wxSize& sz,
                           const wxString& name)
    : wxFileDialogBase()
{
    parent = GetParentForModalDialog(parent, style);

    if (!wxFileDialogBase::Create(parent, message, defaultDir, defaultFileName,
                                  wildCard, style, pos, sz, name))
    {
        return;
    }

    if (!PreCreation(parent, pos, wxDefaultSize) ||
        !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style,
                wxDefaultValidator, wxT("filedialog")))
    {
        wxFAIL_MSG( wxT("wxFileDialog creation failed") );
        return;
    }

    GtkFileChooserAction gtk_action;
    GtkWindow* gtk_parent = NULL;
    if (parent)
        gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) );

    const gchar* ok_btn_stock;
    if ( style & wxFD_SAVE )
    {
        gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE;
        ok_btn_stock = GTK_STOCK_SAVE;
    }
    else
    {
        gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN;
        ok_btn_stock = GTK_STOCK_OPEN;
    }

    m_widget = gtk_file_chooser_dialog_new(
                   wxGTK_CONV(m_message),
                   gtk_parent,
                   gtk_action,
                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                   ok_btn_stock, GTK_RESPONSE_ACCEPT,
                   NULL);
    g_object_ref(m_widget);
    GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget);

    m_fc.SetWidget(file_chooser);

    gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT);

    if ( style & wxFD_MULTIPLE )
        gtk_file_chooser_set_select_multiple(file_chooser, true);

    // gtk_widget_hide_on_delete is used here to avoid that Gtk automatically
    // destroys the dialog when the user press ESC on the dialog: in that case
    // a second call to ShowModal() would result in a bunch of Gtk-CRITICAL
    // errors...
    g_signal_connect(m_widget,
                    "delete_event",
                    G_CALLBACK (gtk_widget_hide_on_delete),
                    this);

    // local-only property could be set to false to allow non-local files to be
    // loaded. In that case get/set_uri(s) should be used instead of
    // get/set_filename(s) everywhere and the GtkFileChooserDialog should
    // probably also be created with a backend, e.g. "gnome-vfs", "default", ...
    // (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept
    // as the default - true:
    // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);

    g_signal_connect (m_widget, "response",
        G_CALLBACK (gtk_filedialog_response_callback), this);


    // deal with extensions/filters
    SetWildcard(wildCard);

    wxString defaultFileNameWithExt = defaultFileName;
    if ( !wildCard.empty() && !defaultFileName.empty() &&
            !wxFileName(defaultFileName).HasExt() )
    {
        // append the default extension to the initial file name: GTK won't do
        // it for us by default (unlike e.g. MSW)
        const wxString defaultExt = m_fc.GetCurrentWildCard().AfterFirst('.');
        if ( defaultExt.find_first_of("?*") == wxString::npos )
            defaultFileNameWithExt += "." + defaultExt;
    }


    // if defaultDir is specified it should contain the directory and
    // defaultFileName should contain the default name of the file, however if
    // directory is not given, defaultFileName contains both
    wxFileName fn;
    if ( defaultDir.empty() )
        fn.Assign(defaultFileNameWithExt);
    else if ( !defaultFileNameWithExt.empty() )
        fn.Assign(defaultDir, defaultFileNameWithExt);
    else
        fn.AssignDir(defaultDir);

    // set the initial file name and/or directory
    fn.MakeAbsolute(); // GTK+ needs absolute path
    const wxString dir = fn.GetPath();
    if ( !dir.empty() )
    {
        gtk_file_chooser_set_current_folder(file_chooser, dir.fn_str());
    }

    const wxString fname = fn.GetFullName();
    if ( style & wxFD_SAVE )
    {
        if ( !fname.empty() )
        {
            gtk_file_chooser_set_current_name(file_chooser, fname.fn_str());
        }

#if GTK_CHECK_VERSION(2,7,3)
        if ((style & wxFD_OVERWRITE_PROMPT) && !gtk_check_version(2,7,3))
            gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true);
#endif
    }
    else // wxFD_OPEN
    {
        if ( !fname.empty() )
        {
            gtk_file_chooser_set_filename(file_chooser,
                                          fn.GetFullPath().fn_str());
        }
    }

    if ( style & wxFD_PREVIEW )
    {
        GtkWidget *previewImage = gtk_image_new();

        gtk_file_chooser_set_preview_widget(file_chooser, previewImage);
        g_signal_connect(m_widget, "update-preview",
                         G_CALLBACK(gtk_filedialog_update_preview_callback),
                         previewImage);
    }
}
Beispiel #6
0
static void
gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass)
{
	GtkWidget *grid;
	GtkWidget *label;
	GtkWidget *exp;
	gchar *str;

	g_return_if_fail (GDAUI_IS_DSN_EDITOR (config));

	gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL);

	/* allocate private structure */
	config->priv = g_new0 (GdauiDsnEditorPrivate, 1);
	config->priv->dsn_info = g_new0 (GdaDsnInfo, 1);
	config->priv->no_change_signal = TRUE;

	/* data source's name and icon */
	GtkWidget *hbox_header;
	hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6);
	config->priv->icon = gtk_image_new ();
	gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE);
	gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0);
	config->priv->wname = gtk_label_new ("");
	gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10);

	GtkWidget *menu_button;
	menu_button = gtk_menu_button_new ();
	gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0);

	GtkWidget *menu_icon;
        menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU);
        gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon);

	GMenu *smenu;
        smenu = g_menu_new ();
        gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu));

	GMenuItem *mitem;
        mitem = g_menu_item_new ("Test data source", "win.DSNTest");
        g_menu_insert_item (smenu, -1, mitem);
        mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset");
        g_menu_insert_item (smenu, -1, mitem);
        mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy");
        g_menu_insert_item (smenu, -1, mitem);

	GtkWindow *win;
	win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ()));
	g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config);

	/* stack in a scrolled window */
	GtkWidget *sw;
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_widget_set_vexpand (sw, TRUE);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
	gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6);

	/* Stack */
	config->priv->stack = gtk_stack_new ();
	gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
	gtk_container_add (GTK_CONTAINER (sw), config->priv->stack);
	
	/* set up widgets */
	grid = gtk_grid_new ();
	gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
	gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
	gtk_widget_show (grid);

	label = gtk_label_new_with_mnemonic (_("_System wide data source:"));
	gtk_widget_set_halign (label, GTK_ALIGN_START);
	gtk_widget_set_hexpand (label, FALSE);
	g_object_set (G_OBJECT (label), "xalign", 0., NULL);
	gtk_widget_show (label);
	gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
	config->priv->is_system = gtk_check_button_new ();
	gtk_widget_show (config->priv->is_system);
	g_signal_connect (G_OBJECT (config->priv->is_system), "toggled",
			  G_CALLBACK (field_toggled_cb), config);
	gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1);

	str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:"));
	label = gtk_label_new ("");
	gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str);
	g_free (str);
	gtk_widget_set_halign (label, GTK_ALIGN_START);
	gtk_widget_set_hexpand (label, FALSE);
	g_object_set (G_OBJECT (label), "xalign", 0., NULL);
	gtk_widget_show (label);
	gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
	config->priv->wprovider = gdaui_provider_selector_new ();
	gtk_widget_set_hexpand (config->priv->wprovider, TRUE);
	gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider);
	gtk_widget_show (config->priv->wprovider);
	g_signal_connect (G_OBJECT (config->priv->wprovider), "changed",
			  G_CALLBACK (field_changed_cb), config);
	gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1);

	label = gtk_label_new_with_mnemonic (_("_Description:"));
	gtk_widget_set_halign (label, GTK_ALIGN_START);
	gtk_widget_set_hexpand (label, FALSE);
	g_object_set (G_OBJECT (label), "xalign", 0., NULL);
	gtk_widget_show (label);
	gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);

	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
	config->priv->wdesc = gtk_text_view_new ();
	gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc);
	gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE);
	gtk_widget_set_vexpand (config->priv->wdesc, TRUE);
	gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc);
	g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed",
			  G_CALLBACK (field_changed_cb), config);
	gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1);

	config->priv->warning = gtk_label_new (NULL);
	gtk_label_set_markup (GTK_LABEL (config->priv->warning),
			      _("<span foreground='red'>The database provider used by this data source is not available,\n"
				"editing the data source's attributes is disabled</span>"));
	gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER);
	gtk_widget_set_hexpand (config->priv->warning, TRUE);
	g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL);
	gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER);
	gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE);
	gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1);
	gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION);

	/* connection's spec */
	config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider 
								 (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
	g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed",
			  G_CALLBACK (field_changed_cb), config);
	gtk_widget_show (config->priv->dsn_spec);
	gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS);

	/* connection's authentication */
	config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider 
								 (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
	g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed",
			  G_CALLBACK (field_changed_cb), config);
	gtk_widget_show (config->priv->dsn_auth);
	gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH);

	config->priv->no_change_signal = FALSE;
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
	GtkWidget* win;
	GtkWidget* main_vbox;
	GtkWidget* vbox;
	GtkWidget* close_button;
	GtkWidget* image;
	GtkWidget* alignment;
	AtkObject* atkobj;
	GtkRcStyle* rcstyle;
	WindowData* windata;
	#ifdef USE_COMPOSITE
		GdkColormap* colormap;
		GdkScreen* screen;
	#endif

	windata = g_new0(WindowData, 1);
	windata->urgency = URGENCY_NORMAL;
	windata->url_clicked = url_clicked;

	win = gtk_window_new(GTK_WINDOW_POPUP);
	gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
	gtk_widget_set_app_paintable(win, TRUE);
	g_signal_connect(G_OBJECT(win), "style-set", G_CALLBACK(on_style_set), windata);
	g_signal_connect(G_OBJECT(win), "map-event", G_CALLBACK(on_window_map), windata);
	g_signal_connect(G_OBJECT(win), "expose-event", G_CALLBACK(on_window_expose), windata);
	g_signal_connect(G_OBJECT(win), "realize", G_CALLBACK(on_window_realize), windata);

	windata->win = win;

	windata->composited = FALSE;

	#ifdef USE_COMPOSITE
		screen = gtk_window_get_screen(GTK_WINDOW(win));
		colormap = gdk_screen_get_rgba_colormap(screen);

		if (colormap != NULL)
		{
			gtk_widget_set_colormap(win, colormap);

			if (gdk_screen_is_composited(screen))
			{
				windata->composited = TRUE;
			}
		}

		g_signal_connect(win, "composited-changed", G_CALLBACK(on_composited_changed), windata);
	#endif

	gtk_window_set_title(GTK_WINDOW(win), "Notification");
	gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
	gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

	g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
	atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);

	g_signal_connect(G_OBJECT(win), "configure-event", G_CALLBACK(on_configure_event), windata);

	main_vbox = gtk_vbox_new(FALSE, 0);
	g_signal_connect(G_OBJECT(main_vbox), "style-set", G_CALLBACK(on_style_set), windata);
	gtk_widget_show(main_vbox);
	gtk_container_add(GTK_CONTAINER(win), main_vbox);
	gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 12);

	windata->main_hbox = gtk_hbox_new(FALSE, 0);
	gtk_widget_show(windata->main_hbox);
	gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);

	/* First row (icon, vbox, close) */
	windata->iconbox = gtk_alignment_new(0.5, 0, 0, 0);
	gtk_widget_show(windata->iconbox);
	gtk_alignment_set_padding(GTK_ALIGNMENT(windata->iconbox), 5, 0, 0, 0);
	gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0);
	gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);

	windata->icon = gtk_image_new();
	gtk_widget_show(windata->icon);
	gtk_container_add(GTK_CONTAINER(windata->iconbox), windata->icon);

	vbox = gtk_vbox_new(FALSE, 6);
	gtk_widget_show(vbox);
	gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);

	/* Add the close button */
	alignment = gtk_alignment_new(0.5, 0, 0, 0);
	gtk_widget_show(alignment);
	gtk_box_pack_start(GTK_BOX(windata->main_hbox), alignment, FALSE, FALSE, 0);

	close_button = gtk_button_new();
	g_signal_connect(G_OBJECT(close_button), "style-set", G_CALLBACK(on_style_set), windata);
	gtk_widget_show(close_button);
	windata->close_button = close_button;
	gtk_container_add(GTK_CONTAINER(alignment), close_button);
	gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
	gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
	g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);

	rcstyle = gtk_rc_style_new();
	rcstyle->xthickness = rcstyle->ythickness = 0;
	gtk_widget_modify_style(close_button, rcstyle);
	g_object_unref(rcstyle);

	atkobj = gtk_widget_get_accessible(close_button);
	atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
	atk_object_set_name(atkobj, "");
	atk_object_set_description(atkobj, "Closes the notification.");

	image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
	gtk_widget_show(image);
	gtk_container_add(GTK_CONTAINER(close_button), image);

	/* center vbox */
	windata->summary_label = gtk_label_new(NULL);
	g_signal_connect(G_OBJECT(windata->summary_label), "style-set", G_CALLBACK(on_style_set), windata);
	gtk_widget_show(windata->summary_label);
	gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, TRUE, TRUE, 0);
	gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0);
	gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);

	atkobj = gtk_widget_get_accessible(windata->summary_label);
	atk_object_set_description(atkobj, "Notification summary text.");

	windata->content_hbox = gtk_hbox_new(FALSE, 6);
	gtk_widget_show(windata->content_hbox);
	gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);


	vbox = gtk_vbox_new(FALSE, 6);
	gtk_widget_show(vbox);
	gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);

	windata->body_label = gtk_label_new(NULL);
	g_signal_connect(G_OBJECT(windata->body_label), "style-set", G_CALLBACK(on_style_set), windata);
	gtk_widget_show(windata->body_label);
	gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
	gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0);
	gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
	g_signal_connect_swapped(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(windata->url_clicked), win);

	atkobj = gtk_widget_get_accessible(windata->body_label);
	atk_object_set_description(atkobj, "Notification body text.");

	alignment = gtk_alignment_new(1, 0.5, 0, 0);
	gtk_widget_show(alignment);
	gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);

	windata->actions_box = gtk_hbox_new(FALSE, 6);
	gtk_widget_show(windata->actions_box);
	gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);

	return GTK_WINDOW(win);
}
Beispiel #8
0
void gui_show_dialog(gpointer signal, gboolean change)
{
    GGaduSignal *sig = (GGaduSignal *) signal;
    GtkWidget *dialog_widget = NULL;
    GtkWidget *image = NULL;
    GtkWidget *table = NULL;
    GtkWidget *label = NULL;
    GtkWidget *hbox = NULL;
    GdkPixbuf *windowicon = NULL;
    GGaduDialog *dialog = (sig) ? sig->data : NULL;
    gchar *markup = NULL;

    if (!sig)
        return;

    if ((ggadu_dialog_get_flags(dialog) & GGADU_DIALOG_FLAG_ONLY_OK) == GGADU_DIALOG_FLAG_ONLY_OK)
        dialog_widget = gtk_dialog_new_with_buttons(dialog->title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
    else
        dialog_widget =
            gtk_dialog_new_with_buttons(dialog->title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);

    gtk_dialog_set_default_response(GTK_DIALOG(dialog_widget), GTK_RESPONSE_OK);
    gtk_window_set_resizable(GTK_WINDOW(dialog_widget), FALSE);

    if ((windowicon = create_pixbuf(GGADU_DEFAULT_ICON_FILENAME)) != NULL)
    {
        gtk_window_set_icon(GTK_WINDOW(dialog_widget), windowicon);
        gdk_pixbuf_unref(windowicon);
    }

    hbox = gtk_hbox_new(FALSE, 0);

    if (ggadu_dialog_get_type(dialog))
    {
        gint type = ggadu_dialog_get_type(dialog);
        print_debug("d->type = %d\n", type);
        switch (type)
        {
        case GGADU_DIALOG_CONFIG:
            image = gtk_image_new();
            gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-preferences", GTK_ICON_SIZE_DND);
            break;
        case GGADU_DIALOG_YES_NO:
            image = gtk_image_new();
            gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-dialog-question", GTK_ICON_SIZE_DND);
            break;
        default:
            break;
        }
        gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 5);
    }

    label = gtk_label_new(NULL);
    markup = g_strdup_printf("<span weight=\"bold\">%s</span>", ggadu_dialog_get_title(dialog));
    gtk_label_set_markup(GTK_LABEL(label), markup);
    g_free(markup);

    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);

    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_widget)->vbox), hbox, TRUE, TRUE, 10);

    if (dialog->flags & GGADU_DIALOG_FLAG_PROGRESS)
        table = gui_build_dialog_gtk_table(ggadu_dialog_get_entries(dialog), 1, TRUE);
    else
        table = gui_build_dialog_gtk_table(ggadu_dialog_get_entries(dialog), 1, FALSE);

    gtk_table_set_row_spacings(GTK_TABLE(table), 7);
    gtk_table_set_col_spacings(GTK_TABLE(table), 5);

    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_widget)->vbox), table, TRUE, TRUE, 0);

    g_signal_connect(G_OBJECT(dialog_widget), "response", G_CALLBACK(gui_dialog_response), signal_cpy(signal));

    /*	if (ggadu_dialog_get_type(dialog) == GGADU_DIALOG_PROGRESS)
    	{
    		g_timeout_add(1000,dialog->watch_func,NULL);
    	}
    */
    gtk_widget_show_all(dialog_widget);
}
Beispiel #9
0
static GtkWidget *create_dialog(void)
{
    GtkWidget *dialog;
    GtkWidget *header_image;
    GtkWidget *header_label;
    GtkWidget *label_info;
    GtkWidget *codename_label;
    GtkWidget *builddate_label;
    GtkWidget *url_button;
    GtkWidget *cop_label;
    GtkWidget *label;
    GtkWidget *license_textview;
    GtkWidget *notebook;
    GtkWidget *box;
    GtkWidget *credits_scrollwin;
    GtkWidget *table;
    GtkWidget *license_scrollwin;
    GtkWidget *info_box;
    GtkWidget *header_hbox;
    GtkWidget *header_eventbox;
    GdkPixbuf *icon;
    GtkTextBuffer* tb;
    gchar *license_text = NULL;
    gchar buffer[512];
    gchar buffer2[128];
    guint i, row = 0;

    dialog = gtk_dialog_new();

    /* configure dialog */
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
    gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
    gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
    gtk_widget_set_name(dialog, "GeanyDialog");
    gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
    gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
    g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);

    /* create header */
    header_eventbox = gtk_event_box_new();
    gtk_widget_show(header_eventbox);
    header_hbox = gtk_hbox_new(FALSE, 12);
    gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
    gtk_widget_show(header_hbox);
    gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
    header_image = gtk_image_new();
    gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
    header_label = gtk_label_new(NULL);
    gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
    /* print the subversion revision generated by ./configure if it is available */
    g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
    gtk_label_set_markup(GTK_LABEL(header_label), buffer);
    gtk_widget_show(header_label);
    gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
    header_eventbox_style_set(header_eventbox);
    header_label_style_set(header_label);
    g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
    g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);

    /* set image */
    icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
    gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
    gtk_window_set_icon(GTK_WINDOW(dialog), icon);
    g_object_unref(icon);	/* free our reference */

    /* create notebook */
    notebook = gtk_notebook_new();
    gtk_widget_show(notebook);
    gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);

    /* create "Info" tab */
    info_box = gtk_vbox_new(FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
    gtk_widget_show(info_box);

    label_info = gtk_label_new(NULL);
    gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
    gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
    gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
    g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
    gtk_label_set_markup(GTK_LABEL(label_info), buffer);
    gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
    gtk_widget_show(label_info);
    gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);

    /* Codename label */
    codename_label = gtk_label_new(NULL);
    gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
    gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
    gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
    gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
    gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
    gtk_widget_show(codename_label);
    gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);

    /* build date label */
    builddate_label = gtk_label_new(NULL);
    gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
    gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
    gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
    g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
    g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
    gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
    gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
    gtk_widget_show(builddate_label);
    gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);

    box = gtk_hbutton_box_new();
    url_button = gtk_button_new();
    gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
    g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
    label = gtk_label_new(NULL);
    gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
    gtk_widget_show(label);
    gtk_container_add(GTK_CONTAINER(url_button), label);
    gtk_widget_show(url_button);
    gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
    gtk_widget_show(box);
    gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);

    /* copyright label */
    cop_label = gtk_label_new(NULL);
    gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
    gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
    gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
    gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
    gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
    gtk_widget_show(cop_label);
    gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
    /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */

    label = gtk_label_new(_("Info"));
    gtk_widget_show(label);
    gtk_widget_show_all(info_box);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);

    /* create "Credits" tab */
    credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

    table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
    gtk_table_set_col_spacings(GTK_TABLE(table), 10);

    row = 0;
    g_snprintf(buffer, sizeof(buffer),
               "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
    label = gtk_label_new(buffer);
    gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
    ROW(buffer, row, 0, 0, 0, 1);
    row++;
    ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
    row++;
    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
    ROW(buffer, row, 0, 0, 0, 1);
    row++;
    ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
    row++;
    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
    ROW(buffer, row, 0, 0, 0, 1);
    row++;
    ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
    row++;
    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
    ROW(buffer, row, 0, 0, 0, 1);
    row++;
    ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
    row++;
    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
    ROW(buffer, row, 0, 0, 0, 1);
    row++;
    ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
    row++;
    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer),
               "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
    label = gtk_label_new(buffer);
    gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
                     (GtkAttachOptions) (GTK_FILL),
                     (GtkAttachOptions) (0), 0, 5);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
    row++;

    for (i = 0; i < translators_len; i++)
    {
        ROW(translators[i][0], row, 0, 1, 4, 0);
        ROW(translators[i][1], row, 1, 0, 4, 0);
        row++;
    }

    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer),
               "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
    label = gtk_label_new(buffer);
    gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
                     (GtkAttachOptions) (GTK_FILL),
                     (GtkAttachOptions) (0), 0, 5);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
    row++;

    for (i = 0; i < prev_translators_len; i++)
    {
        ROW(prev_translators[i][0], row, 0, 1, 4, 0);
        ROW(prev_translators[i][1], row, 1, 0, 4, 0);
        row++;
    }


    ROW("", row, 0, 0, 0, 0);
    row++;

    g_snprintf(buffer, sizeof(buffer),
               "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
    label = gtk_label_new(buffer);
    gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
                     (GtkAttachOptions) (GTK_FILL),
                     (GtkAttachOptions) (0), 0, 5);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
    row++;

    g_snprintf(buffer, sizeof(buffer),
               _("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
               "Thanks.txt"
#else
               "THANKS"
#endif
              );
    label = geany_wrap_label_new(buffer);
    gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
                     (GtkAttachOptions) (GTK_FILL),
                     (GtkAttachOptions) (0), 0, 5);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
    row++;

    label = geany_wrap_label_new(contributors);
    gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
                     (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
                     (GtkAttachOptions) (0), 0, 5);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
    row++;

    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
    gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
    gtk_widget_show_all(table);
    label = gtk_label_new(_("Credits"));
    gtk_widget_show(label);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);

    /* create "License" tab */
    license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    license_textview = gtk_text_view_new();
    gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
    gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
    gtk_widget_show(license_textview);
    gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
    label = gtk_label_new(_("License"));
    gtk_widget_show(label);

    g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);

    g_file_get_contents(buffer, &license_text, NULL, NULL);
    if (license_text == NULL)
    {
        license_text = g_strdup(
                           _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
    }
    tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
    gtk_text_buffer_set_text(tb, license_text, -1);

    g_free(license_text);

    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);

    gtk_widget_show_all(dialog);
    return dialog;
}
Beispiel #10
0
GtkWidget *
pgd_page_create_widget (PopplerDocument *document)
{
	PgdPageDemo *demo;
	GtkWidget   *vbox;
	GtkWidget   *hbox, *page_selector;
	GtkWidget   *button;
	GtkWidget   *frame, *alignment;
	GtkWidget   *table;
	GtkWidget   *label;
	GtkWidget   *thumnail_box;
	gchar       *str;
	gint         n_pages;
	gint         row = 0;

	demo = g_new0 (PgdPageDemo, 1);

	demo->doc = g_object_ref (document);

	n_pages = poppler_document_get_n_pages (document);

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);

	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

	label = gtk_label_new ("Page:");
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
	gtk_widget_show (label);

	page_selector = gtk_spin_button_new_with_range (1, n_pages, 1);
	g_signal_connect (G_OBJECT (page_selector), "value-changed",
			  G_CALLBACK (pgd_page_page_selector_value_changed),
			  (gpointer)demo);
	gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0);
	gtk_widget_show (page_selector);

	str = g_strdup_printf ("of %d", n_pages);
	label = gtk_label_new (str);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
	gtk_widget_show (label);
	g_free (str);

	button = gtk_button_new_with_label ("Get Info");
	g_signal_connect (G_OBJECT (button), "clicked",
			  G_CALLBACK (pgd_page_get_info),
			  (gpointer)demo);
	gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
	gtk_widget_show (button);

	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
	gtk_widget_show (hbox);

	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

	frame = gtk_frame_new (NULL);
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
	label = gtk_label_new (NULL);
	gtk_label_set_markup (GTK_LABEL (label), "<b>Page Properties</b>");
	gtk_frame_set_label_widget (GTK_FRAME (frame), label);
	gtk_widget_show (label);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5);
	gtk_container_add (GTK_CONTAINER (frame), alignment);
	gtk_widget_show (alignment);

	table = gtk_grid_new ();
	gtk_grid_set_column_spacing (GTK_GRID (table), 6);
	gtk_grid_set_row_spacing (GTK_GRID (table), 6);

	pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Index:</b>",
						  &(demo->index), NULL, &row);
	pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Label:</b>",
						  &(demo->label), NULL, &row);
	pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Size:</b>",
						  &(demo->size), NULL, &row);
	pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Duration:</b>",
						  &(demo->duration), NULL, &row);

	gtk_container_add (GTK_CONTAINER (alignment), table);
	gtk_widget_show (table);

	gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
	gtk_widget_show (frame);

	frame = gtk_frame_new (NULL);
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
	gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
	label = gtk_label_new (NULL);
	gtk_label_set_markup (GTK_LABEL (label), "<b>Page Thumbnail</b>");
	gtk_frame_set_label_widget (GTK_FRAME (frame), label);
	gtk_widget_show (label);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5);
	gtk_container_add (GTK_CONTAINER (frame), alignment);
	gtk_widget_show (alignment);
	
	thumnail_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
	
	demo->thumbnail = gtk_image_new ();
	gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail, TRUE, TRUE, 0);
	gtk_widget_show (demo->thumbnail);
	
	demo->thumbnail_size = gtk_label_new (NULL);
	g_object_set (G_OBJECT (demo->thumbnail_size), "xalign", 0.5, NULL);
	gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail_size, TRUE, TRUE, 0);
	gtk_widget_show (demo->thumbnail_size);

	gtk_container_add (GTK_CONTAINER (alignment), thumnail_box);
	gtk_widget_show (thumnail_box);

	gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
	gtk_widget_show (frame);
	
	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
	gtk_widget_show (hbox);

	g_object_weak_ref (G_OBJECT (vbox),
			   (GWeakNotify)pgd_page_free,
			   (gpointer)demo);
	
	return vbox;
}
Beispiel #11
0
static void
moko_talking_init (MokoTalking *talking)
{
  MokoTalkingPrivate *priv;
  GtkWidget *notebook;
  GtkWidget *toolbar, *image, *vbox, *hbox, *label, *align, *frame, *main_vbox;
  GtkWidget *duration;
  GtkToolItem *item;
  gint i;

  priv = talking->priv = MOKO_TALKING_GET_PRIVATE (talking);

  /* initialize dtimer to NULL */
  priv->dtimer = NULL;

  notebook = gtk_notebook_new ();
  gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM);
  priv->notebook = notebook;

  /* status page */
  main_vbox = gtk_vbox_new (FALSE, 0);
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox,
                            gtk_image_new_from_file (PKGDATADIR"/phone.png"));
  gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand",
                           TRUE, NULL);

  priv->incoming_bar = toolbar = gtk_toolbar_new ();
  gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0);

  image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_ANSWER, GTK_ICON_SIZE_BUTTON);
  item = gtk_tool_button_new (image, "Answer");
  gtk_tool_item_set_expand (item, TRUE);
  g_signal_connect (item, "clicked", G_CALLBACK (on_answer_clicked), talking);
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_IGNORE, GTK_ICON_SIZE_BUTTON);
  item = gtk_tool_button_new (image, "Ignore");
  gtk_tool_item_set_expand (item, TRUE);
  g_signal_connect (item, "clicked", G_CALLBACK (on_silence_clicked), talking);
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_REJECT, GTK_ICON_SIZE_BUTTON);
  item = gtk_tool_button_new (image, "Reject");
  gtk_tool_item_set_expand (item, TRUE);
  g_signal_connect (item, "clicked", G_CALLBACK (on_reject_clicked), talking);
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  /* Volume controls */
  priv->headphone = moko_alsa_volume_control_new ();
  moko_alsa_volume_control_set_device_from_name (priv->headphone, "neo1973");
  moko_alsa_volume_control_set_element_from_name (priv->headphone, "Headphone");

  priv->volume = moko_alsa_volume_scale_new (GTK_ORIENTATION_HORIZONTAL);
  moko_alsa_volume_scale_set_control (MOKO_ALSA_VOLUME_SCALE (priv->volume),
                                      priv->headphone);

  /* Outgoing call and talking share the same toolbar */
  priv->main_bar = toolbar = gtk_toolbar_new ();
  gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0);

  image = gtk_image_new_from_icon_name (MOKO_STOCK_SPEAKER,
                                        GTK_ICON_SIZE_BUTTON);
  item = gtk_toggle_tool_button_new ();
  gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), image);

  gtk_tool_item_set_expand (item, TRUE);
  g_signal_connect (item, "toggled", G_CALLBACK (on_speaker_toggled), talking);
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
  priv->speaker_toggle_btn = item;

  image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_HANGUP, GTK_ICON_SIZE_BUTTON);
  item = gtk_tool_button_new (image, "Hangup");
  gtk_tool_item_set_expand (item, TRUE);
  g_signal_connect (item, "clicked", G_CALLBACK (on_cancel_clicked), talking);
  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

  /* The title label and image */
  vbox = gtk_vbox_new (FALSE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
  gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);

  priv->title = label = gtk_label_new ("Incoming Call");
  gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

  align = gtk_alignment_new (0.5, 0.5, 0, 0);
  gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 8);

  priv->icon = image = gtk_image_new ();
  gtk_container_add (GTK_CONTAINER (align), image);

  priv->duration = duration = gtk_label_new ("00:00:00");
  gtk_misc_set_alignment (GTK_MISC (duration), 0.5, 0.5);
  gtk_box_pack_start (GTK_BOX (vbox), duration, FALSE, FALSE, 0);

  /* The status area */
  align = gtk_alignment_new (0.5, 0.5, 1, 0 );
  gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);

  frame = gtk_frame_new (NULL);
  gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
  gtk_container_add (GTK_CONTAINER (align), frame);

  hbox = gtk_hbox_new (FALSE, 12);
  gtk_container_add (GTK_CONTAINER (frame), hbox);

  priv->person = image = gtk_image_new ();
  gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);

  priv->status = label = gtk_label_new ("");
  gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);

  /* The volume control */
  gtk_box_pack_start (GTK_BOX (vbox), priv->volume, FALSE, TRUE, 12);

  /* Load the pixbufs */
  for (i = 0; i < N_PICS; i++)
  {
    if (i == 0)
      priv->talking[i] = gdk_pixbuf_new_from_file (PKGDATADIR"/talking.png",
                                                   NULL);
    else
    {
      gchar *name = g_strdup_printf ("%s/talking_%d.png", PKGDATADIR, i-1);
      priv->talking[i] = gdk_pixbuf_new_from_file (name, NULL);
      g_free (name);
    }
    if (G_IS_OBJECT (priv->talking[i]))
      g_object_ref (priv->talking[i]);
  }
  for (i = 0; i < N_PICS-1; i++)
  {
    gchar *name = g_strdup_printf ("%s/outgoing_%d.png", PKGDATADIR, i);
    priv->outgoing[i] = gdk_pixbuf_new_from_file (name, NULL);
    g_free (name);
    if (G_IS_OBJECT (priv->outgoing[i]))
      g_object_ref (priv->outgoing[i]);
  }
  for (i = 0; i < N_PICS-1; i++)
  {
    gchar *name = g_strdup_printf ("%s/incoming_%d.png", PKGDATADIR, i);
    priv->incoming[i] = gdk_pixbuf_new_from_file (name, NULL);
    g_free (name);
    if (G_IS_OBJECT (priv->incoming[i]))
      g_object_ref (priv->incoming[i]);

  }

  /* dtmf page */
  GtkWidget *pad, *display;
  main_vbox = gtk_vbox_new (FALSE, 0);
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox,
                            gtk_image_new_from_file (PKGDATADIR"/dtmf.png"));
  gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand",
                           TRUE, NULL);

  display = moko_dialer_textview_new ();
  gtk_box_pack_start_defaults (GTK_BOX (main_vbox), display);
  priv->dtmf_display = display;

  pad = moko_dialer_panel_new ();
  gtk_box_pack_start_defaults (GTK_BOX (main_vbox), pad);
  g_signal_connect (pad, "user_input", G_CALLBACK (on_pad_user_input), talking);
  priv->dtmf_pad = pad;

  priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (priv->window, "delete-event", G_CALLBACK (window_delete_event_cb), talking);
  gtk_container_add (GTK_CONTAINER (priv->window), notebook);

  gtk_widget_show_all (notebook);

}
Beispiel #12
0
static void
create_sub_menu (ShellStatusMenu *status)
{
  ShellStatusMenuPrivate *priv = status->priv;
  GtkWidget *item;

  priv->menu = gtk_menu_new ();
  g_signal_connect (priv->menu, "style-set", G_CALLBACK (menu_style_set_cb),
      status);

  g_signal_connect (priv->manager, "users-loaded",
      G_CALLBACK (on_manager_users_loaded), status);
  g_signal_connect (priv->manager, "user-added",
      G_CALLBACK (on_manager_user_added), status);
  g_signal_connect (priv->manager, "user-removed",
      G_CALLBACK (on_manager_user_removed), status);

  priv->account_item = gtk_image_menu_item_new_with_label (_("Account Information..."));
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->account_item),
      gtk_image_new ());
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->account_item);
  g_signal_connect (priv->account_item, "style-set",
      G_CALLBACK (menuitem_style_set_cb), status);
  g_signal_connect (priv->account_item, "activate",
      G_CALLBACK (on_account_activate), status);
  gtk_widget_show (priv->account_item);

  priv->sidebar_item = gtk_check_menu_item_new_with_label (_("Sidebar"));
  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->sidebar_item),
      gconf_client_get_bool (priv->client, SIDEBAR_VISIBLE_KEY, NULL));
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->sidebar_item);
  g_signal_connect (priv->sidebar_item, "toggled",
      G_CALLBACK (on_sidebar_toggled), status);
  gtk_widget_show (priv->sidebar_item);

  priv->control_panel_item = gtk_image_menu_item_new_with_label (_("System Preferences..."));
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->control_panel_item),
      gtk_image_new ());
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->control_panel_item);
  g_signal_connect (priv->control_panel_item, "style-set",
      G_CALLBACK (menuitem_style_set_cb), status);
  g_signal_connect (priv->control_panel_item, "activate",
      G_CALLBACK (on_control_panel_activate), status);
  gtk_widget_show (priv->control_panel_item);

  item = gtk_separator_menu_item_new ();
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
  gtk_widget_show (item);

  priv->lock_screen_item
      = gtk_image_menu_item_new_with_label (_("Lock Screen"));
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->lock_screen_item),
      gtk_image_new ());
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->lock_screen_item);
  g_signal_connect (priv->lock_screen_item, "style-set",
      G_CALLBACK (menuitem_style_set_cb), status);
  g_signal_connect (priv->lock_screen_item, "activate",
      G_CALLBACK (on_lock_screen_activate), status);
  gtk_widget_show (priv->lock_screen_item);

  priv->login_screen_item = gtk_image_menu_item_new_with_label (_("Switch User"));
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->login_screen_item),
      gtk_image_new ());
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->login_screen_item);
  g_signal_connect (priv->login_screen_item, "style-set",
      G_CALLBACK (menuitem_style_set_cb), status);
  g_signal_connect (priv->login_screen_item, "activate",
      G_CALLBACK (on_login_screen_activate), status);
  /* Only show switch user if there are other users */

  priv->quit_session_item = gtk_image_menu_item_new_with_label (_("Quit..."));
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->quit_session_item),
      gtk_image_new ());
  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->quit_session_item);
  g_signal_connect (priv->quit_session_item, "style-set",
      G_CALLBACK (menuitem_style_set_cb), status);
  g_signal_connect (priv->quit_session_item, "activate",
      G_CALLBACK (on_quit_session_activate), status);
  gtk_widget_show (priv->quit_session_item);

  g_signal_connect (G_OBJECT (priv->menu), "deactivate",
      G_CALLBACK (on_deactivate), status);
}
Beispiel #13
0
Datei: gui.c Projekt: rosedu/osmo
void 
gui_create_about(GtkWidget *notebook) {

GtkWidget *vbox1;
GtkWidget *label;
GtkWidget *hseparator;
GtkWidget *logo_area;
GdkPixbuf *logo;
GtkWidget *viewport;
GtkWidget *hbuttonbox;
GSList    *radiobutton_group = NULL;

    label = gtk_label_new(NULL);
    gtk_label_set_angle (GTK_LABEL(label), -90.0);
    gtk_label_set_markup (GTK_LABEL (label), _("About"));
 
    vbox1 = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (vbox1);
    gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox1, label);

    logo_area = gtk_image_new();
    logo = gdk_pixbuf_new_from_inline(-1, osmo_logo, FALSE, NULL);
    gtk_widget_show(logo_area);
    gtk_box_pack_start (GTK_BOX (vbox1), logo_area, FALSE, TRUE, 0);

#ifndef REV
    sprintf(tmpbuf, "%s %s", _("version"), VERSION);
#else
    sprintf(tmpbuf, "%s %d", _("SVN revision"), REV);
#endif

    label = gtk_label_new(tmpbuf);
    gtk_widget_show (label);
    gtk_box_pack_start (GTK_BOX (vbox1), label, FALSE, TRUE, 4);

    gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo);

    hseparator = gtk_hseparator_new ();
    gtk_widget_show (hseparator);
    gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);

    /*--------------------------------------------------------------------------*/

    hbuttonbox = gtk_hbutton_box_new ();
    gtk_widget_show (hbuttonbox);
    gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
    gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);

    about_radiobutton = gui_image_label_radio_button(_("About"), osmo_stock_about);
    gtk_widget_show (about_radiobutton);

    gtk_button_set_relief (GTK_BUTTON (about_radiobutton), GTK_RELIEF_NONE);  
    GTK_WIDGET_UNSET_FLAGS(about_radiobutton, GTK_CAN_FOCUS);
    gtk_radio_button_set_group (GTK_RADIO_BUTTON (about_radiobutton), radiobutton_group);
    radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (about_radiobutton));
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (about_radiobutton), TRUE);
    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (about_radiobutton), FALSE);
    gtk_container_add (GTK_CONTAINER (hbuttonbox), about_radiobutton);

    g_signal_connect (G_OBJECT (about_radiobutton), "released",
                      G_CALLBACK(button_released_cb), NULL);

    help_radiobutton = gui_image_label_radio_button(_("Key shortcuts"), osmo_stock_help);
    gtk_widget_show (help_radiobutton);
    gtk_button_set_relief (GTK_BUTTON (help_radiobutton), GTK_RELIEF_NONE);  
    GTK_WIDGET_UNSET_FLAGS(help_radiobutton, GTK_CAN_FOCUS);
    gtk_radio_button_set_group (GTK_RADIO_BUTTON (help_radiobutton), radiobutton_group);
    radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (help_radiobutton));
    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (help_radiobutton), FALSE);
    gtk_container_add (GTK_CONTAINER (hbuttonbox), help_radiobutton);

    g_signal_connect (G_OBJECT (help_radiobutton), "released",
                      G_CALLBACK(button_released_cb), NULL);

    license_radiobutton = gui_image_label_radio_button(_("License"), osmo_stock_license);
    gtk_widget_show (license_radiobutton);
    gtk_button_set_relief (GTK_BUTTON (license_radiobutton), GTK_RELIEF_NONE);  
    GTK_WIDGET_UNSET_FLAGS(license_radiobutton, GTK_CAN_FOCUS);
    gtk_radio_button_set_group (GTK_RADIO_BUTTON (license_radiobutton), radiobutton_group);
    radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (license_radiobutton));
    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (license_radiobutton), FALSE);
    gtk_container_add (GTK_CONTAINER (hbuttonbox), license_radiobutton);

    g_signal_connect (G_OBJECT (license_radiobutton), "released",
                      G_CALLBACK(button_released_cb), NULL);

    /*--------------------------------------------------------------------------*/

    hseparator = gtk_hseparator_new ();
    gtk_widget_show (hseparator);
    gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);

    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
    gtk_box_pack_start (GTK_BOX (vbox1), scrolled_window, TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_widget_show (scrolled_window);

    viewport = gtk_viewport_new (NULL, NULL);
    gtk_widget_show (viewport);
    gtk_container_set_border_width (GTK_CONTAINER (viewport), 0);
    gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);

    entry_buffer = gtk_text_buffer_new (NULL);
    gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0);
    gtk_text_buffer_create_tag (entry_buffer, "bold", "weight", PANGO_WEIGHT_ULTRABOLD, NULL);
    gtk_text_buffer_create_tag (entry_buffer, "big", "size", 16 * PANGO_SCALE, NULL);
    gtk_text_buffer_create_tag (entry_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL);
    gtk_text_buffer_create_tag (entry_buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL);
    gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0);

    about_textview = gtk_text_view_new_with_buffer (entry_buffer);
    gtk_container_set_border_width (GTK_CONTAINER (about_textview), 1);
    gtk_text_view_set_editable(GTK_TEXT_VIEW (about_textview), FALSE);
    gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (about_textview), FALSE);
    gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (about_textview), GTK_WRAP_WORD);
    gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(about_textview), 2);
    gtk_text_view_set_left_margin(GTK_TEXT_VIEW(about_textview), 6);
    gtk_text_view_set_right_margin(GTK_TEXT_VIEW(about_textview), 6);
    gtk_widget_show (about_textview);
    gtk_container_add (GTK_CONTAINER (viewport), about_textview);

    gui_url_setup(&about_links_list, &about_link_index, about_textview);

    display_about();
}
Beispiel #14
0
static void prefs_custom_header_create(void)
{
	GtkWidget *window;
	GtkWidget *vbox;

	GtkWidget *ok_btn;
	GtkWidget *cancel_btn;

	GtkWidget *confirm_area;

	GtkWidget *vbox1;

	GtkWidget *table1;
	GtkWidget *hdr_label;
	GtkWidget *hdr_combo;
	GtkWidget *val_label;
	GtkWidget *val_entry;
	GtkWidget *val_btn;

	GtkWidget *reg_hbox;
	GtkWidget *btn_hbox;
	GtkWidget *arrow;
	GtkWidget *add_btn;
	GtkWidget *del_btn;
	GtkWidget *preview;

	GtkWidget *ch_hbox;
	GtkWidget *ch_scrolledwin;
	GtkWidget *list_view;

	GtkWidget *btn_vbox;
	GtkWidget *up_btn;
	GtkWidget *down_btn;

	debug_print("Creating custom header setting window...\n");

	window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_customheader");
	gtk_container_set_border_width (GTK_CONTAINER (window), 8);
	gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
	gtk_window_set_resizable(GTK_WINDOW (window), TRUE);

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

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

	gtk_window_set_title (GTK_WINDOW(window), _("Custom header configuration"));
	MANAGE_WINDOW_SIGNALS_CONNECT (window);
	g_signal_connect (G_OBJECT(window), "delete_event",
			  G_CALLBACK(prefs_custom_header_deleted),
			  NULL);
	g_signal_connect (G_OBJECT(window), "key_press_event",
			  G_CALLBACK(prefs_custom_header_key_pressed),
			  NULL);
	g_signal_connect (G_OBJECT(ok_btn), "clicked",
			  G_CALLBACK(prefs_custom_header_ok), NULL);
	g_signal_connect (G_OBJECT(cancel_btn), "clicked",
			  G_CALLBACK(prefs_custom_header_cancel), NULL);

	vbox1 = gtk_vbox_new (FALSE, VSPACING);
	gtk_widget_show (vbox1);
	gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);

	table1 = gtk_table_new (3, 2, FALSE);
	gtk_widget_show (table1);
	gtk_box_pack_start (GTK_BOX (vbox1), table1,
			    FALSE, FALSE, 0);
	gtk_table_set_row_spacings (GTK_TABLE (table1), 8);
	gtk_table_set_col_spacings (GTK_TABLE (table1), 8);

	hdr_label = gtk_label_new (_("Header"));
	gtk_widget_show (hdr_label);
	gtk_table_attach (GTK_TABLE (table1), hdr_label, 0, 1, 0, 1,
			  GTK_EXPAND | GTK_SHRINK | GTK_FILL,
			  0, 0, 0);
	gtk_misc_set_alignment (GTK_MISC (hdr_label), 0, 0.5);
	
	hdr_combo = combobox_text_new(TRUE, "User-Agent", "Face", "X-Face",
				      "X-Operating-System", NULL);
	gtk_table_attach (GTK_TABLE (table1), hdr_combo, 0, 1, 1, 2,
			  GTK_EXPAND | GTK_SHRINK | GTK_FILL,
			  0, 0, 0);
	gtk_widget_set_size_request (hdr_combo, 150, -1);

	val_label = gtk_label_new (_("Value"));
	gtk_widget_show (val_label);
	gtk_table_attach (GTK_TABLE (table1), val_label, 1, 2, 0, 1,
			  GTK_EXPAND | GTK_SHRINK | GTK_FILL,
			  0, 0, 0);
	gtk_misc_set_alignment (GTK_MISC (val_label), 0, 0.5);
	
	val_entry = gtk_entry_new ();
	gtk_widget_show (val_entry);
	gtk_table_attach (GTK_TABLE (table1), val_entry, 1, 2, 1, 2,
			  GTK_EXPAND | GTK_SHRINK | GTK_FILL,
			  0, 0, 0);
	gtk_widget_set_size_request (val_entry, 200, -1);

	val_btn = gtkut_get_browse_file_btn(_("Bro_wse"));
	gtk_widget_show (val_btn);
	gtk_table_attach (GTK_TABLE (table1), val_btn, 2, 3, 1, 2,
			  GTK_EXPAND | GTK_SHRINK | GTK_FILL,
			  0, 0, 0);
	g_signal_connect (G_OBJECT (val_btn), "clicked",
			  G_CALLBACK (prefs_custom_header_val_from_file_cb),
			  NULL);

	/* add / delete */

	reg_hbox = gtk_hbox_new (FALSE, 4);
	gtk_widget_show (reg_hbox);
	gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0);

	arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
	gtk_widget_show (arrow);
	gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0);
	gtk_widget_set_size_request (arrow, -1, 16);

	btn_hbox = gtk_hbox_new (TRUE, 4);
	gtk_widget_show (btn_hbox);
	gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0);

	add_btn = gtk_button_new_from_stock (GTK_STOCK_ADD);
	gtk_widget_show (add_btn);
	gtk_box_pack_start (GTK_BOX (btn_hbox), add_btn, FALSE, TRUE, 0);
	g_signal_connect (G_OBJECT (add_btn), "clicked",
			  G_CALLBACK (prefs_custom_header_add_cb),
			  NULL);

	del_btn = gtk_button_new_from_stock (GTK_STOCK_DELETE);
	gtk_widget_show (del_btn);
	gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
	g_signal_connect (G_OBJECT (del_btn), "clicked",
			  G_CALLBACK (prefs_custom_header_delete_cb),
			  NULL);


	ch_hbox = gtk_hbox_new (FALSE, 8);
	gtk_widget_show (ch_hbox);
	gtk_box_pack_start (GTK_BOX (vbox1), ch_hbox, TRUE, TRUE, 0);

	ch_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
	gtk_widget_set_size_request (ch_scrolledwin, -1, 200);
	gtk_widget_show (ch_scrolledwin);
	gtk_box_pack_start (GTK_BOX (ch_hbox), ch_scrolledwin, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ch_scrolledwin),
					GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);

	list_view = prefs_custom_header_list_view_create();
	gtk_widget_show (list_view);
	gtk_container_add (GTK_CONTAINER (ch_scrolledwin), list_view);

	btn_vbox = gtk_vbox_new (FALSE, 8);
	gtk_widget_show (btn_vbox);
	gtk_box_pack_start (GTK_BOX (ch_hbox), btn_vbox, FALSE, FALSE, 0);

	up_btn = gtk_button_new_from_stock (GTK_STOCK_GO_UP);
	gtk_widget_show (up_btn);
	gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
	g_signal_connect (G_OBJECT (up_btn), "clicked",
			  G_CALLBACK (prefs_custom_header_up), NULL);

	down_btn = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN);
	gtk_widget_show (down_btn);
	gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
	g_signal_connect (G_OBJECT (down_btn), "clicked",
			  G_CALLBACK (prefs_custom_header_down), NULL);

	preview = gtk_image_new ();
	gtk_widget_show (preview);
	gtk_box_pack_start (GTK_BOX (btn_vbox), preview, FALSE, FALSE, 0);

	gtk_widget_show_all(window);

	customhdr.window     = window;
	customhdr.ok_btn     = ok_btn;
	customhdr.cancel_btn = cancel_btn;
	customhdr.preview = preview;

	customhdr.hdr_combo  = hdr_combo;
	customhdr.hdr_entry  = gtk_bin_get_child(GTK_BIN((hdr_combo)));
	customhdr.val_entry  = val_entry;

	customhdr.list_view   = list_view;
}
Beispiel #15
0
bool loop(int argc, char** argv) {

	char home[256]; //NEED TO MAKE THIS DYNAMIC
	strcpy(home, getenv("HOME"));

	//parse the config file
	settings.parse_config(strcat(home, config_file));
	//load the controls into list
	ElementList list(settings.card);
	list_ptr = &list;
	//reorder the controls to the order specified in the config file
	settings.reorder_list(&list);

	//set the scale
	list.set_scale((Element::scale_t)settings.scaling);
	//set the auto_mute
	list.set_auto_mute(settings.auto_mute);
	
	//initialize gtk
	gtk_init(&argc, &argv);

	//set up the tray_slider that goes in the tray
	if (settings.enable_tray_icon){
		GtkWidget *tray_frame;
		tray_frame = gtk_alignment_new(0.5,0.0,0,0);
		settings.tray_slider = new retro_slider;
		settings.set_tray_slider(&list);
		settings.apply_to_tray_slider(settings.tray_slider);
		if (list.num_elems > 0){
			settings.tray_slider->init(tray_frame, (void*)settings.tray_control, &Element::get_callback, &Element::set_callback, (settings.tray_control->values > 1));
		} else {
			settings.tray_control = NULL;
		}

		//set up the small window that holds the tray_slider
		settings.slider_window = gtk_window_new (GTK_WINDOW_POPUP);
		gtk_window_set_resizable(GTK_WINDOW(settings.slider_window), false);
		gtk_window_set_decorated(GTK_WINDOW(settings.slider_window), false);
		gtk_window_set_skip_taskbar_hint(GTK_WINDOW(settings.slider_window), true);
		gtk_window_set_skip_pager_hint(GTK_WINDOW(settings.slider_window), true);
		gtk_widget_set_usize(settings.slider_window, settings.tray_slider->width, settings.tray_slider->height);
		//don't want accidental closure of the slider window to destroy the window
		g_signal_connect(settings.slider_window, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
		//want the widow to go away when it loses focus
		g_signal_connect(settings.slider_window, "focus-out-event", G_CALLBACK (gtk_widget_hide), NULL);
		gtk_container_add( GTK_CONTAINER(settings.slider_window), tray_frame );
		//we want it hidden by default, but it must be shown at least once or else scrolling over the icon will cause a hang
		gtk_widget_show_all(settings.slider_window);
		gtk_widget_hide_all(settings.slider_window);
		
			
		//set up tray icon
#if GTK_CHECK_VERSION(2,16,0)
		settings.tray_icon = gtk_status_icon_new();
		gtk_status_icon_set_from_file(settings.tray_icon, VOL_MUTED_IMAGE);
#else
		settings.tray_icon = GTK_WIDGET(egg_tray_icon_new("Retrovol Tray Icon"));
		//set the background color
		bool enable_tray_icon_background_color = settings.enable_tray_icon_background_color; 
		GdkColor bg_color;
		char bg_color_str[8];
		if (cmdline_enable_bg_color){
			enable_tray_icon_background_color = true;
			strcpy(bg_color_str, cmdline_bg_color);
		} else if (settings.enable_tray_icon_background_color){
			settings.nftoh(settings.tray_icon_background_color, bg_color_str);
		}
		if (enable_tray_icon_background_color){
			if (gdk_color_parse(bg_color_str, &bg_color)){
				GtkStyle *style = gtk_style_copy(gtk_widget_get_style(settings.tray_icon));
				style->bg[GTK_STATE_NORMAL] = bg_color;
				gtk_widget_set_style(settings.tray_icon, style);
			} else {
				fprintf(stderr, _("Error:  Failed to set background color to %s\n"), bg_color_str);
			}
		}
		//set up the images
		settings.tray_icon_image = gtk_image_new();
		gtk_container_add( GTK_CONTAINER(settings.tray_icon), settings.tray_icon_image );
		gtk_image_set_from_file(GTK_IMAGE(settings.tray_icon_image), VOL_MEDIUM_IMAGE);
		//set the event mask
		gtk_widget_set_events (settings.tray_icon, GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK);
#endif

		//signals
		g_signal_connect(G_OBJECT(settings.tray_icon), "button_press_event", G_CALLBACK (&tray_button_press_event_callback), settings.slider_window);
		if (settings.tray_control){
			g_signal_connect(G_OBJECT(settings.tray_icon), "scroll_event", G_CALLBACK (&retro_slider::scroll_event_callback), settings.tray_slider);
		}

#if GTK_CHECK_VERSION(2,16,0)
		//make icon visible
		gtk_status_icon_set_visible(settings.tray_icon, true);
#else
		//handle situations where the icon's window dies, such as due to the tray itself exiting
		g_signal_connect(G_OBJECT(settings.tray_icon), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);

		//make icon visible
		gtk_widget_show_all(settings.tray_icon);
#endif

		//set up the popup menu (the function checks if it should actually do anything)
		set_menu();

	}
	


	//set up the window
	settings.main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	//gtk_window_set_position(GTK_WINDOW(settings.main_window), GTK_WIN_POS_CENTER);
	gtk_window_set_default_size(GTK_WINDOW(settings.main_window), settings.window_width, settings.window_height);
	gtk_window_set_title(GTK_WINDOW(settings.main_window), "Retrovol");
	restore_posdim();
	g_signal_connect(settings.main_window, "configure-event", G_CALLBACK (save_posdim), NULL);
	
	//if the tray icon is enabled, we want the window to hide rather than closing
	if (settings.enable_tray_icon){
		g_signal_connect(settings.main_window, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
	}

	//make the over_box, which will hold stuff like the menu, status bar, and the actual content in the middle
	GtkWidget *over_box;
	over_box = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(settings.main_window), over_box);

	//define the menu
	GtkItemFactoryEntry menu_items_1[] = {
		{ (gchar*)_("/_File"),           NULL,              NULL,                      0, (gchar*)"<Branch>" },
		{ (gchar*)_("/File/_Configure"), (gchar*)"<CTRL>C", G_CALLBACK(configure),     0, (gchar*)"<StockItem>", GTK_STOCK_EXECUTE },
		{ (gchar*)_("/File/_Quit"),      (gchar*)"<CTRL>Q", G_CALLBACK(close_window),  0, (gchar*)"<StockItem>", GTK_STOCK_QUIT },
	};
	gint nmenu_items_1 = sizeof (menu_items_1) / sizeof (menu_items_1[0]);
	
	GtkItemFactoryEntry menu_items_2[] = {
		{ (gchar*)_("/_File"),           NULL,              NULL,                      0, (gchar*)"<Branch>" },
		{ (gchar*)_("/File/_Configure"), (gchar*)"<CTRL>C", G_CALLBACK(configure),     0, (gchar*)"<StockItem>", GTK_STOCK_EXECUTE },
		{ (gchar*)_("/File/_Exit completely"),      (gchar*)"<CTRL>E", G_CALLBACK(gtk_main_quit),  0, (gchar*)"<StockItem>", GTK_STOCK_QUIT },
		{ (gchar*)_("/File/_Quit"),      (gchar*)"<CTRL>Q", G_CALLBACK(close_window),  0, (gchar*)"<StockItem>", GTK_STOCK_QUIT },
	};
	gint nmenu_items_2 = sizeof (menu_items_2) / sizeof (menu_items_2[0]);

	GtkItemFactoryEntry *menu_items;
	gint nmenu_items;
	//if the tray menu is enabled, don't have the "Exit" entry in the main menu
	if (settings.enable_tray_menu){
		menu_items = menu_items_1;
		nmenu_items = nmenu_items_1;
	} else {
		menu_items = menu_items_2;
		nmenu_items = nmenu_items_2;
	}

	//build the menu
	GtkWidget *menubar;
	menubar = get_menubar_menu(settings.main_window, menu_items, nmenu_items, "<RetrovolMain>");
	gtk_box_pack_start(GTK_BOX(over_box), menubar, FALSE, TRUE, 0);


	//use a scrolled window
	GtkWidget *scrolled_window;
	scrolled_window = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(over_box), scrolled_window);
	
	//put the stuff into a viewport manually, so we can specify that it should have no shadow
	GtkWidget *viewport;
	viewport = gtk_viewport_new(NULL, NULL);
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
	gtk_container_add(GTK_CONTAINER(scrolled_window), viewport);
	
			
	//and create an Hbox to hold all the stuff
	GtkWidget *hbox;
	if (settings.vertical){
		hbox = gtk_hbox_new(TRUE, 2);
		gtk_container_add(GTK_CONTAINER(viewport), hbox);
	} else {
		hbox = gtk_vbox_new(TRUE, 2);
		gtk_container_add(GTK_CONTAINER(viewport), hbox);
	}
			
	//add the sliders
	retro_slider *sliders = new retro_slider[list.num_items];
	
	for(int i=0; i<list.num_items; i++){
		//use a vbox w/ slider on top and label on bottom
		GtkWidget *vbox;
		if (settings.vertical){
			vbox = gtk_vbox_new(FALSE, 2);
		} else {
			vbox = gtk_hbox_new(FALSE, 2);
		}
		gtk_box_pack_start(GTK_BOX(hbox), vbox, false, false, 0);
		
		if (strcmp(list.items[i]->type, "INTEGER") == 0){
			//integers need sliders
			//the rslider pseudo-widget likes to be inside a container, lets use a GtkAlignment
			GtkWidget *frame;
			if (settings.vertical){
				frame = gtk_alignment_new(0.5,0.0,0,0);
				gtk_box_pack_start(GTK_BOX(vbox), frame, false, false, 0);
			} else {
				frame = gtk_alignment_new(0.0,0.5,0,0);
				gtk_box_pack_end(GTK_BOX(vbox), frame, false, false, 0);
			}
			//make the slider and associate with a control
			settings.apply_to_slider(&sliders[i]);
			sliders[i].init(frame, (void*)list.items[i], &Element::get_callback, &Element::set_callback, (list.items[i]->values > 1));
		
		} else if (strcmp(list.items[i]->type, "BOOLEAN") == 0){
			//booleans need checkboxes
			GtkWidget *alignment;
			if (settings.vertical){
				alignment = gtk_alignment_new(0.5,1.0,0,0);
				gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0);
			} else {
				alignment = gtk_alignment_new(1.0,0.5,0,0);
				gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0);
			}
			GtkWidget *chkbx;
			chkbx = gtk_check_button_new();
			//set it to the current state
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chkbx), (bool)list.items[i]->get());
			//bind to the toggle_checkbox function
			Element* ptr = list.items[i];
			g_signal_connect(GTK_TOGGLE_BUTTON(chkbx), "toggled", G_CALLBACK (toggle_checkbox), ptr);
			g_signal_connect_after(GTK_TOGGLE_BUTTON(chkbx), "expose-event", G_CALLBACK (refresh_checkbox), ptr);
			gtk_container_add(GTK_CONTAINER(alignment), chkbx);
		} else if (strcmp(list.items[i]->type, "ENUMERATED") == 0){
			GtkWidget *alignment;
			if (settings.vertical){
				alignment = gtk_alignment_new(0.5,0.5,0,0);
				gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0);
			} else {
				alignment = gtk_alignment_new(1.0,0.5,0,0);
				gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0);
			}
			//insert a combobox with the different options
			GtkWidget *combo_box;
			combo_box=gtk_combo_box_new_text();
			for(unsigned int n=0; n<list.items[i]->number_of_enums; n++){
				gtk_combo_box_append_text(GTK_COMBO_BOX(combo_box), list.items[i]->enums[n]);
			}
			gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), list.items[i]->get());
			//bind to the change_combo_box function
			g_signal_connect(GTK_COMBO_BOX(combo_box), "changed", G_CALLBACK (change_combo_box), list.items[i]);
			gtk_container_add(GTK_CONTAINER(alignment), combo_box);
		}
		
		//add a checkbox for sliders that are muteable
		if (list.items[i]->switch_id >= 0){
			GtkWidget *alignment;
			if (settings.vertical){
				alignment = gtk_alignment_new(0.5,1.0,0,0);
				gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0);
			} else {
				alignment = gtk_alignment_new(1.0,0.5,0,0);
				gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0);
			}
			GtkWidget *chkbx;
			chkbx = gtk_check_button_new();
			//set it to the current state
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chkbx), (bool)list.elems[list.items[i]->switch_id].get());
			//bind to the toggle_checkbox function
			g_signal_connect(GTK_TOGGLE_BUTTON(chkbx), "toggled", G_CALLBACK (toggle_checkbox), &(list.elems[list.items[i]->switch_id]));
			g_signal_connect_after(GTK_TOGGLE_BUTTON(chkbx), "expose-event", G_CALLBACK (refresh_checkbox), &(list.elems[list.items[i]->switch_id]));
			
			gtk_container_add(GTK_CONTAINER(alignment), chkbx);
		}
		
		//display the name of the control
		GtkWidget *alignment;
		char wrapped[256];
		if (settings.vertical){
			alignment = gtk_alignment_new(0.5,1.0,0,0);
			gtk_box_pack_end(GTK_BOX(vbox), alignment, false, false, 0);
			word_wrap(wrapped, list.items[i]->short_name);
		} else {
			alignment = gtk_alignment_new(1.0,0.5,0,0);
			gtk_box_pack_start(GTK_BOX(vbox), alignment, false, false, 0);
			strcpy(wrapped, list.items[i]->short_name);
		}
		GtkWidget *label;
		label = gtk_label_new(wrapped);
		gtk_container_add(GTK_CONTAINER(alignment), label);
	}
	
	//finish the window stuff
	if (!start_hidden){ gtk_widget_show_all(settings.main_window); }
	g_signal_connect(settings.main_window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
	

	//add some periodic refreshment to keep the icon and window up-to-date
	#if GTK_CHECK_VERSION(2,14,0)
		int timeout = g_timeout_add_seconds(1, update, NULL);
	#else
		//this is less efficient than g_timeout_add_seconds()
		int timeout = g_timeout_add(1000, update, NULL);
	#endif
	
	//finished with gtk setup
	gtk_main();

	//stop the timeout
	g_source_remove(timeout);
	
	//have the window shown again if it was open before we restarted
	if (settings.resume_main){
		settings.resume_main = false;
		start_hidden = false;
	} else {
		start_hidden = true;
	}

	return(settings.restart);
}
Beispiel #16
0
GtkWidget *
pgd_text_create_widget (PopplerDocument *document)
{
	PgdTextDemo      *demo;
	GtkWidget        *label;
	GtkWidget        *vbox, *vbox2;
	GtkWidget        *hbox, *page_selector, *area_hbox;
	GtkWidget        *button;
	GtkWidget        *swindow, *textview, *treeview;
	GtkTreeSelection *selection;
        GtkWidget        *frame, *alignment, *table;
	GtkWidget        *hpaned;
	GtkCellRenderer  *renderer;
	gchar            *str;
	gint              n_pages;
        gint              row = 0;

	demo = g_new0 (PgdTextDemo, 1);

	demo->doc = g_object_ref (document);

	n_pages = poppler_document_get_n_pages (document);

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
	vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);

	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

	label = gtk_label_new ("Page:");
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
	gtk_widget_show (label);

	page_selector = gtk_spin_button_new_with_range (1, n_pages, 1);
	g_signal_connect (G_OBJECT (page_selector), "value-changed",
			  G_CALLBACK (pgd_text_page_selector_value_changed),
			  (gpointer)demo);
	gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0);
	gtk_widget_show (page_selector);

	str = g_strdup_printf ("of %d", n_pages);
	label = gtk_label_new (str);
	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
	gtk_widget_show (label);
	g_free (str);

        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
	gtk_widget_show (hbox);

        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);

        area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
	label = gtk_label_new ("X1:");
	gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0);
	gtk_widget_show (label);

	demo->area_x1 = gtk_spin_button_new_with_range (0, 0, 0.01);
	g_signal_connect (demo->area_x1, "value-changed",
			  G_CALLBACK (pgd_text_area_selector_value_changed),
			  demo);
	gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x1, TRUE, TRUE, 0);
	gtk_widget_show (demo->area_x1);

	gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0);
	gtk_widget_show (area_hbox);

        area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
	label = gtk_label_new ("Y1:");
	gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0);
	gtk_widget_show (label);

	demo->area_y1 = gtk_spin_button_new_with_range (0, 0, 0.01);
        g_signal_connect (demo->area_y1, "value-changed",
			  G_CALLBACK (pgd_text_area_selector_value_changed),
			  demo);
	gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y1, TRUE, TRUE, 0);
	gtk_widget_show (demo->area_y1);

	gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0);
	gtk_widget_show (area_hbox);

        area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
	label = gtk_label_new ("X2:");
	gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0);
	gtk_widget_show (label);

	demo->area_x2 = gtk_spin_button_new_with_range (0, 0, 0.01);
        g_signal_connect (demo->area_x2, "value-changed",
                          G_CALLBACK (pgd_text_area_selector_value_changed),
                          demo);
	gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x2, TRUE, TRUE, 0);
	gtk_widget_show (demo->area_x2);

	gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0);
	gtk_widget_show (area_hbox);

        area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
	label = gtk_label_new ("Y2:");
	gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0);
	gtk_widget_show (label);

	demo->area_y2 = gtk_spin_button_new_with_range (0, 0, 0.01);
        g_signal_connect (demo->area_y2, "value-changed",
                          G_CALLBACK (pgd_text_area_selector_value_changed),
                          demo);
	gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y2, TRUE, TRUE, 0);
	gtk_widget_show (demo->area_y2);

	gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0);
	gtk_widget_show (area_hbox);

        pgd_text_area_selector_setup (demo);

	button = gtk_button_new_with_label ("Get Text");
	g_signal_connect (G_OBJECT (button), "clicked",
			  G_CALLBACK (pgd_text_get_text),
			  (gpointer)demo);
	gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
	gtk_widget_show (button);

	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
	gtk_widget_show (hbox);

	demo->timer_label = gtk_label_new (NULL);
	gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>");
	g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL);
	gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0);
	gtk_widget_show (demo->timer_label);

	hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_paned_set_position (GTK_PANED (hpaned), 300);

	swindow = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
					GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);

	demo->model = gtk_list_store_new (N_COLUMNS,
					  G_TYPE_STRING,
					  G_TYPE_STRING, G_TYPE_STRING,
					  G_TYPE_STRING, G_TYPE_STRING,
					  G_TYPE_POINTER);
	treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model));
        demo->treeview = treeview;

	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
						     TEXT_X1_COLUMN, "X1",
						     renderer,
						     "text", TEXT_X1_COLUMN,
						     NULL);
	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
						     TEXT_Y1_COLUMN, "Y1",
						     renderer,
						     "text", TEXT_Y1_COLUMN,
						     NULL);
	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
						     TEXT_X2_COLUMN, "X2",
						     renderer,
						     "text", TEXT_X2_COLUMN,
						     NULL);
	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
						     TEXT_Y2_COLUMN, "Y2",
						     renderer,
						     "text", TEXT_Y2_COLUMN,
						     NULL);

	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
						     TEXT_OFFSET_COLUMN, "Offset",
						     renderer,
						     "text", TEXT_OFFSET_COLUMN,
						     NULL);

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
	g_signal_connect (selection, "changed",
			  G_CALLBACK (pgd_text_selection_changed),
			  (gpointer) demo);

	gtk_container_add (GTK_CONTAINER (swindow), treeview);
	gtk_widget_show (treeview);

        gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0);
        gtk_widget_show (swindow);

        /* Text attributes */
        frame = gtk_frame_new (NULL);
        gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
        label = gtk_label_new (NULL);
        gtk_label_set_markup (GTK_LABEL (label), "<b>Text Attributes</b>");
        gtk_frame_set_label_widget (GTK_FRAME (frame), label);
        gtk_widget_show (label);

        alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
        gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5);
        gtk_container_add (GTK_CONTAINER (frame), alignment);
        gtk_widget_show (alignment);

        table = gtk_grid_new ();
        gtk_grid_set_column_spacing (GTK_GRID (table), 6);
        gtk_grid_set_row_spacing (GTK_GRID (table), 6);

        demo->font_name = gtk_label_new (NULL);
        pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Name:</b>", demo->font_name, &row);
        demo->font_size = gtk_label_new (NULL);
        pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Size:</b>", demo->font_size, &row);
        demo->is_underlined = gtk_label_new (NULL);
        pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Underlined:</b>", demo->is_underlined, &row);
        demo->text_color = gtk_image_new ();
        pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Color:</b>", demo->text_color, &row);

        gtk_container_add (GTK_CONTAINER (alignment), table);
        gtk_widget_show (table);

	gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 12);
        gtk_widget_show (frame);
	gtk_paned_add1 (GTK_PANED (hpaned), vbox2);
	gtk_widget_show (vbox2);

	swindow = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
					GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);

	demo->buffer = gtk_text_buffer_new (NULL);
	textview = gtk_text_view_new_with_buffer (demo->buffer);
        g_signal_connect (textview, "query-tooltip",
                          G_CALLBACK (pgd_text_view_query_tooltip),
                          demo);
        g_signal_connect (demo->buffer, "notify::has-selection",
                          G_CALLBACK (pgd_text_buffer_selection_changed),
                          textview);

	gtk_container_add (GTK_CONTAINER (swindow), textview);
	gtk_widget_show (textview);

	gtk_paned_add2 (GTK_PANED (hpaned), swindow);
	gtk_widget_show (swindow);

	gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
	gtk_widget_show (hpaned);

	g_object_weak_ref (G_OBJECT (vbox),
			   (GWeakNotify)pgd_text_free,
			   demo);

	return vbox;
}
int main(int argc, char *argv[])
{
    	GtkWidget *window;
	int i, j, k;
	count = 0;

	/*initiate gtk*/
	gtk_init(&argc, &argv);
    	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    	gtk_window_set_title(GTK_WINDOW(window), "Spectrogram");
    	gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
    	gtk_container_set_border_width(GTK_CONTAINER(window), 2);
    	image = gtk_image_new();
    	gtk_container_add(GTK_CONTAINER(window), image);
    	g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
    	gtk_widget_show_all(window);
	/*END*/

	/*Initialize socket*/
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	
	if (sockfd < 0)
        	error1("ERROR opening socket");
    	bzero((char *) &serv_addr, sizeof(serv_addr));
    	port_num = 51717;
    	serv_addr.sin_family = AF_INET;
    	serv_addr.sin_addr.s_addr = INADDR_ANY; 
    	serv_addr.sin_port = htons(port_num);
    	if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
        	error1("ERROR on binding");
    	listen(sockfd,5);
    	clilen = sizeof(cli_addr);
	
    	newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
    	if (newsockfd < 0)
       		error1("ERROR on accept");

	//First Header
    	fprintf(stderr, "Reading header... ");  
    	n = read(newsockfd, &header, sizeof(struct fft_header));
    	if (n < 0)
       		error1("ERROR reading from socket");
    	else if (n > 0)
	{
		printf("header.constSync is %X\n", header.constSync);
		if(header.constSync != 0xACFDFFBC)
			error1("ERROR reading from socket, incorrect header placement\n");
	}
	else if( n == 0)
	{
		printf("Sender has closed connection\n");
		exit(0);
	}

	//Initializing structures
	samp_rate = header.ptsPerFFT;
	CAMERA_WIDTH = samp_rate;
	rgbImage = malloc(sizeof(struct pixel) * (CAMERA_HEIGHT*CAMERA_WIDTH));
	rgbImageTemp = malloc(sizeof(struct pixel) * (CAMERA_HEIGHT*CAMERA_WIDTH));
	buffer = malloc(sizeof(float) * samp_rate);
	bufSize = sizeof(float)* samp_rate;
	length = (sizeof(struct fft_header) + sizeof(float)* samp_rate);
	size =  length* 2 + 1;
	tempBuf = malloc(length);

	//First Data
	fprintf(stderr, "Reading data... ");
    	n = read(newsockfd, (char *) buffer, header.ptsPerFFT * sizeof(float));
    	if (n < 0)
    		error1("ERROR reading from socket");
	else if( n == 0)
	{
		printf("Sender has closed connection\n");
		exit(0);
	}
	
	/*End*/
	
	//gtk initialization
	/*Initialize screen with color*/
	for(j = 0; j < CAMERA_WIDTH; j++)
	{
		for(i = CAMERA_HEIGHT-1; i>=0 ; i--)
		{		
			rgbImage[j+i*CAMERA_WIDTH].blue = BLUEMAC(0);
			rgbImage[j+i*CAMERA_WIDTH].red = REDMAC(0);
			rgbImage[j+i*CAMERA_WIDTH].green = GREENMAC(0);
		}
	}
	for(i = 0; i<CAMERA_WIDTH ; i++)
	{		
		rgbImage[i].blue = BLUEMAC(buffer[i]);
		rgbImage[i].red = REDMAC(buffer[i]);
		rgbImage[i].green = GREENMAC(buffer[i]);
	}
	
	//loadeImage function
	loadImage(rgbImage);

	//call shift every 50msec
	gint func_ref = g_timeout_add(50, getData, NULL);
	
	gtk_main();
	g_source_remove (func_ref);
   
    return 0;

}
static GtkWidget *
build_tab_label (NautilusNotebook *nb, NautilusWindowSlot *slot)
{
	NautilusDragSlotProxyInfo *drag_info;
	GtkWidget *hbox, *label, *close_button, *image, *spinner, *icon;

	/* set hbox spacing and label padding (see below) so that there's an
	 * equal amount of space around the label */
	hbox = gtk_hbox_new (FALSE, 4);
	gtk_widget_show (hbox);

	/* setup load feedback */
	spinner = ephy_spinner_new ();
	ephy_spinner_set_size (EPHY_SPINNER (spinner), GTK_ICON_SIZE_MENU);
	gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);

	/* setup site icon, empty by default */
	icon = gtk_image_new ();
	gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
	/* don't show the icon */

	/* setup label */
	label = gtk_label_new (NULL);
	gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
	gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE);
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_misc_set_padding (GTK_MISC (label), 0, 0);
	gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
	gtk_widget_show (label);

	/* setup close button */
	close_button = gtk_button_new ();
	gtk_button_set_relief (GTK_BUTTON (close_button),
			       GTK_RELIEF_NONE);
	/* don't allow focus on the close button */
	gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);

	gtk_widget_set_name (close_button, "nautilus-tab-close-button");

	image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
	gtk_widget_set_tooltip_text (close_button, _("Close tab"));
	g_signal_connect_object (close_button, "clicked",
				 G_CALLBACK (close_button_clicked_cb), slot, 0);

	gtk_container_add (GTK_CONTAINER (close_button), image);
	gtk_widget_show (image);

	gtk_box_pack_start (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
	gtk_widget_show (close_button);

	/* Set minimal size */
	g_signal_connect (hbox, "style-set",
			  G_CALLBACK (tab_label_style_set_cb), NULL);

	drag_info = g_new0 (NautilusDragSlotProxyInfo, 1);
	drag_info->target_slot = slot;
	g_object_set_data_full (G_OBJECT (hbox), "proxy-drag-info",
				drag_info, (GDestroyNotify) g_free);

	nautilus_drag_slot_proxy_init (hbox, drag_info);

	g_object_set_data (G_OBJECT (hbox), "label", label);
	g_object_set_data (G_OBJECT (hbox), "spinner", spinner);
	g_object_set_data (G_OBJECT (hbox), "icon", icon);
	g_object_set_data (G_OBJECT (hbox), "close-button", close_button);

	return hbox;
}
Beispiel #19
0
static void tb_editor_set_item_values(TBEditorWidget *tbw, const gchar *action_name,
                                      GtkListStore *store, GtkTreeIter *iter)
{
    gchar *icon = NULL;
    gchar *label = NULL;
    gchar *label_clean = NULL;
    GdkPixbuf *pix = NULL;
    GtkAction *action;

    action = gtk_action_group_get_action(marlin_view_window_get_actiongroup(tbw->mvw), action_name);

    if (action != NULL)
    {
        /*gtk_action_block_activate(action);
          log_printf (LOG_LEVEL_UNDEFINED, "blocked %s\n", action_name);*/
        icon = katze_object_get_string(action, "icon-name");
        if (icon == NULL)
        {
            icon = katze_object_get_string(action, "stock-id");
        }

        label = katze_object_get_string(action, "label");
        if (label != NULL)
            label_clean = katze_strip_mnemonics(label);
    }
    else
        label_clean = strdup(action_name);


    GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
    /*GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (icon_theme, icon, 16,
      GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_GENERIC_FALLBACK | GTK_ICON_LOOKUP_FORCE_SIZE);
      gchar *test;
      test = gtk_icon_info_get_filename (icon_info);
    //log_printf (LOG_LEVEL_UNDEFINED, "action: %20s icon: %20s\n", action_name, icon);
    log_printf (LOG_LEVEL_UNDEFINED, "action: %20s icon: %20s test: %s\n", action_name, icon, test);*/


    if (icon != NULL)
    {
        //GtkIconSize status_btn_size = gtk_icon_size_from_name ("16px");
        GtkWidget *image = gtk_image_new ();
        //pix = gtk_widget_render_icon (image, icon, status_btn_size, NULL);
        pix = gtk_widget_render_icon (image, icon, GTK_ICON_SIZE_MENU, NULL);
        gtk_widget_destroy (image);

        if (pix==NULL && icon!=NULL)
            pix = gtk_icon_theme_load_icon (icon_theme, icon, 16,
                                            GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_GENERIC_FALLBACK | GTK_ICON_LOOKUP_FORCE_SIZE, NULL);
    }

    gtk_list_store_set(store, iter,
                       TB_EDITOR_COL_ACTION, action_name,
                       TB_EDITOR_COL_LABEL, label_clean,
                       //TB_EDITOR_COL_LABEL, action_name,
                       TB_EDITOR_COL_ICON, pix,
                       -1);

    g_free(icon);
    g_free(label);
    g_free(label_clean);
}
Beispiel #20
0
static void _lib_import_single_image_callback(GtkWidget *widget, gpointer user_data)
{
  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
  GtkWidget *filechooser = gtk_file_chooser_dialog_new(
      _("import image"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL,
      _("_Open"), GTK_RESPONSE_ACCEPT, (char *)NULL);

  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);

  char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
  if(last_directory != NULL)
  {
    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
    g_free(last_directory);
  }

  char *cp, **extensions, ext[1024];
  GtkFileFilter *filter;
  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  extensions = g_strsplit(dt_supported_extensions, ",", 100);
  for(char **i = extensions; *i != NULL; i++)
  {
    snprintf(ext, sizeof(ext), "*.%s", *i);
    gtk_file_filter_add_pattern(filter, ext);
    gtk_file_filter_add_pattern(filter, cp = g_ascii_strup(ext, -1));
    g_free(cp);
  }
  g_strfreev(extensions);
  gtk_file_filter_set_name(filter, _("supported images"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);

  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_pattern(filter, "*");
  gtk_file_filter_set_name(filter, _("all files"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);

  GtkWidget *preview = gtk_image_new();
  gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview);
  g_signal_connect(filechooser, "update-preview", G_CALLBACK(_lib_import_update_preview), preview);

  dt_lib_import_metadata_t metadata;
  gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser),
                                    _lib_import_get_extra_widget(&metadata, FALSE));

  if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    dt_conf_set_string("ui_last/import_last_directory",
                       gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser)));
    _lib_import_evaluate_extra_widget(&metadata, FALSE);

    char *filename = NULL;
    dt_film_t film;
    GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser));
    GSList *it = list;
    int id = 0;
    int filmid = 0;

    /* reset filter so that view isn't empty */
    dt_view_filter_reset(darktable.view_manager, TRUE);

    while(it)
    {
      filename = (char *)it->data;
      gchar *directory = g_path_get_dirname((const gchar *)filename);
      filmid = dt_film_new(&film, directory);
      id = dt_image_import(filmid, filename, TRUE);
      if(!id) dt_control_log(_("error loading file `%s'"), filename);
      g_free(filename);
      g_free(directory);
      it = g_slist_next(it);
    }

    if(id)
    {
      dt_film_open(filmid);
      // make sure buffers are loaded (load full for testing)
      dt_mipmap_buffer_t buf;
      dt_mipmap_cache_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r');
      gboolean loaded = (buf.buf != NULL);
      dt_mipmap_cache_release(darktable.mipmap_cache, &buf);
      if(!loaded)
      {
        dt_control_log(_("file has unknown format!"));
      }
      else
      {
        dt_control_set_mouse_over_id(id);
        dt_ctl_switch_mode_to(DT_DEVELOP);
      }
    }
  }
  gtk_widget_destroy(metadata.frame);
  gtk_widget_destroy(filechooser);
  gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
Beispiel #21
0
GtkWidget * scratch_tab_create()
{
	GtkWidget *vbox = gtk_vbox_new(FALSE, 5);

	/* file list treeview */

	filelist_treeview = gtk_tree_view_new ();
	gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (filelist_treeview), TRUE);
	gtk_tree_view_set_reorderable(GTK_TREE_VIEW (filelist_treeview), FALSE);

	GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(filelist_treeview));
	gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);

	g_signal_connect (G_OBJECT(filelist_treeview), "cursor-changed",
		G_CALLBACK (filelist_treeview_row_selected), NULL);

	filelist_treeview_sw = new_scrolled_window (NULL);
	gtk_container_add (GTK_CONTAINER (filelist_treeview_sw), filelist_treeview);

	/* add columns to the tree view */
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *col;
	int i;
	int col_count = sizeof (filelist_treeview_col_names) / sizeof (char *);

	for (i=0; i<col_count; i++) {
		renderer = gtk_cell_renderer_text_new();
		col = gtk_tree_view_column_new_with_attributes (filelist_treeview_col_names[i],
			renderer, "text", i, NULL);
		if (i == 0) {
			gtk_tree_view_column_set_clickable(col, TRUE);
			gtk_tree_view_column_set_sort_order(col, GTK_SORT_DESCENDING);
			gtk_tree_view_column_set_sort_column_id(col, 0);
			gtk_tree_view_column_set_sort_indicator(col, TRUE);
		} else {
			gtk_tree_view_column_set_clickable(col, FALSE);
		}
		gtk_tree_view_append_column (GTK_TREE_VIEW(filelist_treeview), col);
	}

	filelist_store = gtk_list_store_new (col_count,	G_TYPE_STRING, G_TYPE_STRING);
	GtkTreeSortable *sortable = GTK_TREE_SORTABLE(filelist_store);
	gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_DESCENDING);

	gtk_tree_view_set_model(GTK_TREE_VIEW(filelist_treeview), GTK_TREE_MODEL(filelist_store));

	GtkWidget *hbox = gtk_hbox_new(TRUE, 5);

	GtkWidget *scratch_button = gtk_button_new_with_label("Scratch on map");
	g_signal_connect (G_OBJECT (scratch_button), "clicked",
		G_CALLBACK (scratch_button_clicked), NULL);

	view_button = gtk_button_new_with_label("View");
	g_signal_connect (G_OBJECT(view_button), "clicked",
		G_CALLBACK (view_button_clicked), NULL);

	delete_button = gtk_button_new_with_label("Delete");
	g_signal_connect (G_OBJECT(delete_button), "clicked",
		G_CALLBACK (delete_button_clicked), NULL);

	gtk_container_add(GTK_CONTAINER(hbox), view_button);
	gtk_container_add(GTK_CONTAINER(hbox), delete_button);
	gtk_container_add(GTK_CONTAINER(hbox), scratch_button);

	gtk_box_pack_start(GTK_BOX(vbox), filelist_treeview_sw, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);

	/* populate files into filelist treeview */

	GtkTreeIter iter;
	struct dirent *ep;
	char buf[256];
	char *file_path = NULL;
	int len, ext_len = strlen(SCREENSHOT_FILE_EXT);
	char *fname;
	struct stat st;

	DIR *dp = opendir (g_context.screenshot_dir);
	if (dp == NULL) {
		if (stat(buf, &st) == 0)
			warn_dialog("unable to list screenshot files");
	} else {
		while ((ep = readdir (dp))) {
			fname = ep->d_name;
			len = strlen(fname);
			if (ep->d_type == DT_REG && len > ext_len &&
				(strncmp(&fname[len-ext_len], SCREENSHOT_FILE_EXT, ext_len) == 0)) {

				gtk_list_store_prepend (filelist_store, &iter);

				file_path = get_full_path(buf, sizeof(buf), fname);
				add_file_to_list(&iter, file_path, fname);
			}
		}
		closedir (dp);
	}

	notebook = gtk_notebook_new();
	gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), FALSE);
	gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);

	GtkWidget *label;

	label = gtk_label_new("screen shot list");
	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);

	GtkWidget *image_box = gtk_vbox_new(FALSE, 0);
	screenshot_label = gtk_label_new("");
	screenshot_image = gtk_image_new();
	gtk_box_pack_start(GTK_BOX(image_box), screenshot_label, FALSE, FALSE, 0);

	GtkWidget *sw = new_scrolled_window (screenshot_image);

	/* stretch */
	gtk_box_pack_start(GTK_BOX(image_box), sw, TRUE, TRUE, 0);

	label = gtk_label_new("view screen shot");
	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), image_box, label);

	return notebook;
}
Beispiel #22
0
void update_sidepanel()
{
  int i;
  for(i = 0; i < BUFFER_COUNT; i++)
    {
      if(icons[i] != NULL)
	{
	  gtk_widget_hide(icons[i]);
	  gtk_widget_destroy(icons[i]);
	  gtk_widget_hide(icon_event_boxes[i]);
	  gtk_widget_destroy(icon_event_boxes[i]);
	  icons[i] = NULL;
	  icon_event_boxes[i] = NULL;
	}
    }

  for(i = 0; i < BUFFER_COUNT; i++)
    {
      if(mdata[i] != NULL)
	{
	  if(i == current_buffer)
	    {
	      GdkColor color;

	      gdk_color_parse("red", &color);

	      if(selected_buffer_frame != NULL)
		gtk_widget_destroy(selected_buffer_frame);
	      selected_buffer_frame = gtk_frame_new(NULL);
	      gtk_widget_modify_bg(selected_buffer_frame, GTK_STATE_NORMAL, &color);
	      gtk_box_pack_start(GTK_BOX(list_vbox), selected_buffer_frame, FALSE, TRUE, 1);

	      icons[i] = gtk_image_new();
	      icon_event_boxes[i] = gtk_event_box_new();

	      gtk_image_set_from_pixbuf(GTK_IMAGE(icons[i]), get_pixbuf_from_data(mdata[i], 0));

	      gtk_container_add(GTK_CONTAINER(selected_buffer_frame), icon_event_boxes[i]);
	      gtk_container_add(GTK_CONTAINER(icon_event_boxes[i]), icons[i]);

	      gtk_widget_show(icons[i]);
	      gtk_widget_show(icon_event_boxes[i]);
	      gtk_widget_show(selected_buffer_frame);

	      g_signal_connect(G_OBJECT(icon_event_boxes[i]), "button_press_event", G_CALLBACK(buffer_callback), (gpointer *)(size_t)i);
	    }
	  else
	    {
	      icons[i] = gtk_image_new();
	      icon_event_boxes[i] = gtk_event_box_new();

	      gtk_image_set_from_pixbuf(GTK_IMAGE(icons[i]), get_pixbuf_from_data(mdata[i], 0));

	      gtk_box_pack_start(GTK_BOX(list_vbox), icon_event_boxes[i], FALSE, TRUE, 2);
	      gtk_container_add(GTK_CONTAINER(icon_event_boxes[i]), icons[i]);

	      gtk_widget_show(icons[i]);
	      gtk_widget_show(icon_event_boxes[i]);

	      g_signal_connect(G_OBJECT(icon_event_boxes[i]), "button_press_event", G_CALLBACK(buffer_callback), (gpointer *)(size_t)i);
	    }
	}
    }
}
Beispiel #23
0
static void egg_tray_icon_update_manager_window (EggTrayIcon *icon) {

	static GdkPixbuf *background_pixbuf;
	const gchar *window_manager=NULL;

	if (icon->manager_window != None) {
		GdkWindow *gdkwin;
		gdkwin = gdk_window_lookup (icon->manager_window);
		gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon);
	}

	XGrabServer (GDK_DISPLAY());

	icon->manager_window = XGetSelectionOwner (GDK_DISPLAY(),
			icon->selection_atom);

	if (icon->manager_window != None)
		XSelectInput (GDK_DISPLAY(), icon->manager_window, StructureNotifyMask);

	XUngrabServer (GDK_DISPLAY());
	XFlush (GDK_DISPLAY());

	if (icon->manager_window == None)
		return;

	window_manager=gdk_x11_screen_get_window_manager_name (gdk_screen_get_default());

	if ( !g_ascii_strcasecmp(window_manager, kde_window_manger) && kde_dock (icon)) {

		if ((background_pixbuf=kde_dock_background(icon)) !=NULL) {

			icon->box= gtk_fixed_new ();
			gtk_fixed_set_has_window(GTK_FIXED (icon->box),TRUE);
			gtk_container_add(GTK_CONTAINER(icon), icon->box);

			icon->image=gtk_image_new ();
			gtk_image_set_from_pixbuf(GTK_IMAGE(icon->image), icon->default_pix);

			icon->background =gtk_image_new ();
			gtk_image_set_from_pixbuf(GTK_IMAGE(icon->background), background_pixbuf);

			gtk_fixed_put (GTK_FIXED (icon->box), GTK_WIDGET(icon->background), 0, 0);
			gtk_fixed_put (GTK_FIXED (icon->box), GTK_WIDGET(icon->image), 0, 0);

			gtk_widget_show (icon->background);
			gtk_widget_show (icon->image);
			gtk_widget_show(icon->box);

			icon->ready=TRUE;
		}
	} else {

		icon->box=gtk_event_box_new ();
		gtk_container_add(GTK_CONTAINER(icon), icon->box);

		icon->image=gtk_image_new ();
		gtk_image_set_from_pixbuf(GTK_IMAGE(icon->image),icon->default_pix);
		gtk_container_add(GTK_CONTAINER(icon->box), icon->image);

		gtk_widget_show (icon->image);
		gtk_widget_show(icon->box);

		GdkWindow *gdkwin;

		gdkwin = gdk_window_lookup (icon->manager_window);
		gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon);

		/* Send a request that we'd like to dock */
		egg_tray_icon_send_dock_request (icon);
	}
}
Beispiel #24
0
int main(int argc, char ** argv)
{
  GtkWidget * vbox;
  GtkWidget * hpaned;
  GtkWidget * sc_win, * sc_buffer;
  GtkWidget * menu_bar;
  GtkWidget * file_menu, * file_item, * open_item, * save_item, * quit_item, * exp_img_item, * save_raw_data_item;
  GtkWidget * generate_menu, * generate_item, * mandelbrot_item, * julia_item, * palette_item, * random_noise_item, * from_clipboard_item;
  GtkWidget * settings_menu, * settings_item;
	
  GtkWidget * zoom_box, * zoom_button;
	
  //init general
  colors = (color_t *)malloc(56 * sizeof(color_t));
  memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *));
  memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *));
  memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *));
  mdata[current_buffer] = (unsigned char *)malloc(128 * 128);
	
  char * templine = malloc(13);
  FILE * fcolors = fopen("colors", "r");
	
  int i, r, g, b;
  for(i = 0; fgets(templine, 13, fcolors) == templine; i++)
    {
      sscanf(templine, "%i,%i,%i", &r, &g, &b);
      color_t color = {r, g, b};
      colors[i] = color;
    }
	
  free(templine);
  fclose(fcolors);
	
  save_colors(colors, "colors.bin");
  //load_colors(colors, "colors.bin");
	
  srand(time(NULL));
	
  config = config_new();
	
  //init gtk
  gtk_init(&argc, &argv);
	
  //window
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER);
  g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL);
	
  //vbox
#ifdef GTK2
  vbox = gtk_vbox_new(FALSE, 0);
#else
  vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
  gtk_container_add(GTK_CONTAINER (window), vbox);
  gtk_widget_show(vbox);
	
  //////menu_bar
  menu_bar = gtk_menu_bar_new();
  gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0);
  gtk_widget_show(menu_bar);
	
  ////////file_menu
  file_menu = gtk_menu_new();
	
  //////////open_item
  open_item = gtk_menu_item_new_with_label("Open");
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), open_item);
  gtk_widget_show(open_item);
  g_signal_connect_swapped (open_item, "activate",
			    G_CALLBACK (button_click),
			    (gpointer) "button.open");
			
  //////////save_item
  save_item = gtk_menu_item_new_with_label("Save");
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_item);
  gtk_widget_show(save_item);
  g_signal_connect_swapped (save_item, "activate",
			    G_CALLBACK (button_click),
			    (gpointer) "button.save");
			
  //////////save_raw_data_item
  save_raw_data_item = gtk_menu_item_new_with_label("Save Raw Map");
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_raw_data_item);
  gtk_widget_show(save_raw_data_item);
  g_signal_connect_swapped (save_raw_data_item, "activate",
			    G_CALLBACK (button_click),
			    (gpointer) "button.save_rm");
			
  //////////exp_img_item
  exp_img_item = gtk_menu_item_new_with_label("Export Image");
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), exp_img_item);
  gtk_widget_show(exp_img_item);
  g_signal_connect_swapped(exp_img_item, "activate",
			   G_CALLBACK (button_click),
			   (gpointer) "button.exp_img");
	
  //////////quit_item
  quit_item = gtk_menu_item_new_with_label("Quit");
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit_item);
  gtk_widget_show(quit_item);
  g_signal_connect_swapped (quit_item, "activate",
			    G_CALLBACK(kill_window),
			    (gpointer)"button.quit");
	
  /////////file_item
  file_item = gtk_menu_item_new_with_label("File");
  gtk_widget_show(file_item);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
  gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item);
	
  ////////generate_menu
  generate_menu = gtk_menu_new();
	
  //////////mandelbrot_item
  mandelbrot_item = gtk_menu_item_new_with_label("Mandelbrot");
  gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), mandelbrot_item);
  gtk_widget_show(mandelbrot_item);
  g_signal_connect_swapped(mandelbrot_item, "activate",
			   G_CALLBACK(button_click),
			   (gpointer) "button.mandelbrot");
	
  //////////julia_item
  julia_item = gtk_menu_item_new_with_label("Julia");
  gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), julia_item);
  gtk_widget_show(julia_item);
  g_signal_connect_swapped(julia_item, "activate",
			   G_CALLBACK (button_click),
			   (gpointer) "button.julia");
	
  //////////palette_item
  palette_item = gtk_menu_item_new_with_label("Palette");
  gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), palette_item);
  gtk_widget_show(palette_item);
  g_signal_connect_swapped(palette_item, "activate",
			   G_CALLBACK(button_click),
			   (gpointer)"button.palette");

  //////////random_noise_item
  random_noise_item = gtk_menu_item_new_with_label("Random Noise");
  gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), random_noise_item);
  gtk_widget_show(random_noise_item);
  g_signal_connect_swapped(random_noise_item, "activate",
			   G_CALLBACK(button_click),
			   (gpointer)"button.random_noise");

  //////////from_clipboard_item
  from_clipboard_item = gtk_menu_item_new_with_label("From Clipboard");
  gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), from_clipboard_item);
  gtk_widget_show(from_clipboard_item);
  g_signal_connect_swapped(from_clipboard_item, "activate",
			   G_CALLBACK(button_click),
			   (gpointer)"button.from_clipboard");
	
  /////////generate_item
  generate_item = gtk_menu_item_new_with_label("Generate");
  gtk_widget_show(generate_item);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu);
  gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item);

  ////////settings_menu
  settings_menu = gtk_menu_new();
  
  ////////settings_item
  settings_item = gtk_menu_item_new_with_label("Settings");
  gtk_widget_show(settings_item);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu);
  gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item);

  //////////FSD_checkbox
  FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering");
  gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox);
  gtk_widget_show(FSD_checkbox);
  
  //drop_down_menu
  init_drop_down_menu();

  //hpaned
#ifdef GTK2
  hpaned = gtk_hpaned_new();
#else
  hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
#endif
  gtk_widget_set_size_request (hpaned, 220, -1);
  gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
  gtk_widget_show(hpaned);

  ////sc_buffer
  sc_buffer = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
  gtk_widget_set_size_request(sc_buffer, 128 + 32, 512);
#else
  gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32);
  gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512);
#endif
  gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE);
  gtk_widget_show(sc_buffer);

  //////list_vbox
#ifdef GTK2
  list_vbox = gtk_vbox_new(FALSE, 0);
#else
  list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox);
  gtk_widget_show(list_vbox);

  ////sc_win
  sc_win = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
  gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4);
  gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70);
#else
  gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
  gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
#endif
  gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE);
  gtk_widget_show(sc_win);
	
  //////image
  dimage = gdk_pixbuf_new_from_file("start.png", NULL);
  image = gtk_image_new();
  gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image);
  gtk_widget_show(image);
	
  ////zoom_box
#ifdef GTK2
  zoom_box = gtk_hbox_new(FALSE, 0);
#else
  zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
  gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0);
  gtk_widget_show(zoom_box);
	
  //////zoom_button (+)
  zoom_button = gtk_button_new_with_label("+");
	
  gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
  g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp");
  gtk_widget_show(zoom_button);
	
  //////zoom_button (|)
  zoom_button = gtk_button_new_with_label("|");
	
  gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
  g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome");
  gtk_widget_show(zoom_button);
	
  //////zoom_button (-)
  zoom_button = gtk_button_new_with_label("-");
	
  gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
  g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm");
  gtk_widget_show(zoom_button);
	
  //icon
  gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico"));
  
  //display window
  gtk_widget_show (window);
  gtk_main();
	
  //clean up
  free(colors);
  for(i = 0; i < BUFFER_COUNT; i++)
    free(mdata[i]);
  config_free(config);
	
  return 0;
}
Beispiel #25
0
static gboolean
avatar_image_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
	EmpathyAvatarImagePriv *priv;
	GtkWidget             *popup;
	GtkWidget             *frame;
	GtkWidget             *image;
	gint                   x, y;
	gint                   popup_width, popup_height;
	gint                   width, height;
	GdkPixbuf             *pixbuf;
	GtkAllocation          allocation;

	priv = GET_PRIV (widget);

	if (priv->popup) {
		gtk_widget_destroy (priv->popup);
		priv->popup = NULL;
	}

	if (event->button != 1 || event->type != GDK_BUTTON_PRESS || !priv->pixbuf) {
		return FALSE;
	}

	popup_width = gdk_pixbuf_get_width (priv->pixbuf);
	popup_height = gdk_pixbuf_get_height (priv->pixbuf);

	gtk_widget_get_allocation (priv->image, &allocation);
	width = allocation.width;
	height = allocation.height;

	/* Don't show a popup if the popup is smaller then the currently avatar
	 * image.
	 */
	if (popup_height <= height && popup_width <= width) {
		return TRUE;
	}

	pixbuf = tpaw_pixbuf_scale_down_if_necessary (priv->pixbuf, MAX_LARGE);
	popup_width = gdk_pixbuf_get_width (pixbuf);
	popup_height = gdk_pixbuf_get_height (pixbuf);

	popup = gtk_window_new (GTK_WINDOW_POPUP);

	frame = gtk_frame_new (NULL);
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);

	gtk_container_add (GTK_CONTAINER (popup), frame);

	image = gtk_image_new ();
	gtk_container_add (GTK_CONTAINER (frame), image);

	gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
	g_object_unref (pixbuf);

	gdk_window_get_origin (gtk_widget_get_window (priv->image), &x, &y);

	x = x - (popup_width - width) / 2;
	y = y - (popup_height - height) / 2;

	gtk_window_move (GTK_WINDOW (popup), x, y);

	priv->popup = popup;

	gtk_widget_show_all (popup);

	return TRUE;
}
Beispiel #26
0
void pidgin_log_show_contact(PurpleContact *contact) {
	struct log_viewer_hash_t *ht;
	PurpleBlistNode *child;
	PidginLogViewer *lv = NULL;
	GList *logs = NULL;
	GdkPixbuf *pixbuf;
	GtkWidget *image;
	const char *name = NULL;
	char *title;
	int total_log_size = 0;

	g_return_if_fail(contact != NULL);

	ht = g_new0(struct log_viewer_hash_t, 1);
	ht->type = PURPLE_LOG_IM;
	ht->contact = contact;

	if (log_viewers == NULL) {
		log_viewers = g_hash_table_new(log_viewer_hash, log_viewer_equal);
	} else if ((lv = g_hash_table_lookup(log_viewers, ht))) {
		gtk_window_present(GTK_WINDOW(lv->window));
		g_free(ht);
		return;
	}

	for (child = contact->node.child ; child ; child = child->next) {
		if (!PURPLE_BLIST_NODE_IS_BUDDY(child))
			continue;

		logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name,
						((PurpleBuddy *)child)->account), logs);
		total_log_size += purple_log_get_total_size(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name, ((PurpleBuddy *)child)->account);
	}
	logs = g_list_sort(logs, purple_log_compare);

	image = gtk_image_new();
	pixbuf = gtk_widget_render_icon(image, PIDGIN_STOCK_STATUS_PERSON,
					gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow");
	if (pixbuf) {
		gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
		g_object_unref(pixbuf);
	} else {
		gtk_widget_destroy(image);
		image = NULL;
	}

	if (contact->alias != NULL)
		name = contact->alias;
	else if (contact->priority != NULL)
		name = purple_buddy_get_contact_alias(contact->priority);

	/* This will happen if the contact doesn't have an alias,
	 * and none of the contact's buddies are online.
	 * There is probably a better way to deal with this. */
	if (name == NULL) {
		if (contact->node.child != NULL && PURPLE_BLIST_NODE_IS_BUDDY(contact->node.child))
			name = purple_buddy_get_contact_alias((PurpleBuddy *) contact->node.child);
		if (name == NULL)
			name = "";
	}

	title = g_strdup_printf(_("Conversations with %s"), name);
	display_log_viewer(ht, logs, title, image, total_log_size);
	g_free(title);
}
Beispiel #27
0
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
{
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);

    GSList* radioGroup;
    switch ( tool->GetStyle() )
    {
        case wxTOOL_STYLE_BUTTON:
            switch (tool->GetKind())
            {
                case wxITEM_CHECK:
                    tool->m_item = gtk_toggle_tool_button_new();
                    g_signal_connect(tool->m_item, "toggled",
                        G_CALLBACK(item_toggled), tool);
                    break;
                case wxITEM_RADIO:
                    radioGroup = GetRadioGroup(pos);
                    if (radioGroup)
                    {
                        // this is the first button in the radio button group,
                        // it will be toggled automatically by GTK so bring the
                        // internal flag in sync
                        tool->Toggle(true);
                    }
                    tool->m_item = gtk_radio_tool_button_new(radioGroup);
                    g_signal_connect(tool->m_item, "toggled",
                        G_CALLBACK(item_toggled), tool);
                    break;
                default:
                    wxFAIL_MSG("unknown toolbar child type");
                    // fall through
                case wxITEM_DROPDOWN:
                case wxITEM_NORMAL:
                    tool->m_item = gtk_tool_button_new(NULL, "");
                    g_signal_connect(tool->m_item, "clicked",
                        G_CALLBACK(item_clicked), tool);
                    break;
            }
            if (!HasFlag(wxTB_NOICONS))
            {
                GtkWidget* image = gtk_image_new();
                gtk_tool_button_set_icon_widget(
                    GTK_TOOL_BUTTON(tool->m_item), image);
                tool->SetImage();
                gtk_widget_show(image);
                g_signal_connect(image, "expose_event",
                    G_CALLBACK(image_expose_event), tool);
            }
            if (!tool->GetLabel().empty())
            {
                gtk_tool_button_set_label(
                    GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel()));
                // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT
                gtk_tool_item_set_is_important(tool->m_item, true);
            }
            if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())
            {
#if GTK_CHECK_VERSION(2, 12, 0)
                if (!gtk_check_version(2, 12, 0))
                {
                    gtk_tool_item_set_tooltip_text(tool->m_item,
                        wxGTK_CONV(tool->GetShortHelp()));
                }
                else
#endif
                {
                    gtk_tool_item_set_tooltip(tool->m_item,
                        m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
                }
            }
            g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event",
                G_CALLBACK(button_press_event), tool);
            g_signal_connect(tool->m_item, "enter_notify_event",
                G_CALLBACK(enter_notify_event), tool);
            g_signal_connect(tool->m_item, "leave_notify_event",
                G_CALLBACK(enter_notify_event), tool);

            if (tool->GetKind() == wxITEM_DROPDOWN)
                tool->CreateDropDown();
            gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
            break;

        case wxTOOL_STYLE_SEPARATOR:
            tool->m_item = gtk_separator_tool_item_new();
            if ( tool->IsStretchable() )
            {
                gtk_separator_tool_item_set_draw
                (
                    GTK_SEPARATOR_TOOL_ITEM(tool->m_item),
                    FALSE
                );
                gtk_tool_item_set_expand(tool->m_item, TRUE);
            }
            gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
            break;

        case wxTOOL_STYLE_CONTROL:
            wxWindow* control = tool->GetControl();
            if (control->m_widget->parent == NULL)
                AddChildGTK(control);
            tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent);
            if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))
            {
                g_object_ref(tool->m_item);
                gtk_container_remove(
                    GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item));
                gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
                g_object_unref(tool->m_item);
            }
            // Inserted items "slide" into place using an animated effect that
            // causes multiple size events on the item. Must set size request
            // to keep item size from getting permanently set too small by the
            // first of these size events.
            const wxSize size = control->GetSize();
            gtk_widget_set_size_request(control->m_widget, size.x, size.y);
            break;
    }
    gtk_widget_show(GTK_WIDGET(tool->m_item));

    InvalidateBestSize();

    return true;
}
Beispiel #28
0
void makeGUI()
{	
	GtkWidget *seperator;
	GtkWidget* vertbox;
	/**
	* Create the window and the main containter for all the widgets (topbox)
	**/
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width(GTK_CONTAINER(window), 5);
	topbox = gtk_vbox_new(FALSE, 0);
	
	
	
	
		
	/*
	* Build the left side of the panel first
	*/
	
	image = gtk_image_new();
	gtk_widget_set_size_request(image, 320, 240);
	horbox = gtk_hbox_new(FALSE, 0);
	
	gtk_box_pack_start(GTK_BOX(topbox), horbox, TRUE, TRUE, 0);
	
	
	vertbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(horbox), vertbox, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vertbox), image, TRUE, FALSE, 0);
	gtk_widget_show(vertbox);
	gtk_widget_show(image);	
	if (options)
	{
		GtkWidget* frame;
		frame = gtk_frame_new("Wallpaper Settings");		
		optionBox = gtk_combo_box_new_text ();  	
		gtk_combo_box_append_text (GTK_COMBO_BOX (optionBox), "Scale To Fit");
		gtk_combo_box_append_text (GTK_COMBO_BOX (optionBox), "Center");
		gtk_combo_box_append_text (GTK_COMBO_BOX (optionBox), "Tile");		
		gtk_combo_box_set_active (GTK_COMBO_BOX (optionBox), 0);	
		g_signal_connect (G_OBJECT (GTK_COMBO_BOX (optionBox)), "changed", G_CALLBACK (setOption), NULL);
		gtk_widget_show(optionBox);
		gtk_container_set_border_width (GTK_CONTAINER (frame), 2);
		gtk_container_add (GTK_CONTAINER (frame), optionBox);
		gtk_widget_show(frame);		
		gtk_box_pack_start(GTK_BOX(vertbox), frame, TRUE, TRUE, 0);
		seperator = gtk_hseparator_new();		
		gtk_widget_show(seperator);
	}
	
	/**
	* Seperate the two sides, just for fun
	**/
	seperator = gtk_vseparator_new();
	gtk_widget_show(seperator);
	gtk_box_pack_start(GTK_BOX(horbox), seperator, TRUE, TRUE, 2);	
	
	/**
	* Now make the right side of the panel.
	* This is where the list of wallpapers go (selectbox)
	* It is embed in a scrollable area, so the window isn't 
	* twenty meters long
	**/	
	scrollable = gtk_scrolled_window_new (NULL, NULL);
	createTreeList();
	
	
	gtk_widget_set_size_request(scrollable, 250, 240);
	gtk_container_add(GTK_CONTAINER(scrollable), selectBox);
	
	
	
	
	
	gtk_box_pack_start(GTK_BOX(horbox), scrollable, TRUE, TRUE, 0);	
	gtk_widget_show(selectBox);
	gtk_widget_show(scrollable);
	gtk_widget_show(horbox);
	/*
	* Foo!
	*/
	horbox = gtk_hbox_new(TRUE, 0);
	

	
	
	seperator = gtk_hseparator_new();
	gtk_box_pack_start(GTK_BOX(topbox), seperator, TRUE, TRUE, 2);
	gtk_widget_show(seperator);
	
	
	
	
	
	gtk_box_pack_start(GTK_BOX(topbox), horbox, FALSE, TRUE, 2);
	
	button = gtk_button_new_from_stock("gtk-apply");
	gtk_box_pack_start(GTK_BOX(horbox), button, FALSE, TRUE, 10);
	
	
	gtk_widget_show(button);
	gtk_widget_show(horbox);
	
	

	
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(delete_event), NULL);
	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(setWallpaper), "2");
	button =  gtk_button_new_from_stock("gtk-cancel");   
	gtk_box_pack_end(GTK_BOX(horbox), button, FALSE, TRUE, 10);
	gtk_widget_show(button);
	g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), G_OBJECT (window));
	
	gtk_container_add(GTK_CONTAINER(window), topbox);
	
	

	gtk_widget_show(topbox);
	 gtk_window_set_title (GTK_WINDOW (window), "CWallpaper Setter");
	gtk_widget_show(window);
	gtk_widget_grab_focus(GTK_WIDGET(selectBox));
	buildList();
	
	return;
}
Beispiel #29
0
/**
 * Cette fonction est la boucle principale du programme.
 * Elle permet de rassembler toutes les autres fonctions dans un contenu reflétant
 * le fonctionnement du programme. Pour comprendre le fonctionnement d'un programme,
 * lire le main() devrait suffire.
 * Dans notre cas en revanche ce n'est pas tout à fait exact, car gtk implique
 * une execution évènementielle, c'est à dire une éxécution basée sur les
 * évènements. Le programme ne se lit donc plus du haut vers le bas, mais en
 * fonction des évènements liés à des fonctions dites de callback, dans le fichier
 * libGUI.c.
 */
int main(int argc, char ** argv)
{

    // Commençons par charger les préférences, si elles existent. On ouvre le fichier
    // en lecture pour charger la structure préférences :
    fichierPreferences = fopen(".olonoPrefs", "rb");
    if (fichierPreferences == NULL)
        erreur("Pas de fichier de préférences trouvé\n");
    else
    {
        // On lit 1 élément de donnée de longueur preferences depuis le fichier
        // fPreferences pour le stocker dans la variable prefs (de type preferences)
        fread(&prefs,sizeof(preferences),1,fichierPreferences);

        /// INIT 2 : Préférences globales (from file)
        couleurDepart = prefs.couleurDepart;
        allowIA       = prefs.allowIA;
        couleurIA     = prefs.couleurIA;
        affJouable    = prefs.affJouable;
        taillePlateau = prefs.taillePlateau;

        if (args.verbose)
            ecrire("Chargement de :\n\t couleurDepart: %d, allowIA      : %d\n\t couleurIA    : %d, taillePlateau: %d",couleurDepart,allowIA,couleurIA,taillePlateau);
    }



    /* On initialise les arguments à leur valeur par défaut */
    args.taillePlateau = 0;
    args.verbose       = 0;
    args.Tore          = 0;

    /* This is where the magic should happen | Attention, instant magique ... */
    argp_parse (&argp, argc, argv, 0, 0, &args);

    /// INIT 3 : Préférences globales (from)
    if (args.taillePlateau != 0)
        if (atoi((char*) args.taillePlateau) <= 25 && atoi((char*) args.taillePlateau) >= 4)
            taillePlateau = atoi((char*) args.taillePlateau);


    /// Les 3 priorités d'initialisation étant terminées, on peut désormais
    //  assigner la couleur de départ du jeton :
    jeton = couleurDepart;


/// ######################################################################## ///
/// ### On commence les choses sérieuses ici (cad le main) ################# ///
/// ######################################################################## ///

    gint    i=0,j=0,n=0;
    CASE    caseActuelle[625];

    wOlono = g_malloc(sizeof(window));

    plateau = createPlateau();
    initPlateau(plateau);
    tronc = initHistorique(plateau,couleurDepart);


/// ######################################################################## ///
/// ### On fait chauffer l'Interface Graphique ############################# ///
/// ######################################################################## ///
    GladeXML    *xml;

    /* Initialisation de la lib GTK+ */
    gtk_init(&argc, &argv);

    /* load the interface and complete it with the variable pieces */
    xml = glade_xml_new(DATADIR "/" GLADEDIR "/" GLADEFILE, NULL, NULL);

    /* connect the signals in the interface */
    glade_xml_signal_autoconnect(xml);

    /*    // timer up*/
    /*    wOlono->pIAClock = g_timer_new();*/
    /*    g_timer_start(wOlono->pIAClock);*/

    // get the main Window
    wOlono->pWindow     = glade_xml_get_widget(xml, "olonoWindow");
    gtk_window_set_title(GTK_WINDOW (wOlono->pWindow), "OloNO v" VERSION);

    // get checkBoxes, and set their values
    wOlono->pCheckAllowIA = glade_xml_get_widget(xml, "allowIA");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckAllowIA),allowIA);
    wOlono->pCheckiaIsBlack = glade_xml_get_widget(xml, "iaIsBlack");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckiaIsBlack),couleurIA);
    wOlono->pCheckAffJouable = glade_xml_get_widget(xml, "showPossibleMoves");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckAffJouable),affJouable);
    wOlono->pCheckCouleurDeb = glade_xml_get_widget(xml, "whiteStart");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckCouleurDeb),!couleurDepart);

    // also get the spin button and set the default value :
    wOlono->pSpinTT = glade_xml_get_widget(xml, "taillePlateau");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON (wOlono->pSpinTT),taillePlateau);

    // why not speak to the prefs window too ?
    wOlono->pPrefWindow = glade_xml_get_widget(xml, "olonoPreferences");

    // get the status bar :
    wOlono->pStatusBar  = glade_xml_get_widget(xml, "barreDesTaches");

    // creating context ids :
    wOlono->contextId01 = gtk_statusbar_get_context_id(GTK_STATUSBAR(wOlono->pStatusBar),
                          "MsgTour");
    wOlono->contextId02 = gtk_statusbar_get_context_id(GTK_STATUSBAR(wOlono->pStatusBar),
                          "MsgScore");

    // creating first blank message for contextId01 :
    gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar),
                        GPOINTER_TO_INT(wOlono->contextId01),"Bienvenue - Youkoso");

    // On s'occupe de charger les images en mémoire :
    wOlono->imgVide     = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGVIDE,&wOlono->gerror);
    wOlono->imgBlanche  = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGBLANCHE,&wOlono->gerror);
    wOlono->imgNoire    = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGNOIRE,&wOlono->gerror);
    wOlono->imgJoker    = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGJOKER,&wOlono->gerror);

    // Puis on créé les dérivées transparentes :
    wOlono->imgTransBlanche = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGTBLANCHE,&wOlono->gerror);
    wOlono->imgTransNoire   = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGTNOIRE,&wOlono->gerror);


    // set the plateau.
    wOlono->pPlateau    = gtk_table_new(taillePlateau,taillePlateau,TRUE);

    for (i=0;i<taillePlateau;i++)
    {
        for (j=0;j<taillePlateau;j++)
        {
            n=i*taillePlateau+j;
            wOlono->pImage[n] = gtk_image_new();
            wOlono->pEvent[n] = gtk_event_box_new ();
            gtk_container_add (GTK_CONTAINER (wOlono->pEvent[n]), wOlono->pImage[n]);

            // Important : On place le gtk_event_box au dessus sinon on peut pas
            // recevoir des évènements, puisqu'il est caché par l'image.
            gtk_event_box_set_above_child (GTK_EVENT_BOX (wOlono->pEvent[n]),1);

            // On rempli caseActuelle :
            caseActuelle[n].x = i;
            caseActuelle[n].y = j;

            // On connecte chaque signal à la fonction callback :
            g_signal_connect (G_OBJECT (wOlono->pEvent[n]),
                              "button_press_event",
                              G_CALLBACK (on_case_clic),
                              &caseActuelle[n]);

            gtk_table_attach_defaults (GTK_TABLE (wOlono->pPlateau),
                                       wOlono->pEvent[n], i, i+1, j, j+1);
        }
    }

    /* Rafraichit le plateau (fait concorder celui en mémoire et celui affiché) */
    refreshBoard(plateau);

    wOlono->pContainer = glade_xml_get_widget(xml, "cadreAspect");
    gtk_container_add(GTK_CONTAINER(wOlono->pContainer), wOlono->pPlateau);

    /* For all the abandonned widgets ie plateau */
    gtk_widget_show_all (wOlono->pPlateau);

    /* start the event loop */
    gtk_main();

    return 0;
}
Beispiel #30
0
void wxAnyButton::DoSetBitmap(const wxBitmap& bitmap, State which)
{
    switch ( which )
    {
        case State_Normal:
            if ( DontShowLabel() )
            {
                // we only have the bitmap in this button, never remove it but
                // do invalidate the best size when the bitmap (and presumably
                // its size) changes
                InvalidateBestSize();
            }
            // normal image is special: setting it enables images for the button and
            // resetting it to nothing disables all of them
            else
            {
                GtkWidget *image = gtk_button_get_image(GTK_BUTTON(m_widget));
                if ( image && !bitmap.IsOk() )
                {
                    gtk_container_remove(GTK_CONTAINER(m_widget), image);
                }
                else if ( !image && bitmap.IsOk() )
                {
                    image = gtk_image_new();
                    gtk_button_set_image(GTK_BUTTON(m_widget), image);
                }
                else // image presence or absence didn't change
                {
                    // don't invalidate best size below
                    break;
                }

                InvalidateBestSize();
            }
            break;

        case State_Pressed:
            if ( bitmap.IsOk() )
            {
                if ( !m_bitmaps[which].IsOk() )
                {
                    // we need to install the callbacks to be notified about
                    // the button pressed state change
                    g_signal_connect
                    (
                        m_widget,
                        "pressed",
                        G_CALLBACK(wxgtk_button_press_callback),
                        this
                    );

                    g_signal_connect
                    (
                        m_widget,
                        "released",
                        G_CALLBACK(wxgtk_button_released_callback),
                        this
                    );
                }
            }
            else // no valid bitmap
            {
                if ( m_bitmaps[which].IsOk() )
                {
                    // we don't need to be notified about the button pressed
                    // state changes any more
                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_press_callback,
                        this
                    );

                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_released_callback,
                        this
                    );

                    // also make sure we don't remain stuck in pressed state
                    if ( m_isPressed )
                    {
                        m_isPressed = false;
                        GTKUpdateBitmap();
                    }
                }
            }
            break;

        case State_Current:
            // the logic here is the same as above for State_Pressed: we need
            // to connect the handlers if we must be notified about the changes
            // in the button current state and we disconnect them when/if we
            // don't need them any more
            if ( bitmap.IsOk() )
            {
                if ( !m_bitmaps[which].IsOk() )
                {
                    g_signal_connect
                    (
                        m_widget,
                        "enter",
                        G_CALLBACK(wxgtk_button_enter_callback),
                        this
                    );

                    g_signal_connect
                    (
                        m_widget,
                        "leave",
                        G_CALLBACK(wxgtk_button_leave_callback),
                        this
                    );
                }
            }
            else // no valid bitmap
            {
                if ( m_bitmaps[which].IsOk() )
                {
                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_enter_callback,
                        this
                    );

                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_leave_callback,
                        this
                    );

                    if ( m_isCurrent )
                    {
                        m_isCurrent = false;
                        GTKUpdateBitmap();
                    }
                }
            }
            break;

        case State_Focused:
            if ( bitmap.IsOk() )
            {
                Connect(wxEVT_SET_FOCUS,
                        wxFocusEventHandler(wxAnyButton::GTKOnFocus));
                Connect(wxEVT_KILL_FOCUS,
                        wxFocusEventHandler(wxAnyButton::GTKOnFocus));
            }
            else // no valid focused bitmap
            {
                Disconnect(wxEVT_SET_FOCUS,
                           wxFocusEventHandler(wxAnyButton::GTKOnFocus));
                Disconnect(wxEVT_KILL_FOCUS,
                           wxFocusEventHandler(wxAnyButton::GTKOnFocus));
            }
            break;

        default:
            // no callbacks to connect/disconnect
            ;
    }

    m_bitmaps[which] = bitmap;

    // update the bitmap immediately if necessary, otherwise it will be done
    // when the bitmap for the corresponding state is needed the next time by
    // GTKUpdateBitmap()
    if ( bitmap.IsOk() && which == GTKGetCurrentState() )
    {
        GTKDoShowBitmap(bitmap);
    }
}