コード例 #1
0
ファイル: text-edit.c プロジェクト: benjohnson2001/base
void
sp_text_edit_dialog (void)
{
	if (!dlg) {
		GtkWidget *mainvb, *nb, *vb, *hb, *txt, *fontsel, *preview, *f, *tbl, *l, *px, *c, *b, *hs;
		GtkTextBuffer *tb;
		GList *sl;
		int i;

		gchar title[500];
		sp_ui_dialog_title_string (SP_VERB_DIALOG_TEXT, title);

		dlg = sp_window_new (title, TRUE);
		if (x == -1000 || y == -1000) {
			x = prefs_get_int_attribute (prefs_path, "x", 0);
			y = prefs_get_int_attribute (prefs_path, "y", 0);
		}
		if (w ==0 || h == 0) {
			w = prefs_get_int_attribute (prefs_path, "w", 0);
			h = prefs_get_int_attribute (prefs_path, "h", 0);
		}
		if (x != 0 || y != 0) 
			gtk_window_move ((GtkWindow *) dlg, x, y);
		else
			gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
		if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
		sp_transientize (dlg);
		wd.win = dlg;
		wd.stop = 0;
		g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
		gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
		gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg);
		gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
		g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg);

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

		mainvb = gtk_vbox_new (FALSE, 0);
		gtk_container_add (GTK_CONTAINER (dlg), mainvb);

		nb = gtk_notebook_new ();
		gtk_container_set_border_width (GTK_CONTAINER (nb), 4);
		gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
		g_object_set_data (G_OBJECT (dlg), "notebook", nb);

		/* Vbox inside notebook */
		vb = gtk_vbox_new (FALSE, 0);

		/* Textview */
		f = gtk_frame_new (NULL);
		gtk_frame_set_shadow_type (GTK_FRAME (f), GTK_SHADOW_IN);
		tb = gtk_text_buffer_new (NULL);
		txt = gtk_text_view_new_with_buffer (tb);
		gtk_widget_set_size_request (txt, -1, 64);
		gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
		gtk_container_add (GTK_CONTAINER (f), txt);
		gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, 0);
		g_signal_connect (G_OBJECT (tb), "changed", G_CALLBACK (sp_text_edit_dialog_text_changed), dlg);
		g_object_set_data (G_OBJECT (dlg), "text", tb);
		g_object_set_data (G_OBJECT (dlg), "textw", txt);

		/* HBox containing font selection and layout */
		hb = gtk_hbox_new (FALSE, 0);
		gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);

		fontsel = sp_font_selector_new ();
		g_signal_connect (G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg);
		gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
		g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);

		/* Layout */
		f = gtk_frame_new (_("Layout"));
		gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);

		tbl = gtk_table_new (3, 4, FALSE);
		gtk_table_set_row_spacings (GTK_TABLE (tbl), 4);
		gtk_table_set_col_spacings (GTK_TABLE (tbl), 4);
		gtk_container_add (GTK_CONTAINER (f), tbl);

		l = gtk_label_new (_("Alignment:"));
		gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
		gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
		px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR);
		b = gtk_radio_button_new (NULL);
		g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
		gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
		gtk_container_add (GTK_CONTAINER (b), px);
		gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
		g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
		px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR);
		b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
		g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
		gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
		gtk_container_add (GTK_CONTAINER (b), px);
		gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
		g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
		px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR);
		b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
		g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
		gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
		gtk_container_add (GTK_CONTAINER (b), px);
		gtk_table_attach (GTK_TABLE (tbl), b, 3, 4, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
		g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);

		l = gtk_label_new (_("Orientation:"));
		gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
		gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
		px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_LR, GTK_ICON_SIZE_LARGE_TOOLBAR);
		b = gtk_radio_button_new (NULL);
		g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
		gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
		gtk_container_add (GTK_CONTAINER (b), px);
		gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
		g_object_set_data (G_OBJECT (dlg), "writing_mode_lr", b);
		px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_TB, GTK_ICON_SIZE_LARGE_TOOLBAR);
		b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
		g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
		gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
		gtk_container_add (GTK_CONTAINER (b), px);
		gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
		g_object_set_data (G_OBJECT (dlg), "writing_mode_tb", b);

		l = gtk_label_new (_("Line spacing:"));
		gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
		gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
		c = gtk_combo_new ();
		gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
		gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
		gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
		gtk_widget_set_size_request (c, 64, -1);
		/* Setup strings */
		sl = NULL;
		for (i = 0; spacings[i]; i++) {
			sl = g_list_prepend (sl, (void *) spacings[i]);
		}
		sl = g_list_reverse (sl);
		gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
		g_list_free (sl);
		g_signal_connect ((GObject *) ((GtkCombo *) c)->entry, "changed", (GCallback) sp_text_edit_dialog_line_spacing_changed, dlg);
		gtk_table_attach (GTK_TABLE (tbl), c, 1, 4, 2, 3, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
		g_object_set_data (G_OBJECT (dlg), "line_spacing", c);

		/* Font preview */
		preview = sp_font_preview_new ();
		gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
		g_object_set_data (G_OBJECT (dlg), "preview", preview);

		l = gtk_label_new (_("Text and font"));
		gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);

		/* Buttons */
		hs = gtk_hseparator_new ();
		gtk_box_pack_start (GTK_BOX (mainvb), hs, FALSE, FALSE, 0);

		hb = gtk_hbox_new (FALSE, 4);
		gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
		gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);

		b = gtk_button_new_with_label (_("Set as default"));
		g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_set_default), dlg);
		gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
		g_object_set_data (G_OBJECT (dlg), "default", b);

		b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
		g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_close), dlg);
		gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);

		b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
		g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_apply), dlg);
		gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
		g_object_set_data (G_OBJECT (dlg), "apply", b);

		g_signal_connect (G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_text_edit_dialog_modify_selection), dlg);
		g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_text_edit_dialog_change_selection), dlg);

		sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);

		gtk_widget_show_all (dlg);
	}

	gtk_window_present ((GtkWindow *) dlg);
}
コード例 #2
0
PpJobsDialog *
pp_jobs_dialog_new (GtkWindow            *parent,
                    UserResponseCallback  user_callback,
                    gpointer              user_data,
                    gchar                *printer_name)
{
  PpJobsDialog *dialog;
  GtkWidget    *widget;
  GError       *error = NULL;
  gchar        *objects[] = { "jobs-dialog", NULL };
  guint         builder_result;
  gchar        *title;

  dialog = g_new0 (PpJobsDialog, 1);

  dialog->builder = gtk_builder_new ();
  dialog->parent = GTK_WIDGET (parent);

  builder_result = gtk_builder_add_objects_from_file (dialog->builder,
                                                      DATADIR"/jobs-dialog.ui",
                                                      objects, &error);

  if (builder_result == 0)
    {
      g_warning ("Could not load ui: %s", error->message);
      g_error_free (error);
      return NULL;
    }

  dialog->dialog = (GtkWidget *) gtk_builder_get_object (dialog->builder, "jobs-dialog");
  dialog->user_callback = user_callback;
  dialog->user_data = user_data;
  dialog->printer_name = g_strdup (printer_name);
  dialog->current_job_id = -1;
  dialog->ref_count = 0;

  /* connect signals */
  g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
  g_signal_connect (dialog->dialog, "response", G_CALLBACK (jobs_dialog_response_cb), dialog);

  widget = (GtkWidget*)
    gtk_builder_get_object (dialog->builder, "content-alignment");
  g_signal_connect (widget, "size-allocate", G_CALLBACK (update_alignment_padding), dialog);

  widget = (GtkWidget*)
    gtk_builder_get_object (dialog->builder, "job-cancel-button");
  g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog);

  widget = (GtkWidget*)
    gtk_builder_get_object (dialog->builder, "job-hold-button");
  g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog);

  widget = (GtkWidget*)
    gtk_builder_get_object (dialog->builder, "job-release-button");
  g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog);

  widget = (GtkWidget*)
    gtk_builder_get_object (dialog->builder, "jobs-title");
  title = g_strdup_printf (_("%s Active Jobs"), printer_name);
  gtk_label_set_label (GTK_LABEL (widget), title);
  g_free (title);

  populate_jobs_list (dialog);

  gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent));
  gtk_window_present (GTK_WINDOW (dialog->dialog));
  gtk_widget_show_all (GTK_WIDGET (dialog->dialog));

  return dialog;
}
コード例 #3
0
void cairo_dock_show_desklet (CairoDesklet *pDesklet)
{
	if (pDesklet)
		gtk_window_present(GTK_WINDOW(pDesklet->pWidget));
}
コード例 #4
0
ファイル: conv.c プロジェクト: celiachen/hybrid
HybridChatWindow*
hybrid_chat_window_create(HybridAccount *account, const gchar *id,
                          HybridChatWindowType type)
{
    HybridChatWindow   *chat = NULL;
    HybridConversation *conv = NULL;
    HybridBuddy        *buddy;
    HybridModule       *proto;
    HybridIMOps        *ops;

    g_return_val_if_fail(account != NULL, NULL);
    g_return_val_if_fail(id != NULL, NULL);

    if (type == HYBRID_CHAT_PANEL_SYSTEM) {
        if (!(buddy = (hybrid_blist_find_buddy(account, id)))) {
            hybrid_debug_error("conv", "FATAL, can't find buddy");
            return NULL;
        }

        proto = account->proto;
        ops = proto->info->im_ops;

        /* we will check whether the protocol allows this buddy to be activated. */
        if (ops->chat_start) {
            if (!ops->chat_start(account, buddy)) {
                return NULL;
            }
        }
    }

    if ((chat = hybrid_conv_find_chat(id))) {
        conv = chat->parent;
        goto found;
    }

    /*
     * Whether to show the chat dialog in a single window.
     */
    if (hybrid_pref_get_boolean(NULL, "single_chat_window")) {

        if (!conv_list) {
            conv = hybrid_conv_create();
            conv_list = g_slist_append(conv_list, conv);

        } else {
            conv = conv_list->data;
        }

    } else {

        conv = hybrid_conv_create();
        conv_list = g_slist_append(conv_list, conv);
    }

    chat          = g_new0(HybridChatWindow, 1);
    chat->id      = g_strdup(id);
    chat->parent  = conv;
    chat->account = account;
    chat->type    = type;
    chat->logs    = hybrid_logs_create(account, id);

    if (type == HYBRID_CHAT_PANEL_SYSTEM) {
        chat->data = buddy;
    }

    conv->chat_buddies = g_slist_append(conv->chat_buddies, chat);

    init_chat_window(chat);
    return chat;

found:
    gtk_notebook_set_current_page(GTK_NOTEBOOK(conv->notebook),
        gtk_notebook_page_num(GTK_NOTEBOOK(conv->notebook), chat->vbox));

    /* focus the send textview */
    gtk_widget_grab_focus(chat->sendtext);
    gtk_window_present(GTK_WINDOW(chat->parent->window));

    return chat;
}
コード例 #5
0
/* Menu Callback : Configure preferences */
void menu_preferences_cb(GtkAction *action, StickyNotesApplet *applet)
{
	stickynotes_applet_update_prefs();
	gtk_window_set_screen(GTK_WINDOW(stickynotes->w_prefs), gtk_widget_get_screen(applet->w_applet));
	gtk_window_present(GTK_WINDOW(stickynotes->w_prefs));
}
コード例 #6
0
ファイル: window.cpp プロジェクト: xonotic/netradient
gboolean floating_window_delete_present( ui::Window floating, GdkEventFocus *event, ui::Window main_window ){
	if ( gtk_window_is_active( floating ) || gtk_window_is_active( main_window ) ) {
		gtk_window_present( main_window );
	}
	return FALSE;
}
コード例 #7
0
ファイル: view-commands.c プロジェクト: ellelstone/gimp
void
view_padding_color_cmd_callback (GtkAction *action,
                                 gint       value,
                                 gpointer   data)
{
  GimpDisplay        *display;
  GimpImageWindow    *window;
  GimpDisplayShell   *shell;
  GimpDisplayOptions *options;
  gboolean            fullscreen;
  return_if_no_display (display, data);

  shell  = gimp_display_get_shell (display);
  window = gimp_display_shell_get_window (shell);

  if (window)
    fullscreen = gimp_image_window_get_fullscreen (window);
  else
    fullscreen = FALSE;

  if (fullscreen)
    options = shell->fullscreen_options;
  else
    options = shell->options;

#define PADDING_COLOR_DIALOG_KEY "gimp-padding-color-dialog"

  switch ((GimpCanvasPaddingMode) value)
    {
    case GIMP_CANVAS_PADDING_MODE_DEFAULT:
    case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK:
    case GIMP_CANVAS_PADDING_MODE_DARK_CHECK:
      dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY);

      options->padding_mode_set = TRUE;

      gimp_display_shell_set_padding (shell, (GimpCanvasPaddingMode) value,
                                      &options->padding_color);
      break;

    case GIMP_CANVAS_PADDING_MODE_CUSTOM:
      {
        GtkWidget *dialog;

        dialog = dialogs_get_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY);

        if (! dialog)
          {
            GimpImage        *image = gimp_display_get_image (display);
            GimpDisplayShell *shell = gimp_display_get_shell (display);

            dialog =
              gimp_color_dialog_new (GIMP_VIEWABLE (image),
                                     action_data_get_context (data),
                                     _("Set Canvas Padding Color"),
                                     GIMP_ICON_FONT,
                                     _("Set Custom Canvas Padding Color"),
                                     GTK_WIDGET (shell),
                                     NULL, NULL,
                                     &options->padding_color,
                                     FALSE, FALSE);

            g_signal_connect (dialog, "update",
                              G_CALLBACK (view_padding_color_dialog_update),
                              shell);

            dialogs_attach_dialog (G_OBJECT (shell),
                                   PADDING_COLOR_DIALOG_KEY, dialog);
          }

        gtk_window_present (GTK_WINDOW (dialog));
      }
      break;

    case GIMP_CANVAS_PADDING_MODE_RESET:
      dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY);

      {
        GimpDisplayOptions *default_options;

        options->padding_mode_set = FALSE;

        if (fullscreen)
          default_options = display->config->default_fullscreen_view;
        else
          default_options = display->config->default_view;

        gimp_display_shell_set_padding (shell,
                                        default_options->padding_mode,
                                        &default_options->padding_color);
      }
      break;
    }
}
コード例 #8
0
void cd_do_change_current_icon (Icon *pIcon, CairoDock *pDock)
{
	//\_________________ on gere le cachage et le montrage du dock precedent et actuel.
	if (myData.pCurrentDock != NULL && pDock != myData.pCurrentDock && myData.pCurrentDock != g_pMainDock)  // on remet au repos dock precedemment anime.
	{
		cairo_dock_emit_leave_signal (myData.pCurrentDock);
	}
	if (pDock != NULL && pDock != g_pMainDock && pDock != myData.pCurrentDock)  // on montre le nouveau dock
	{
		if (pDock != NULL)
		{
			if (pDock->iRefCount > 0)
			{
				CairoDock *pParentDock = NULL;
				Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock);
				if (pPointingIcon != NULL)
				{
					cairo_dock_show_subdock (pPointingIcon, pParentDock, FALSE);  // utile pour le montrage des sous-docks au clic.
				}
			}
			else
			{
				cairo_dock_pop_up (pDock);
			}
			cairo_dock_emit_enter_signal (pDock);
		}
	}
	if (pDock != NULL)
	{
		
		gtk_window_present (GTK_WINDOW (pDock->pWidget));
	}
	
	//\_________________ on gere l'allumage et l'eteignage de l'icone precedente et actuelle.
	if (myData.pCurrentIcon != NULL && pIcon != myData.pCurrentIcon)  // on remet au repos l'icone precedemment anime.
	{
		myData.bIgnoreIconState = TRUE;
		cairo_dock_stop_icon_animation (myData.pCurrentIcon);
		myData.bIgnoreIconState = FALSE;
		cairo_dock_redraw_icon (myData.pCurrentIcon, CAIRO_CONTAINER (myData.pCurrentDock));  /// utile ?...
	}
	if (pIcon != NULL && myData.pCurrentIcon != pIcon)  // on anime la nouvelle icone.
	{
		int x = pIcon->fXAtRest + pIcon->fWidth/2 + (- pDock->fFlatDockWidth + pDock->iMaxDockWidth)/2;
		int y = pIcon->fDrawY + pIcon->fHeight/2 * pIcon->fScale;
		if (1||myData.pCurrentDock != pDock)
		{
			cairo_dock_emit_motion_signal (pDock,
				x,
				y);
		}
		else
		{
			myData.iPrevMouseX = myData.iMouseX;
			myData.iPrevMouseY = myData.iMouseY;
			myData.iMotionCount = 10;
		}
		myData.iMouseX = x;
		myData.iMouseY = y;
		cairo_dock_request_icon_animation (pIcon, pDock, myConfig.cIconAnimation, 1e6);  // interrompt l'animation de "mouse over".
		cairo_dock_launch_animation (CAIRO_CONTAINER (pDock));
		//if (myAccessibility.bShowSubDockOnClick)
		//	cairo_dock_show_subdock (pIcon, pDock, FALSE);
	}
	
	myData.pCurrentDock = pDock;
	myData.pCurrentIcon = pIcon;
	if (myData.pCurrentDock == NULL)
		gtk_window_present (GTK_WINDOW (g_pMainDock->pWidget));
}
コード例 #9
0
static void
cb_show_details (GtkWidget *button,
		 AppearanceData *data)
{
  if (!data->font_details) {
    GtkAdjustment *adjustment;
    GtkWidget *widget;
    EnumGroup *group;

    data->font_details = glade_xml_get_widget (data->xml, "render_details");

    gtk_window_set_transient_for (GTK_WINDOW (data->font_details),
				  GTK_WINDOW (glade_xml_get_widget (data->xml, "appearance_window")));

    widget = glade_xml_get_widget (data->xml, "dpi_spinner");

    /* pick a sensible maximum dpi */
    adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
    adjustment->upper = DPI_HIGH_REASONABLE_VALUE;

    dpi_load (data->client, GTK_SPIN_BUTTON (widget));
    g_signal_connect (widget, "value_changed",
		      G_CALLBACK (dpi_value_changed), data->client);

    gconf_client_notify_add (data->client, FONT_DPI_KEY,
			     dpi_changed, widget, NULL, NULL);

    setup_font_sample (glade_xml_get_widget (data->xml, "antialias_none_sample"),      ANTIALIAS_NONE,      HINT_FULL);
    setup_font_sample (glade_xml_get_widget (data->xml, "antialias_grayscale_sample"), ANTIALIAS_GRAYSCALE, HINT_FULL);
    setup_font_sample (glade_xml_get_widget (data->xml, "antialias_subpixel_sample"),  ANTIALIAS_RGBA,      HINT_FULL);

    group = enum_group_create (
    	FONT_ANTIALIASING_KEY, antialias_enums, ANTIALIAS_GRAYSCALE,
	glade_xml_get_widget (data->xml, "antialias_none_radio"),      ANTIALIAS_NONE,
	glade_xml_get_widget (data->xml, "antialias_grayscale_radio"), ANTIALIAS_GRAYSCALE,
	glade_xml_get_widget (data->xml, "antialias_subpixel_radio"),  ANTIALIAS_RGBA,
	NULL);
    data->font_groups = g_slist_prepend (data->font_groups, group);

    setup_font_sample (glade_xml_get_widget (data->xml, "hint_none_sample"),   ANTIALIAS_GRAYSCALE, HINT_NONE);
    setup_font_sample (glade_xml_get_widget (data->xml, "hint_slight_sample"), ANTIALIAS_GRAYSCALE, HINT_SLIGHT);
    setup_font_sample (glade_xml_get_widget (data->xml, "hint_medium_sample"), ANTIALIAS_GRAYSCALE, HINT_MEDIUM);
    setup_font_sample (glade_xml_get_widget (data->xml, "hint_full_sample"),   ANTIALIAS_GRAYSCALE, HINT_FULL);

    group = enum_group_create (
    	FONT_HINTING_KEY, hint_enums, HINT_FULL,
	glade_xml_get_widget (data->xml, "hint_none_radio"),   HINT_NONE,
	glade_xml_get_widget (data->xml, "hint_slight_radio"), HINT_SLIGHT,
	glade_xml_get_widget (data->xml, "hint_medium_radio"), HINT_MEDIUM,
	glade_xml_get_widget (data->xml, "hint_full_radio"),   HINT_FULL,
	NULL);
    data->font_groups = g_slist_prepend (data->font_groups, group);

    gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_rgb_image")),
			     GNOMECC_PIXMAP_DIR "/subpixel-rgb.png");
    gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_bgr_image")),
			     GNOMECC_PIXMAP_DIR "/subpixel-bgr.png");
    gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_vrgb_image")),
			     GNOMECC_PIXMAP_DIR "/subpixel-vrgb.png");
    gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_vbgr_image")),
			     GNOMECC_PIXMAP_DIR "/subpixel-vbgr.png");

    group = enum_group_create (
    	FONT_RGBA_ORDER_KEY, rgba_order_enums, RGBA_RGB,
	glade_xml_get_widget (data->xml, "subpixel_rgb_radio"),  RGBA_RGB,
	glade_xml_get_widget (data->xml, "subpixel_bgr_radio"),  RGBA_BGR,
	glade_xml_get_widget (data->xml, "subpixel_vrgb_radio"), RGBA_VRGB,
	glade_xml_get_widget (data->xml, "subpixel_vbgr_radio"), RGBA_VBGR,
	NULL);
    data->font_groups = g_slist_prepend (data->font_groups, group);

    g_signal_connect (G_OBJECT (data->font_details),
		      "response",
		      G_CALLBACK (cb_details_response), NULL);
    g_signal_connect (G_OBJECT (data->font_details),
		      "delete_event",
		      G_CALLBACK (gtk_true), NULL);
  }

  gtk_window_present (GTK_WINDOW (data->font_details));
}
コード例 #10
0
ファイル: PortableTrayIcon.cpp プロジェクト: ellysh/notecase
void on_tray_restore (GtkMenuItem *menuitem, gpointer user_data)
{
	gtk_widget_show(window1);
	gtk_window_present(GTK_WINDOW(window1));
	g_tray.Hide();
}
コード例 #11
0
ファイル: find-files.c プロジェクト: alfbar0/spacefm
static void on_open_files( GtkAction* action, FindFile* data )
{
    GtkTreeModel* model;
    GtkTreeSelection* sel;
    GtkTreeIter it;
    GList *row, *rows, *sel_files;
    GHashTable* hash;
    GtkWidget* w;
    VFSFileInfo* fi;
    gboolean open_files_has_dir = FALSE;  //sfm
    PtkFileBrowser* file_browser = NULL;  //sfm
    gboolean open_files = TRUE;
    
    if ( action )
        open_files = (0 == strcmp( gtk_action_get_name(action), "OpenAction") );

    sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( data->result_view ) );
    rows = gtk_tree_selection_get_selected_rows( sel, &model );
    if( ! rows )
        return;

    //sfm this frees list when new value inserted - caused segfault
    //hash = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, open_files ? (GDestroyNotify)vfs_file_info_list_free : NULL );
    hash = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, NULL );

    for( row = rows; row; row = row->next )
    {
        char* dir;
        GtkTreePath* tp = (GtkTreePath*)row->data;

        if( gtk_tree_model_get_iter( model, &it, tp ) )
        {
            if( open_files ) /* open files */
                gtk_tree_model_get( model, &it, COL_INFO, &fi, COL_DIR, &dir, -1 );
            else  /* open containing folders */
                gtk_tree_model_get( model, &it, COL_DIR, &dir, -1 );

            if( open_files )
            {
                GList *l;
                l = g_hash_table_lookup( hash, dir );
                l = g_list_prepend( l, vfs_file_info_ref(fi) );
                g_hash_table_insert( hash, dir, l );  //sfm caused segfault with destroy function
                if ( vfs_file_info_is_dir( fi ) )  //sfm
                    open_files_has_dir = TRUE;
            }
            else
            {
                if( g_hash_table_lookup( hash, dir ) )
                    g_free( dir );
                g_hash_table_insert( hash, dir, NULL );
            }
        }
        gtk_tree_path_free( tp );
    }
    g_list_free( rows );

    if( open_files )
    {
        if ( open_files_has_dir )
        {
            w = GTK_WIDGET( fm_main_window_get_last_active() );
            if( ! w )
            {
                w = fm_main_window_new();
                gtk_window_set_default_size( GTK_WINDOW( w ), app_settings.width, app_settings.height );
            }
            gtk_window_present( (GtkWindow*)w );
            file_browser = (PtkFileBrowser*)fm_main_window_get_current_file_browser(
                                                                (FMMainWindow*)w );
        }
        g_hash_table_foreach_steal( hash, (GHRFunc)open_file, file_browser );
    }
    else
    {
        w = GTK_WIDGET( fm_main_window_get_last_active() );
        if( ! w )
        {
            w = fm_main_window_new();
            gtk_window_set_default_size( GTK_WINDOW( w ), app_settings.width, app_settings.height );
        }

        g_hash_table_foreach( hash, (GHFunc)open_dir, w );
        gtk_window_present( (GtkWindow*)w );
    }

    g_hash_table_destroy( hash );
}
コード例 #12
0
void
terminal_encoding_dialog_show (GtkWindow *transient_parent)
{
	TerminalApp *app;
	GtkCellRenderer *cell_renderer;
	GtkTreeViewColumn *column;
	GtkTreeModel *model;
	EncodingDialogData *data;

	if (encoding_dialog)
	{
		gtk_window_set_transient_for (GTK_WINDOW (encoding_dialog), transient_parent);
		gtk_window_present (GTK_WINDOW (encoding_dialog));
		return;
	}

	data = g_new (EncodingDialogData, 1);

	if (!terminal_util_load_builder_file ("encodings-dialog.ui",
	                                      "encodings-dialog", &data->dialog,
	                                      "add-button", &data->add_button,
	                                      "remove-button", &data->remove_button,
	                                      "available-treeview", &data->available_tree_view,
	                                      "displayed-treeview", &data->active_tree_view,
	                                      NULL))
	{
		g_free (data);
		return;
	}

	g_object_set_data_full (G_OBJECT (data->dialog), "GT::Data", data, (GDestroyNotify) encoding_dialog_data_free);

	gtk_window_set_transient_for (GTK_WINDOW (data->dialog), transient_parent);
	gtk_window_set_role (GTK_WINDOW (data->dialog), "mate-terminal-encodings");
	g_signal_connect (data->dialog, "response",
	                  G_CALLBACK (response_callback), data);

	/* buttons */
	g_signal_connect (data->add_button, "clicked",
	                  G_CALLBACK (button_clicked_cb), data);

	g_signal_connect (data->remove_button, "clicked",
	                  G_CALLBACK (button_clicked_cb), data);

	/* Tree view of available encodings */
	/* Column 1 */
	cell_renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes (_("_Description"),
	         cell_renderer,
	         "text", COLUMN_NAME,
	         NULL);
	gtk_tree_view_append_column (data->available_tree_view, column);
	gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);

	/* Column 2 */
	cell_renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes (_("_Encoding"),
	         cell_renderer,
	         "text", COLUMN_CHARSET,
	         NULL);
	gtk_tree_view_append_column (data->available_tree_view, column);
	gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET);

	data->available_selection = gtk_tree_view_get_selection (data->available_tree_view);
	gtk_tree_selection_set_mode (data->available_selection, GTK_SELECTION_BROWSE);

	g_signal_connect (data->available_selection, "changed",
	                  G_CALLBACK (selection_changed_cb), data);

	/* Tree view of selected encodings */
	/* Column 1 */
	cell_renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes (_("_Description"),
	         cell_renderer,
	         "text", COLUMN_NAME,
	         NULL);
	gtk_tree_view_append_column (data->active_tree_view, column);
	gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);

	/* Column 2 */
	cell_renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes (_("_Encoding"),
	         cell_renderer,
	         "text", COLUMN_CHARSET,
	         NULL);
	gtk_tree_view_append_column (data->active_tree_view, column);
	gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET);

	/* Add the data */

	data->active_selection = gtk_tree_view_get_selection (data->active_tree_view);
	gtk_tree_selection_set_mode (data->active_selection, GTK_SELECTION_BROWSE);

	g_signal_connect (data->active_selection, "changed",
	                  G_CALLBACK (selection_changed_cb), data);

	data->base_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, TERMINAL_TYPE_ENCODING);

	app = terminal_app_get ();
	encodings_list_changed_cb (app, data);
	g_signal_connect (app, "encoding-list-changed",
	                  G_CALLBACK (encodings_list_changed_cb), data);

	/* Now turn on sorting */
	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->base_store),
	                                      COLUMN_NAME,
	                                      GTK_SORT_ASCENDING);

	model = encodings_create_treemodel (data->base_store, FALSE);
	gtk_tree_view_set_model (data->available_tree_view, model);
	g_object_unref (model);

	model = encodings_create_treemodel (data->base_store, TRUE);
	gtk_tree_view_set_model (data->active_tree_view, model);
	g_object_unref (model);

	g_object_unref (data->base_store);

	gtk_window_present (GTK_WINDOW (data->dialog));

	encoding_dialog = data->dialog;
	g_signal_connect (data->dialog, "destroy",
	                  G_CALLBACK (gtk_widget_destroyed), &encoding_dialog);
}
コード例 #13
0
ファイル: tagging.c プロジェクト: AdamMajer/darktable
static gboolean _lib_tagging_tag_show(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval,
                                      GdkModifierType modifier, dt_lib_module_t *self)
{
  int mouse_over_id = -1;
  int zoom = dt_conf_get_int("plugins/lighttable/images_in_row");

  // the order is:
  // if(zoom == 1) => currently shown image
  // else if(selection not empty) => selected images
  // else if(cursor over image) => hovered image
  // else => return
  if(zoom == 1 || dt_collection_get_selected_count(darktable.collection) == 0)
  {
    mouse_over_id = dt_control_get_mouse_over_id();
    if(mouse_over_id < 0) return TRUE;
  }

  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  d->floating_tag_imgid = mouse_over_id;

  gint x, y;
  gint px, py, w, h;
  GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
  GtkWidget *center = dt_ui_center(darktable.gui->ui);
  gdk_window_get_origin(gtk_widget_get_window(center), &px, &py);

  w = gdk_window_get_width(gtk_widget_get_window(center));
  h = gdk_window_get_height(gtk_widget_get_window(center));

  x = px + 0.5 * (w - FLOATING_ENTRY_WIDTH);
  y = py + h - 50;

  /* put the floating box at the mouse pointer */
  //   gint pointerx, pointery;
  //   GdkDevice *device =
  //   gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget)));
  //   gdk_window_get_device_position (gtk_widget_get_window (widget), device, &pointerx, &pointery, NULL);
  //   x = px + pointerx + 1;
  //   y = py + pointery + 1;

  d->floating_tag_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  /* stackoverflow.com/questions/1925568/how-to-give-keyboard-focus-to-a-pop-up-gtk-window */
  gtk_widget_set_can_focus(d->floating_tag_window, TRUE);
  gtk_window_set_decorated(GTK_WINDOW(d->floating_tag_window), FALSE);
  gtk_window_set_type_hint(GTK_WINDOW(d->floating_tag_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
  gtk_window_set_transient_for(GTK_WINDOW(d->floating_tag_window), GTK_WINDOW(window));
  gtk_widget_set_opacity(d->floating_tag_window, 0.8);
  gtk_window_move(GTK_WINDOW(d->floating_tag_window), x, y);


  GtkWidget *entry = gtk_entry_new();
  gtk_widget_set_size_request(entry, FLOATING_ENTRY_WIDTH, -1);
  gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK);

  GtkEntryCompletion *completion = gtk_entry_completion_new();
  gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related)));
  gtk_entry_completion_set_text_column(completion, 0);
  gtk_entry_completion_set_inline_completion(completion, TRUE);
  gtk_entry_completion_set_popup_set_width(completion, FALSE);
  gtk_entry_set_completion(GTK_ENTRY(entry), completion);

  gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
  gtk_container_add(GTK_CONTAINER(d->floating_tag_window), entry);
  g_signal_connect(entry, "focus-out-event", G_CALLBACK(_lib_tagging_tag_destroy), d->floating_tag_window);
  g_signal_connect(entry, "key-press-event", G_CALLBACK(_lib_tagging_tag_key_press), self);

  gtk_widget_show_all(d->floating_tag_window);
  gtk_widget_grab_focus(entry);
  gtk_window_present(GTK_WINDOW(d->floating_tag_window));

  return TRUE;
}
コード例 #14
0
void show_about_window(void)
{
	GtkWidget *vbox;
	GtkWidget *hbox;
	GtkWidget *label;
	GtkWidget *button;
	GdkPixbuf *pixbuf;

	gchar *buf;

	if (about)
		{
		gtk_window_present(GTK_WINDOW(about));
		return;
		}

	about = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_type_hint(GTK_WINDOW(about), GDK_WINDOW_TYPE_HINT_DIALOG);
	gtk_window_set_wmclass(GTK_WINDOW(about), "about", "GQview");
	g_signal_connect(G_OBJECT(about), "delete_event",
			 G_CALLBACK(about_delete_cb), NULL);

	gtk_window_set_title(GTK_WINDOW(about), _("About - GQview"));
	gtk_container_set_border_width(GTK_CONTAINER(about), PREF_PAD_BORDER);

	vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
	gtk_container_add(GTK_CONTAINER(about), vbox);
	gtk_widget_show(vbox);

	pixbuf = pixbuf_inline(PIXBUF_INLINE_LOGO);
	button = gtk_image_new_from_pixbuf(pixbuf);
	g_object_unref(pixbuf);
	gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0);
	gtk_widget_show(button);

	buf = g_strdup_printf(_("GQview %s\n\nCopyright (c) %s John Ellis\nwebsite: %s\nemail: %s\n\nReleased under the GNU General Public License"),
			      VERSION,
			      "2006",
			      "gqview.sourceforge.net",
			      "*****@*****.**");
	label = gtk_label_new(buf);
	g_free(buf);

	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
	gtk_widget_show(label);

	hbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
	gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
	gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
	gtk_widget_show(hbox);

	button = pref_button_new(NULL, NULL, _("Credits..."), FALSE,
				 G_CALLBACK(about_credits_cb), NULL);
	gtk_container_add(GTK_CONTAINER(hbox), button);
	GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
	gtk_widget_show(button);

	button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
				 G_CALLBACK(about_window_close), NULL);
	gtk_container_add(GTK_CONTAINER(hbox), button);
	GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
	gtk_widget_grab_default(button);
	gtk_widget_show(button);

	window_set_icon(about, NULL, NULL);
	gtk_widget_show(about);
}
コード例 #15
0
ファイル: toplevel.cpp プロジェクト: CobaltBlues/wxWidgets
void wxTopLevelWindowGTK::Restore()
{
    // "Present" seems similar enough to "restore"
    gtk_window_present( GTK_WINDOW( m_widget ) );
}
コード例 #16
0
void show_login()
{
	GtkWidget *image;
    GtkWidget *hbox_toplevel;
	GtkWidget *vbox;
	GtkWidget *button;
	GtkWidget *hbox;
	GtkWidget *label;
	GtkWidget *vbox2;
    GtkWidget *table;
#ifdef GAIM_SMALL_SCREEN    
#ifdef ENABLE_HILDON
    GtkWidget *hbox1;
    GtkWidget *vbox1;
#endif
    GtkWidget *hseparator;
#endif
	/* Do we already have a main window opened? If so, bring it back, baby... ribs... yeah */

#ifdef ENABLE_HILDON
    if (login_app_view) {
            hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view));
	    g_object_unref(login_app_view);
            return;
    }
    mainwindow = current_app_view = login_app_view = hildon_appview_new(_("Login"));
    hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view));
    
    hbox_toplevel = gtk_hbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(login_app_view), hbox_toplevel);
    g_signal_connect(G_OBJECT(login_app_view), "delete_event",
                     G_CALLBACK(login_window_closed), login_app_view);
                     
                 
#else
    if (mainwindow) {
            gtk_window_present(GTK_WINDOW(mainwindow));
            return;
    }
    #ifdef GAIM_SMALL_SCREEN
        mainwindow = gtk_dialog_new();
        gtk_window_set_modal(GTK_WINDOW(mainwindow), TRUE);
        gtk_dialog_set_has_separator(mainwindow, FALSE);
    #else
        mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    #endif
        gtk_window_set_role(GTK_WINDOW(mainwindow), "login");
        gtk_window_set_resizable(GTK_WINDOW(mainwindow), FALSE);
        gtk_window_set_title(GTK_WINDOW(mainwindow), _("Login"));
        gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
        g_signal_connect(G_OBJECT(mainwindow), "delete_event",
                        G_CALLBACK(login_window_closed), mainwindow);
        hbox_toplevel = gtk_hbox_new(FALSE, 0);
    #ifdef GAIM_SMALL_SCREEN
        gtk_container_add(GTK_CONTAINER(GTK_DIALOG(mainwindow)->vbox), hbox_toplevel);
    #else
        gtk_container_add(GTK_CONTAINER(mainwindow), hbox_toplevel);
    #endif
#endif

    

                     
    vbox_toplevel = vbox = gtk_vbox_new(FALSE, 0);

    gtk_box_pack_start(GTK_BOX(hbox_toplevel), vbox, FALSE, FALSE, BOX_SPACING);
#ifdef GAIM_SMALL_SCREEN	
    /* Now for the button box */
    hbox = gtk_hbox_new(FALSE, 0);
#ifdef ENABLE_HILDON
    hbox1 = gtk_hbox_new(FALSE, BOX_SPACING);
    vbox1 = gtk_vbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), hbox1, TRUE, FALSE, 0);
    gtk_box_pack_end(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0);
    vbox = vbox1;
#else
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
#endif    
    
    /* lets put the image also in the hbox */
    image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO));
#ifdef ENABLE_HILDON
    gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0);
#else
    gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
#endif
    
    /* And now for the buttons */
    button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL);
    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
    g_signal_connect(G_OBJECT(button), "clicked",
                     G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow);
    gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);

    button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL);
    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
    g_signal_connect(G_OBJECT(button), "clicked",
                     G_CALLBACK(gaim_gtk_prefs_show), mainwindow);
    gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);

    button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL);
    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
    g_signal_connect(G_OBJECT(button), "clicked",
                     G_CALLBACK(dologin), mainwindow);
    g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL);
    gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);

    hseparator = gtk_hseparator_new ();
    gtk_widget_show (hseparator);
    gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 2);
        
#else
    image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO));
    gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0);
#endif    
    
    table = gtk_table_new (2, 2, FALSE);
    gtk_widget_show (table);
    gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
    gtk_table_set_row_spacings (GTK_TABLE (table), 2);
    gtk_table_set_col_spacings (GTK_TABLE (table), 2);
    
	/* why isn't there a gtk_label_new_with_markup? */
	label = gtk_label_new(NULL);
	gtk_widget_show (label);
    gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Account:</b>"));
	gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
                        (GtkAttachOptions) (GTK_FILL),
                        (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
    
    
	name = gaim_gtk_account_option_menu_new(NULL, TRUE, G_CALLBACK(combo_changed), NULL, NULL);
	gtk_label_set_mnemonic_widget(GTK_LABEL(label), name);
    gtk_widget_show (name);
    gtk_table_attach (GTK_TABLE (table), name, 1, 2, 0, 1,
                        (GtkAttachOptions) (GTK_FILL),
                        (GtkAttachOptions) (0), 0, 0);

    
	label = gtk_label_new(NULL);
    gtk_widget_show (label);
	gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Password:</b>"));
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
                        (GtkAttachOptions) (GTK_FILL),
                        (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);

	pass = gtk_entry_new();
	gtk_label_set_mnemonic_widget(GTK_LABEL(label), pass);
	gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE);
    gtk_table_attach (GTK_TABLE (table), pass, 1, 2, 1, 2,
                (GtkAttachOptions) (GTK_FILL),
                (GtkAttachOptions) (0), 0, 0);
    
    
#ifndef GAIM_SMALL_SCREEN
    g_signal_connect(G_OBJECT(pass), "activate",
                     G_CALLBACK(dologin), mainwindow);
    /*
    gtk_box_pack_start(GTK_BOX(vbox2), pass, FALSE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0);
    */
    /* Now for the button box */
    hbox = gtk_hbox_new(TRUE, 0);
    /*
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
    */
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);

    /* And now for the buttons */
    button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL);
    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
    g_signal_connect(G_OBJECT(button), "clicked",
                     G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);

    button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL);
    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
    g_signal_connect(G_OBJECT(button), "clicked",
                     G_CALLBACK(gaim_gtk_prefs_show), mainwindow);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);

    button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL);
    gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
    g_signal_connect(G_OBJECT(button), "clicked",
                     G_CALLBACK(dologin), mainwindow);
    g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
#endif
	/* Now grab the focus that we need */
	if (gaim_accounts_get_all()) {
		GaimAccount *account = gaim_accounts_get_all()->data;

		if (gaim_account_get_remember_password(account)) {
			combo_changed(NULL, account, NULL);
			gtk_widget_grab_focus(button);
		} else {
			gtk_widget_grab_focus(pass);
		}
	} else {
		gaim_gtk_accounts_window_show();
		gtk_widget_grab_focus(button);
	}
    
#ifndef ENABLE_HILDON
	/* And raise the curtain! */
	gtk_widget_show_all(mainwindow);
#else
    gtk_widget_show_all(login_app_view);
#endif
}
コード例 #17
0
ファイル: toplevel.cpp プロジェクト: CobaltBlues/wxWidgets
void wxTopLevelWindowGTK::Raise()
{
    gtk_window_present( GTK_WINDOW( m_widget ) );
}
コード例 #18
0
ファイル: wb_wpkg_gtk.cpp プロジェクト: jordibrus/proview
void WPkgGtk::pop()
{
  gtk_window_present( GTK_WINDOW(toplevel));
}
コード例 #19
0
ファイル: window.cpp プロジェクト: xonotic/netradient
gboolean floating_window_destroy_present( ui::Window floating, ui::Window main_window ){
	if ( gtk_window_is_active( floating ) || gtk_window_is_active( main_window ) ) {
		gtk_window_present( main_window );
	}
	return FALSE;
}
コード例 #20
0
ファイル: setup.c プロジェクト: gfunkmonk2/mate-games
gint
setup_game (GtkAction * action, gpointer data)
{
  GtkWidget *box, *box2, *label, *button, *frame;
  GtkWidget *table;
  GtkWidget *combo;
  gchar *ts;
  int i;

  if (setupdialog) {
    gtk_window_present (GTK_WINDOW (setupdialog));
    return FALSE;
  }

  setupdialog = gtk_dialog_new_with_buttons (_("Tali Preferences"),
					     GTK_WINDOW (window),
					     GTK_DIALOG_DESTROY_WITH_PARENT,
					     GTK_STOCK_CLOSE,
					     GTK_RESPONSE_CLOSE, NULL);
  gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), 2);
  gtk_window_set_resizable (GTK_WINDOW (setupdialog), FALSE);
  gtk_dialog_set_has_separator (GTK_DIALOG (setupdialog), FALSE);
  g_signal_connect (G_OBJECT (setupdialog), "delete_event",
		    G_CALLBACK (setupdialog_destroy), NULL);
  button = gtk_button_new_from_stock (GTK_STOCK_OK);
  g_signal_connect (G_OBJECT (setupdialog), "response",
		    G_CALLBACK (do_setup), NULL);

  table = gtk_table_new (3, 2, FALSE);
  gtk_container_set_border_width (GTK_CONTAINER (table), 5);
  gtk_table_set_row_spacings (GTK_TABLE (table), 18);
  gtk_table_set_col_spacings (GTK_TABLE (table), 18);

  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), 
                      table, FALSE, FALSE, 0);

  frame = games_frame_new (_("Human Players"));
  gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, GTK_FILL, GTK_FILL,
		    0, 0);

  box = gtk_vbox_new (FALSE, 6);
  gtk_container_add (GTK_CONTAINER (frame), box);

	/*--- Spinner (number of humans) ---*/
  OriginalNumberOfHumans = NumberOfHumans;
  box2 = gtk_hbox_new (FALSE, 12);
  gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0);
  label = gtk_label_new_with_mnemonic (_("_Number of players:"));

  gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
  HumanAdj = gtk_adjustment_new ((gfloat) NumberOfHumans, 1.0,
				 6.0, 1.0, 6.0, 0.0);
  HumanSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (HumanAdj), 10, 0);
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), HumanSpinner);

  g_signal_connect (G_OBJECT (HumanAdj), "value_changed",
		    G_CALLBACK (MaxPlayersCheck), HumanAdj);

  gtk_box_pack_start (GTK_BOX (box2), HumanSpinner, TRUE, TRUE, 0);


  frame = games_frame_new (_("Computer Opponents"));
  gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 1, 2, GTK_FILL,
		    GTK_FILL | GTK_EXPAND, 0, 0);

  box = gtk_vbox_new (FALSE, 6);
  gtk_container_add (GTK_CONTAINER (frame), box);

	/*--- Button ---*/
  button = gtk_check_button_new_with_mnemonic (_("_Delay between rolls"));
  gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), DoDelay);
  g_signal_connect (G_OBJECT (button), "clicked",
		    G_CALLBACK (set_as_int), &tmpDoDelay);

	/*--- Spinner (number of computers) ---*/
  OriginalNumberOfComputers = NumberOfComputers;
  box2 = gtk_hbox_new (FALSE, 12);
  gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0);
  label = gtk_label_new_with_mnemonic (_("N_umber of opponents:"));
  gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);

  ComputerAdj = gtk_adjustment_new ((gfloat) NumberOfComputers,
				    0.0, 5.0, 1.0, 5.0, 0.0);
  ComputerSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (ComputerAdj), 10, 0);
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), ComputerSpinner);

  g_signal_connect (G_OBJECT (ComputerAdj), "value_changed",
		    G_CALLBACK (MaxPlayersCheck), ComputerAdj);
  gtk_box_pack_start (GTK_BOX (box2), ComputerSpinner, TRUE, TRUE, 0);

  box2 = gtk_hbox_new(FALSE, 2);
  gtk_box_pack_start(GTK_BOX(box), box2, FALSE, FALSE, 0);
  label = gtk_label_new_with_mnemonic (_("_Difficulty:"));
  gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0);
  combo = gtk_combo_box_new_text();
  gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("difficulty", "Easy"));
  gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("difficulty", "Medium"));
  gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("difficulty", "Hard"));
  skill_level = 0;
  while (NUM_TRIALS > skill_level_table[skill_level].trials &&
         skill_level < (SKILL_LEVEL_TABLE_SIZE - 1)) skill_level++;
  gtk_combo_box_set_active(GTK_COMBO_BOX(combo), skill_level);
  g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetSkillLevel),
                    combo);
  gtk_box_pack_start(GTK_BOX(box2), combo, FALSE, FALSE, 0);

    /*--- Combo (yahtzee or kismet style ----*/

  frame = games_frame_new (_("Game Type"));
  gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 2, 3, GTK_FILL,
                    GTK_FILL | GTK_EXPAND, 0, 0);
  combo = gtk_combo_box_new_text();
  gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("game type", "Regular"));
  gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("game type", "Colors"));
  gtk_combo_box_set_active(GTK_COMBO_BOX(combo), game_type);
  NewGameType = game_type;
  g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetGameType),
                    combo);
  gtk_container_add (GTK_CONTAINER (frame), combo);

	/*--- PLAYER NAMES FRAME ----*/
  frame = games_frame_new (_("Player Names"));
  gtk_table_attach_defaults (GTK_TABLE (table), frame, 1, 2, 0, 3);

  box = gtk_vbox_new (FALSE, 6);
  gtk_container_add (GTK_CONTAINER (frame), box);

  for (i = 0; i < MAX_NUMBER_OF_PLAYERS; i++) {
    box2 = gtk_hbox_new (FALSE, 12);

    gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0);
    ts = g_strdup_printf ("_%1d:", i + 1);
    label = gtk_label_new_with_mnemonic (ts);
    g_free (ts);
    gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);

    PlayerNames[i] = gtk_entry_new ();
    gtk_label_set_mnemonic_widget (GTK_LABEL (label), PlayerNames[i]);
    ts = g_strdup_printf ("PlayerName%1d", i + 1);
    gtk_widget_set_name (PlayerNames[i], ts);
    g_free (ts);
    gtk_entry_set_text (GTK_ENTRY (PlayerNames[i]), players[i].name);
    gtk_box_pack_start (GTK_BOX (box2), PlayerNames[i], FALSE, FALSE, 0);
  }

  gtk_widget_show_all (setupdialog);

  return FALSE;
}
コード例 #21
0
ファイル: conv.c プロジェクト: celiachen/hybrid
static void
init_chat_window_body(GtkWidget *vbox, HybridChatWindow *chat)
{
    GtkWidget     *scroll;
    GtkWidget     *button;
    GtkWidget     *image_icon;
    GtkWidget     *limit_label;
    GtkTextBuffer *send_buffer;
    gchar         *word_limit_string;
    gint           word_limit;
    HybridAccount *account;
    HybridModule  *module;
    HybridIMOps   *ops;

    g_return_if_fail(vbox != NULL);
    g_return_if_fail(chat != NULL);

    /* create buddy tips panel */
    create_buddy_tips_panel(vbox, chat);

    /* create textview */
    scroll = gtk_scrolled_window_new(NULL, NULL);
    gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
            GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
            GTK_SHADOW_ETCHED_IN);

    chat->textview = text_ops->create();
    g_signal_connect(chat->textview, "focus-in-event",
                    GTK_SIGNAL_FUNC(focus_in_cb), chat);
    gtk_container_add(GTK_CONTAINER(scroll), chat->textview);

    /* create toolbar */
    chat->toolbar = gtk_toolbar_new();
    gtk_toolbar_set_style(GTK_TOOLBAR(chat->toolbar), GTK_TOOLBAR_ICONS);
    gtk_box_pack_start(GTK_BOX(vbox), chat->toolbar, FALSE, FALSE, 0);

    image_icon = gtk_image_new_from_file(PIXMAPS_DIR"menus/logs.png");
    button = gtk_toolbar_append_item(GTK_TOOLBAR(chat->toolbar),
            _("Chat logs"), _("View chat logs"), NULL, image_icon,
            NULL, NULL);

    if (IS_SYSTEM_CHAT(chat)) {
        gtk_toolbar_append_space(GTK_TOOLBAR(chat->toolbar));
        image_icon = gtk_image_new_from_file(PIXMAPS_DIR"menus/nudge.png");
        button = gtk_toolbar_append_item(GTK_TOOLBAR(chat->toolbar),
                _("Screen jitter"), _("Send a screen jitter"), NULL,
                image_icon, NULL, NULL);
        gtk_toolbar_append_space(GTK_TOOLBAR(chat->toolbar));

        account = chat->account;
        module    = account->proto;
        ops        = module->info->im_ops;

        if (ops->chat_word_limit &&
            (word_limit = ops->chat_word_limit(account)) > 0) {

            word_limit_string =
                g_strdup_printf(_("Total %d character, left "), word_limit);

            limit_label = gtk_label_new(word_limit_string);

            g_free(word_limit_string);

            word_limit_string =
                g_strdup_printf(_("[<span color='#0099ff'>%d</span>] characters"),
                        word_limit);

            chat->words_left_label = gtk_label_new(NULL);
            gtk_label_set_markup(GTK_LABEL(chat->words_left_label), word_limit_string);
            g_free(word_limit_string);

            gtk_container_add(GTK_CONTAINER(chat->toolbar), limit_label);
            gtk_container_add(GTK_CONTAINER(chat->toolbar), chat->words_left_label);
        }
    }

    gtk_widget_show_all(chat->toolbar);

    /* create textview */
    scroll = gtk_scrolled_window_new(NULL, NULL);
    gtk_box_pack_start(GTK_BOX(vbox), scroll, FALSE, FALSE, 0);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
            GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
            GTK_SHADOW_ETCHED_IN);

    chat->sendtext = gtk_text_view_new();
    gtk_widget_set_size_request(chat->sendtext, 0, 80);
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(chat->sendtext),
            GTK_WRAP_WORD_CHAR);
    gtk_container_add(GTK_CONTAINER(scroll), chat->sendtext);
    g_signal_connect(chat->sendtext, "key_press_event",
            G_CALLBACK(key_pressed_cb), chat->parent);
    g_signal_connect(chat->sendtext, "focus-in-event",
                    GTK_SIGNAL_FUNC(focus_in_cb), chat);

    send_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(chat->sendtext));

    g_signal_connect(send_buffer, "changed",
            G_CALLBACK(sendtext_buffer_changed), chat);

    gtk_window_present(GTK_WINDOW(chat->parent->window));

    /* focus the send textview */
    GTK_WIDGET_SET_FLAGS(chat->sendtext, GTK_CAN_FOCUS);
    gtk_widget_grab_focus(chat->sendtext);

    gtk_widget_show_all(scroll);
    gtk_widget_show_all(vbox);
}
コード例 #22
0
ファイル: trkproperties.c プロジェクト: fishman/deadbeef
void
show_track_properties_dlg (int ctx) {
    last_ctx = ctx;

    if (tracks) {
        for (int i = 0; i < numtracks; i++) {
            deadbeef->pl_item_unref (tracks[i]);
        }
        free (tracks);
        tracks = NULL;
        numtracks = 0;
    }

    deadbeef->pl_lock ();
    ddb_playlist_t *plt = deadbeef->plt_get_curr ();
    if (!plt) {
        deadbeef->pl_unlock ();
        return;
    }
    int num = 0;
    if (ctx == DDB_ACTION_CTX_SELECTION) {
        num = deadbeef->plt_getselcount (plt);
    }
    else if (ctx == DDB_ACTION_CTX_PLAYLIST) {
        num = deadbeef->plt_get_item_count (plt, PL_MAIN);
    }
    else if (ctx == DDB_ACTION_CTX_NOWPLAYING) {
        num = 1;
    }
    if (num <= 0) {
        deadbeef->pl_unlock ();
        return;
    }

    tracks = malloc (sizeof (DB_playItem_t *) * num);
    if (!tracks) {
        fprintf (stderr, "gtkui: failed to alloc %d bytes to store selected tracks\n", (int)(num * sizeof (void *)));
        deadbeef->pl_unlock ();
        return;
    }

    if (ctx == DDB_ACTION_CTX_NOWPLAYING) {
        DB_playItem_t *it = deadbeef->streamer_get_playing_track ();
        if (!it) {
            free (tracks);
            tracks = NULL;
            deadbeef->pl_unlock ();
            return;
        }
        tracks[0] = it;
    }
    else {
        int n = 0;
        DB_playItem_t *it = deadbeef->pl_get_first (PL_MAIN);
        while (it) {
            if (ctx == DDB_ACTION_CTX_PLAYLIST || deadbeef->pl_is_selected (it)) {
                assert (n < num);
                deadbeef->pl_item_ref (it);
                tracks[n++] = it;
            }
            DB_playItem_t *next = deadbeef->pl_get_next (it, PL_MAIN);
            deadbeef->pl_item_unref (it);
            it = next;
        }
    }
    numtracks = num;

    deadbeef->pl_unlock ();

    GtkTreeView *tree;
    GtkTreeView *proptree;
    if (!trackproperties) {
        trackproperties = create_trackproperties ();
        gtk_window_set_transient_for (GTK_WINDOW (trackproperties), GTK_WINDOW (mainwin));
        wingeom_restore (trackproperties, "trkproperties", -1, -1, 300, 400, 0);

        // metadata tree
        tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
        store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
        gtk_tree_view_set_model (tree, GTK_TREE_MODEL (store));
        GtkCellRenderer *rend_text = gtk_cell_renderer_text_new ();
        rend_text2 = GTK_CELL_RENDERER (ddb_cell_renderer_text_multiline_new ());
        g_signal_connect ((gpointer)rend_text2, "edited",
                G_CALLBACK (on_metadata_edited),
                store);
        GtkTreeViewColumn *col1 = gtk_tree_view_column_new_with_attributes (_("Key"), rend_text, "text", 0, NULL);
        GtkTreeViewColumn *col2 = gtk_tree_view_column_new_with_attributes (_("Value"), rend_text2, "text", 1, NULL);
        gtk_tree_view_append_column (tree, col1);
        gtk_tree_view_append_column (tree, col2);

        // properties tree
        proptree = GTK_TREE_VIEW (lookup_widget (trackproperties, "properties"));
        propstore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
        gtk_tree_view_set_model (proptree, GTK_TREE_MODEL (propstore));
        GtkCellRenderer *rend_propkey = gtk_cell_renderer_text_new ();
        GtkCellRenderer *rend_propvalue = gtk_cell_renderer_text_new ();
        g_object_set (G_OBJECT (rend_propvalue), "editable", TRUE, NULL);
        col1 = gtk_tree_view_column_new_with_attributes (_("Key"), rend_propkey, "text", 0, NULL);
        col2 = gtk_tree_view_column_new_with_attributes (_("Value"), rend_propvalue, "text", 1, NULL);
        gtk_tree_view_append_column (proptree, col1);
        gtk_tree_view_append_column (proptree, col2);
    }
    else {
        tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
        store = GTK_LIST_STORE (gtk_tree_view_get_model (tree));
        gtk_list_store_clear (store);
        proptree = GTK_TREE_VIEW (lookup_widget (trackproperties, "properties"));
        propstore = GTK_LIST_STORE (gtk_tree_view_get_model (proptree));
        gtk_list_store_clear (propstore);
    }

    if (numtracks == 1) {
        deadbeef->pl_lock ();
        gtk_entry_set_text (GTK_ENTRY (lookup_widget (trackproperties, "filename")), deadbeef->pl_find_meta_raw (tracks[0], ":URI"));
        deadbeef->pl_unlock ();
    }
    else {
        gtk_entry_set_text (GTK_ENTRY (lookup_widget (trackproperties, "filename")), _("[Multiple values]"));
    }

    g_object_set (G_OBJECT (rend_text2), "editable", TRUE, NULL);

    GtkWidget *widget = trackproperties;
    GtkWidget *w;
    const char *meta;

    trkproperties_fill_metadata ();

    gtk_widget_set_sensitive (lookup_widget (widget, "write_tags"), TRUE);

    gtk_widget_show (widget);
    gtk_window_present (GTK_WINDOW (widget));
}
コード例 #23
0
ファイル: resv_info.c プロジェクト: cinek810/slurm
extern void popup_all_resv(GtkTreeModel *model, GtkTreeIter *iter, int id)
{
	char *name = NULL;
	char title[100] = {0};
	ListIterator itr = NULL;
	popup_info_t *popup_win = NULL;
	GError *error = NULL;

	gtk_tree_model_get(model, iter, SORTID_NAME, &name, -1);

	switch(id) {
	case PART_PAGE:
		snprintf(title, 100, "Partition(s) with reservation %s", name);
		break;
	case JOB_PAGE:
		snprintf(title, 100, "Job(s) in reservation %s", name);
		break;
	case NODE_PAGE:
		snprintf(title, 100, "Node(s) in reservation %s ", name);
		break;
	case SUBMIT_PAGE:
		snprintf(title, 100, "Submit job in reservation %s", name);
		break;
	case INFO_PAGE:
		snprintf(title, 100, "Full info for reservation %s", name);
		break;
	default:
		g_print("resv got %d\n", id);
	}

	itr = list_iterator_create(popup_list);
	while ((popup_win = list_next(itr))) {
		if (popup_win->spec_info)
			if (!xstrcmp(popup_win->spec_info->title, title)) {
				break;
			}
	}
	list_iterator_destroy(itr);

	if (!popup_win) {
		if (id == INFO_PAGE)
			popup_win = create_popup_info(id, RESV_PAGE, title);
		else
			popup_win = create_popup_info(RESV_PAGE, id, title);
	} else {
		g_free(name);
		gtk_window_present(GTK_WINDOW(popup_win->popup));
		return;
	}

	/* Pass the model and the structs from the iter so we can always get
	   the current node_inx.
	*/
	popup_win->model = model;
	popup_win->iter = *iter;
	popup_win->node_inx_id = SORTID_NODE_INX;

	switch(id) {
	case JOB_PAGE:
	case INFO_PAGE:
		popup_win->spec_info->search_info->gchar_data = name;
		//specific_info_job(popup_win);
		break;
	case NODE_PAGE:
	case PART_PAGE:
		g_free(name);
		gtk_tree_model_get(model, iter, SORTID_NODELIST, &name, -1);
		popup_win->spec_info->search_info->gchar_data = name;
		popup_win->spec_info->search_info->search_type =
			SEARCH_NODE_NAME;
		//specific_info_node(popup_win);
		break;
	case SUBMIT_PAGE:
		break;
	default:
		g_print("resv got unknown type %d\n", id);
	}
	if (!sview_thread_new((gpointer)popup_thr, popup_win, false, &error)) {
		g_printerr ("Failed to create resv popup thread: %s\n",
			    error->message);
		return;
	}
}
コード例 #24
0
ファイル: trkproperties.c プロジェクト: fishman/deadbeef
void
on_write_tags_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
    deadbeef->pl_lock ();
    GtkTreeView *tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
    GtkTreeModel *model = GTK_TREE_MODEL (gtk_tree_view_get_model (tree));

    // delete all metadata properties that are not in the listview
    for (int i = 0; i < numtracks; i++) {
        DB_metaInfo_t *meta = deadbeef->pl_get_metadata_head (tracks[i]);
        while (meta) {
            DB_metaInfo_t *next = meta->next;
            if (meta->key[0] != ':' && meta->key[0] != '!' && meta->key[0] != '_') {
                GtkTreeIter iter;
                gboolean res = gtk_tree_model_get_iter_first (model, &iter);
                while (res) {
                    GValue key = {0,};
                    gtk_tree_model_get_value (model, &iter, 2, &key);
                    const char *skey = g_value_get_string (&key);

                    if (!strcasecmp (skey, meta->key)) {
                        // field found, don't delete
                        break;
                    }
                    res = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
                }
                if (!res) {
                    // field not found, delete
                    deadbeef->pl_delete_metadata (tracks[i], meta);
                }
            }
            meta = next;
        }
    }
    // put all metainfo into track
    gtk_tree_model_foreach (model, set_metadata_cb, NULL);
    deadbeef->pl_unlock ();

    for (int i = 0; i < numtracks; i++) {
        ddb_event_track_t *ev = (ddb_event_track_t *)deadbeef->event_alloc (DB_EV_TRACKINFOCHANGED);
        ev->track = tracks[i];
        deadbeef->pl_item_ref (ev->track);
        deadbeef->event_send ((ddb_event_t*)ev, 0, 0);
    }

    progress_aborted = 0;
    progressdlg = create_progressdlg ();
    gtk_window_set_title (GTK_WINDOW (progressdlg), _("Writing tags..."));

    g_signal_connect ((gpointer) progressdlg, "delete_event",
            G_CALLBACK (on_progress_delete_event),
            NULL);
    GtkWidget *cancelbtn = lookup_widget (progressdlg, "cancelbtn");
    g_signal_connect ((gpointer) cancelbtn, "clicked",
            G_CALLBACK (on_progress_abort),
            NULL);

    gtk_widget_show_all (progressdlg);
    gtk_window_present (GTK_WINDOW (progressdlg));
    gtk_window_set_transient_for (GTK_WINDOW (progressdlg), GTK_WINDOW (trackproperties));

    // start new thread for writing metadata
    intptr_t tid = deadbeef->thread_start (write_meta_worker, NULL);
    deadbeef->thread_detach (tid);
}
コード例 #25
0
ファイル: gradients-commands.c プロジェクト: jiapei100/gimp
void
gradients_save_as_pov_ray_cmd_callback (GtkAction *action,
                                        gpointer   data)
{
  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
  GimpContext         *context;
  GimpGradient        *gradient;
  GtkWidget           *dialog;

  context  = gimp_container_view_get_context (editor->view);
  gradient = gimp_context_get_gradient (context);

  if (! gradient)
    return;

#define SAVE_AS_POV_DIALOG_KEY "gimp-save-as-pov-ray-dialog"

  dialog = dialogs_get_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY);

  if (! dialog)
    {
      gchar *title = g_strdup_printf (_("Save '%s' as POV-Ray"),
                                      gimp_object_get_name (gradient));

      dialog = gtk_file_chooser_dialog_new (title, NULL,
                                            GTK_FILE_CHOOSER_ACTION_SAVE,

                                            _("_Cancel"), GTK_RESPONSE_CANCEL,
                                            _("_Save"),   GTK_RESPONSE_OK,

                                            NULL);

      g_free (title);

      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
      gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
                                               GTK_RESPONSE_OK,
                                               GTK_RESPONSE_CANCEL,
                                               -1);

      g_object_set_data (G_OBJECT (dialog), "gimp", context->gimp);

      gtk_window_set_screen (GTK_WINDOW (dialog),
                             gtk_widget_get_screen (GTK_WIDGET (editor)));
      gtk_window_set_role (GTK_WINDOW (dialog), "gimp-gradient-save-pov");
      gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);

      gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
                                                      TRUE);

      g_signal_connect (dialog, "response",
                        G_CALLBACK (gradients_save_as_pov_ray_response),
                        gradient);
      g_signal_connect (dialog, "delete-event",
                        G_CALLBACK (gtk_true),
                        NULL);

      g_signal_connect_object (dialog, "destroy",
                               G_CALLBACK (g_object_unref),
                               g_object_ref (gradient),
                               G_CONNECT_SWAPPED);

      gimp_help_connect (dialog, gimp_standard_help_func,
                         GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL);

      dialogs_attach_dialog (G_OBJECT (gradient),
                             SAVE_AS_POV_DIALOG_KEY, dialog);
    }

  gtk_window_present (GTK_WINDOW (dialog));
}
コード例 #26
0
ファイル: trkproperties.c プロジェクト: fishman/deadbeef
void
on_add_field_activate                 (GtkMenuItem     *menuitem,
                                        gpointer         user_data) {
    GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
    if (!gtk_widget_is_focus(GTK_WIDGET (treeview))) {
        return; // do not add field if Metadata tab is not focused
    }
    GtkWidget *dlg = create_entrydialog ();
    gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (trackproperties));
    gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_RESPONSE_OK);
    gtk_window_set_title (GTK_WINDOW (dlg), _("Field name"));
    GtkWidget *e;
    e = lookup_widget (dlg, "title_label");
    gtk_label_set_text (GTK_LABEL(e), _("Name:"));
    for (;;) {
        int res = gtk_dialog_run (GTK_DIALOG (dlg));
        if (res == GTK_RESPONSE_OK) {
            e = lookup_widget (dlg, "title");

            const char *text = gtk_entry_get_text (GTK_ENTRY(e));

            GtkTreeIter iter;

            // check for _ and :
            if (text[0] == '_' || text[0] == ':' || text[0] == '!') {
                GtkWidget *d = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Field names must not start with : or _"));
                gtk_window_set_title (GTK_WINDOW (d), _("Cannot add field"));

                gtk_dialog_run (GTK_DIALOG (d));
                gtk_widget_destroy (d);
                continue;
            }

            // check if a field with the same name already exists
            int dup = 0;
            gboolean res = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
            while (res) {
                GValue value = {0,};
                gtk_tree_model_get_value (GTK_TREE_MODEL (store), &iter, 2, &value);
                const char *svalue = g_value_get_string (&value);
                if (!strcasecmp (svalue, text)) {
                    dup = 1;
                    break;
                }
                res = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
            }

            if (!dup) {
                int l = strlen (text);
                char title[l+3];
                snprintf (title, sizeof (title), "<%s>", text);
                const char *value = "";
                const char *key = text;

                gtk_list_store_append (store, &iter);
                gtk_list_store_set (store, &iter, 0, title, 1, value, 2, key, -1);
                GtkTreePath *path;
                gint rows = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL);
                path = gtk_tree_path_new_from_indices (rows - 1, -1);
                gtk_tree_view_set_cursor (treeview, path, NULL, TRUE); // set cursor onto new field
                gtk_tree_path_free(path);
                trkproperties_modified = 1;
            }
            else {
                GtkWidget *d = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Field with such name already exists, please try different name."));
                gtk_window_set_title (GTK_WINDOW (d), _("Cannot add field"));

                gtk_dialog_run (GTK_DIALOG (d));
                gtk_widget_destroy (d);
                continue;
            }
        }
        break;
    }
    gtk_widget_destroy (dlg);
    gtk_window_present (GTK_WINDOW (trackproperties));
}
コード例 #27
0
ファイル: gva-main.c プロジェクト: priteau/gnome-video-arcade
/**
 * gva_main_init:
 *
 * Initializes the main window.
 *
 * This function should be called once when the application starts.
 **/
void
gva_main_init (void)
{
        gchar *text;

        gva_tree_view_init ();

        gtk_box_pack_start (
                GTK_BOX (GVA_WIDGET_MAIN_VBOX),
                gva_ui_get_managed_widget ("/main-menu"),
                FALSE, FALSE, 0);

        gtk_action_connect_proxy (
                GVA_ACTION_VIEW_AVAILABLE,
                GVA_WIDGET_MAIN_VIEW_BUTTON_0);

        gtk_action_connect_proxy (
                GVA_ACTION_VIEW_FAVORITES,
                GVA_WIDGET_MAIN_VIEW_BUTTON_1);

        gtk_action_connect_proxy (
                GVA_ACTION_VIEW_RESULTS,
                GVA_WIDGET_MAIN_VIEW_BUTTON_2);

        gtk_action_connect_proxy (
                GVA_ACTION_PROPERTIES,
                GVA_WIDGET_MAIN_PROPERTIES_BUTTON);

        gtk_action_connect_proxy (
                GVA_ACTION_START,
                GVA_WIDGET_MAIN_START_GAME_BUTTON);

        gtk_widget_set_sensitive (
                GVA_WIDGET_MAIN_MUTE_BUTTON,
                gva_mame_supports_sound ());

        gconf_bridge_bind_property (
                gconf_bridge_get (), GVA_GCONF_SOUND_MUTED,
                G_OBJECT (GVA_WIDGET_MAIN_MUTE_BUTTON), "muted");

        gconf_bridge_bind_window (
                gconf_bridge_get (), GVA_GCONF_WINDOW_PREFIX,
                GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW), TRUE, FALSE);

        /* Initialize the search entry. */
        text = gva_main_get_last_search_text ();
        gtk_entry_set_text (GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY), text);
        g_free (text);

#if !GTK_CHECK_VERSION(2,14,0) && !defined WITH_GNOME
        /* Requires that we link against libgnome. */
        gtk_action_set_sensitive (GVA_ACTION_CONTENTS, FALSE);
#endif

        gtk_action_set_sensitive (GVA_ACTION_PROPERTIES, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_RECORD, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_SEARCH, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_SHOW_CLONES, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_START, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_VIEW_AVAILABLE, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_VIEW_FAVORITES, FALSE);
        gtk_action_set_sensitive (GVA_ACTION_VIEW_RESULTS, FALSE);

        gtk_action_set_visible (GVA_ACTION_INSERT_FAVORITE, FALSE);
        gtk_action_set_visible (GVA_ACTION_REMOVE_FAVORITE, FALSE);

        gtk_window_present (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
}
コード例 #28
0
ファイル: logging.c プロジェクト: 42p/linphone
void linphone_gtk_log_show(void){
	gtk_widget_show(log_window);
	gtk_window_present(GTK_WINDOW(log_window));
}
コード例 #29
0
ファイル: socket.c プロジェクト: cirne100/geany
gboolean socket_lock_input_cb(GIOChannel *source, GIOCondition condition, gpointer data)
{
	gint fd, sock;
	gchar buf[BUFFER_LENGTH];
	struct sockaddr_in caddr;
	socklen_t caddr_len = sizeof(caddr);
	GtkWidget *window = data;
	gboolean popup = FALSE;

	fd = g_io_channel_unix_get_fd(source);
	sock = accept(fd, (struct sockaddr *)&caddr, &caddr_len);

	/* first get the command */
	while (socket_fd_gets(sock, buf, sizeof(buf)) != -1)
	{
		if (strncmp(buf, "open", 4) == 0)
		{
			while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.')
			{
				handle_input_filename(g_strstrip(buf));
			}
			popup = TRUE;
		}
		else if (strncmp(buf, "doclist", 7) == 0)
		{
			gchar *doc_list = build_document_list();
			if (NZV(doc_list))
				socket_fd_write_all(sock, doc_list, strlen(doc_list));
			else
				/* send ETX (end-of-text) in case we have no open files, we must send anything
				 * otherwise the client would hang on reading */
				socket_fd_write_all(sock, "\3", 1);
			g_free(doc_list);
		}
		else if (strncmp(buf, "line", 4) == 0)
		{
			while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.')
			{
				g_strstrip(buf); /* remove \n char */
				/* on any error we get 0 which should be safe enough as fallback */
				cl_options.goto_line = atoi(buf);
			}
		}
		else if (strncmp(buf, "column", 6) == 0)
		{
			while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.')
			{
				g_strstrip(buf); /* remove \n char */
				/* on any error we get 0 which should be safe enough as fallback */
				cl_options.goto_column = atoi(buf);
			}
		}
#ifdef G_OS_WIN32
		else if (strncmp(buf, "window", 6) == 0)
		{
			HWND hwnd = (HWND) gdk_win32_drawable_get_handle(GDK_DRAWABLE(window->window));
			socket_fd_write(sock, (gchar *)&hwnd, sizeof(hwnd));
		}
#endif
	}

	if (popup)
	{
#ifdef GDK_WINDOWING_X11
		/* Set the proper interaction time on the window. This seems necessary to make
		 * gtk_window_present() really bring the main window into the foreground on some
		 * window managers like Gnome's metacity.
		 * Code taken from Gedit. */
		gdk_x11_window_set_user_time(window->window, gdk_x11_get_server_time(window->window));
#endif
		gtk_window_present(GTK_WINDOW(window));
#ifdef G_OS_WIN32
		gdk_window_show(window->window);
#endif
	}

	socket_fd_close(sock);

	return TRUE;
}
コード例 #30
0
ファイル: about.cpp プロジェクト: czchen/debian-gcin
void create_about_window()
{
    if (about_window) {
      gtk_window_present(GTK_WINDOW(about_window));
      return;
    }

    GtkWidget *vbox = gtk_vbox_new(FALSE,3);
    GtkWidget *hbox;

    /* Create a new about_window */
    about_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(about_window), GTK_WIN_POS_CENTER);

    gtk_window_set_has_resize_grip(GTK_WINDOW(about_window), FALSE);

    gtk_window_set_title (GTK_WINDOW (about_window), _(_L("關於 gcin")));


    g_signal_connect (G_OBJECT (about_window), "destroy",
	              G_CALLBACK (callback_close), NULL);

    g_signal_connect (G_OBJECT (about_window), "delete_event",
	 	      G_CALLBACK (callback_close), NULL);

    /* Sets the border width of the about_window. */
    gtk_container_set_border_width (GTK_CONTAINER (about_window), 10);


    GtkWidget *label_version;
    GtkWidget *image;

    /* Create box for image and label */
    hbox = gtk_hbox_new (FALSE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);

    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);

    GtkWidget *separator = gtk_hseparator_new ();
    gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 3);

// this doesn't work on win32
#if GTK_CHECK_VERSION(2,18,9) && UNIX && 0
   char tmp[1024];
   sprintf(tmp, "<a href='"FURL_LINUX"'>%s</a>\n"
                "<a href='"FURL_WIN32"'>%s</a>\n"
                "<a href='"LOG_URL"'>%s</a>\n"
                "<a href='"ET26_URL"'>%s</a>\n"
                "<a href='"PUNC_URL"'>%s</a>\n"
                "<a href='"ADD_PHRASE_URL"'>%s</a>\n"
                "<a href='"SPLIT_PHRASE_URL"'>%s</a>\n",
                _(_L("前往 gcin 討論區")),
                _(_L("gcin也有 Windows版")),
                _(_L("gcin改變記錄")),
                _(_L("推薦使用26鍵的注音鍵盤")),
                _(_L("使用詞音輸入標點符號")),
                _(_L("如何新增詞")),
                _(_L("如何手動斷詞"))

          );
   GtkWidget *label = gtk_label_new(tmp);
   gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
#else
static struct {
		unich_t *label_str;
		char *url;
	} lab_url[] = {
#if UNIX
		{_L("討論區"), FURL_LINUX },
        {_L("gcin也有 Windows版"), FURL_WIN32},
#else
		{_L("討論區"), FURL_WIN32 },
		{_L("gcin也有 Linux版"), FURL_LINUX},
#endif
		{_L("gcin也有 Android版"), FURL_ANDROID},
		{_L("gcin改變記錄"), LOG_URL},
		{_L("推薦使用26鍵的注音鍵盤"), ET26_URL},
		{_L("使用詞音輸入標點符號"), PUNC_URL},
		{_L("如何新增詞"), ADD_PHRASE_URL},
		{_L("如何手動斷詞"), SPLIT_PHRASE_URL},
#if WIN32
		{_L("IE內使用gcin"), IE_URL},
#endif
		{NULL}
	};

	int i;
	for(i=0; lab_url[i].url; i++) {
       GtkWidget *button = gtk_button_new_with_label(_(lab_url[i].label_str));
       gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
       g_signal_connect (G_OBJECT (button), "clicked",
		      G_CALLBACK (callback_url), lab_url[i].url);
	}
#endif


#if UNIX
    image = gtk_image_new_from_file (SYS_ICON_DIR"/hicolor/64x64/apps/gcin.png");
#else
    char gcin_png[128];
    sys_icon_fname("gcin.png", gcin_png);
    image = gtk_image_new_from_file (gcin_png);
#endif

    label_version = gtk_label_new ("version " GCIN_VERSION "  " __DATE__);

    gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 3);
    gtk_box_pack_start (GTK_BOX (hbox), label_version, FALSE, FALSE, 3);


    gtk_container_add (GTK_CONTAINER (about_window), vbox);

    GtkWidget *button = gtk_button_new_with_label (_(_L("關閉")));
    gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 3);
    g_signal_connect (G_OBJECT (button), "clicked",
		      G_CALLBACK (callback_close), (gpointer) "cool button");

    gtk_widget_show_all (about_window);

    return;
}