Exemple #1
0
gboolean
mouse_ps(GtkWidget      *widget,
         GdkEventButton *event,
         gpointer        data)
{
    gchar *ps;
    if(event->type == GDK_BUTTON_PRESS && event->button == 3) // right click
    {
        ui_toggle_ps_mode();
        return FALSE;
    }
    if(!tuner.rds_ps_avail)
    {
        return FALSE;
    }
    if(conf.replace_spaces)
    {
        ps = replace_spaces(tuner.rds_ps);
        gtk_clipboard_set_text(gtk_widget_get_clipboard(ui.window, GDK_SELECTION_CLIPBOARD),
                               ps,
                               -1);
        g_free(ps);
    }
    else
    {
        gtk_clipboard_set_text(gtk_widget_get_clipboard(ui.window, GDK_SELECTION_CLIPBOARD),
                               tuner.rds_ps,
                               -1);
    }
    return TRUE;
}
Exemple #2
0
/* pass NULL as selection to paste to both clipboard & X11 text */
void
gtkutil_copy_to_clipboard (GtkWidget *widget, GdkAtom selection,
                           const gchar *str)
{
	GtkWidget *win;
	GtkClipboard *clip, *clip2;

	win = gtk_widget_get_toplevel (GTK_WIDGET (widget));
	if (GTK_WIDGET_TOPLEVEL (win))
	{
		int len = strlen (str);

		if (selection)
		{
			clip = gtk_widget_get_clipboard (win, selection);
			gtk_clipboard_set_text (clip, str, len);
		} else
		{
			/* copy to both primary X selection and clipboard */
			clip = gtk_widget_get_clipboard (win, GDK_SELECTION_PRIMARY);
			clip2 = gtk_widget_get_clipboard (win, GDK_SELECTION_CLIPBOARD);
			gtk_clipboard_set_text (clip, str, len);
			gtk_clipboard_set_text (clip2, str, len);
		}
	}
}
void EditorClient::respondToChangedSelection()
{
    WebKitWebViewPrivate* priv = m_webView->priv;
    Frame* targetFrame = core(m_webView)->focusController()->focusedOrMainFrame();

    if (!targetFrame)
        return;

    if (targetFrame->editor()->ignoreCompositionSelectionChange())
        return;

    GtkClipboard* clipboard = gtk_widget_get_clipboard(GTK_WIDGET(m_webView), GDK_SELECTION_PRIMARY);
    if (targetFrame->selection()->isRange()) {
        GtkTargetList* targetList = webkit_web_view_get_copy_target_list(m_webView);
        gint targetCount;
        GtkTargetEntry* targets = gtk_target_table_new_from_list(targetList, &targetCount);
        gtk_clipboard_set_with_owner(clipboard, targets, targetCount,
                                     clipboard_get_contents_cb, clipboard_clear_contents_cb, G_OBJECT(m_webView));
        gtk_target_table_free(targets, targetCount);
    } else if (gtk_clipboard_get_owner(clipboard) == G_OBJECT(m_webView))
        gtk_clipboard_clear(clipboard);

    if (!targetFrame->editor()->hasComposition())
        return;

    unsigned start;
    unsigned end;
    if (!targetFrame->editor()->getCompositionSelection(start, end)) {
        // gtk_im_context_reset() clears the composition for us.
        gtk_im_context_reset(priv->imContext);
        targetFrame->editor()->confirmCompositionWithoutDisturbingSelection();
    }
}
static void
on_map (GtkWidget *w)
{
  GtkClipboard *clip = gtk_widget_get_clipboard (w, GDK_SELECTION_CLIPBOARD);

  g_signal_connect (clip, "owner-change", G_CALLBACK (on_owner_change), w);
}
Exemple #5
0
CLIPRDR_FORMAT_LIST *remmina_rdp_cliprdr_get_client_format_list(RemminaProtocolWidget* gp)
{
	TRACE_CALL(__func__);

	GtkClipboard* gtkClipboard;
	rfContext* rfi = GET_PLUGIN_DATA(gp);
	GdkAtom* targets;
	gboolean result = 0;
	gint loccount, srvcount;
	gint formatId, i;
	CLIPRDR_FORMAT *formats;
	struct retp_t {
		CLIPRDR_FORMAT_LIST pFormatList;
		CLIPRDR_FORMAT formats[];
	} *retp;

	formats = NULL;

	retp = NULL;

	gtkClipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
	if (gtkClipboard) {
		result = gtk_clipboard_wait_for_targets(gtkClipboard, &targets, &loccount);
	}

	if (result && loccount > 0) {
		formats = (CLIPRDR_FORMAT*)malloc(loccount * sizeof(CLIPRDR_FORMAT));
		srvcount = 0;
		for (i = 0; i < loccount; i++) {
			formatId = remmina_rdp_cliprdr_get_format_from_gdkatom(targets[i]);
			if ( formatId != 0 ) {
				formats[srvcount].formatId = formatId;
				formats[srvcount].formatName = NULL;
				srvcount++;
			}
		}
		if (srvcount > 0) {
			retp = (struct retp_t *)malloc(sizeof(struct retp_t) + sizeof(CLIPRDR_FORMAT) * srvcount);
			retp->pFormatList.formats = retp->formats;
			retp->pFormatList.numFormats = srvcount;
			memcpy(retp->formats, formats, sizeof(CLIPRDR_FORMAT) * srvcount);
		} else {
			retp = (struct retp_t *)malloc(sizeof(struct retp_t));
			retp->pFormatList.formats = NULL;
			retp->pFormatList.numFormats = 0;
		}
		free(formats);
	} else {
		retp = (struct retp_t *)malloc(sizeof(struct retp_t) + sizeof(CLIPRDR_FORMAT));
		retp->pFormatList.formats = NULL;
		retp->pFormatList.numFormats = 0;
	}

	if (result)
		g_free(targets);

	retp->pFormatList.msgFlags = CB_RESPONSE_OK;

	return (CLIPRDR_FORMAT_LIST*)retp;
}
Exemple #6
0
//カーソルのある行を削除する
void kill_line(void)
{
    int delete_flag = 0;
    GtkTextIter start, end;
    GtkClipboard *clipboard = gtk_widget_get_clipboard(view, GDK_SELECTION_CLIPBOARD);
    
    buf[0] = '\0';
    if (kill_flag == 1) {
        char *text = gtk_clipboard_wait_for_text(clipboard);
        strcat(buf, text);
        free(text);
    }
    
    gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(buffer), &start, gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(buffer)));
    end = start;
    gtk_text_iter_forward_line(&end);
    if (!gtk_text_iter_starts_line(&start) && !gtk_text_iter_ends_line(&start) && !gtk_text_iter_is_end(&end) && kill_flag == 0) gtk_text_iter_backward_char(&end);
    
    char *text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, TRUE);
    strcat(buf, text);
    free(text);
    
    if (buf[0] != '\0') delete_flag = 1;
    
    gtk_clipboard_set_text(clipboard, buf, -1);
    gtk_text_buffer_delete(GTK_TEXT_BUFFER(buffer), &start, &end);
    
    kill_flag = delete_flag;
}
Exemple #7
0
/* preview_on_copy */
static void _preview_on_copy(gpointer data)
{
	Preview * preview = data;
	GtkClipboard * clipboard;

	clipboard = gtk_widget_get_clipboard(preview->view_text,
			GDK_SELECTION_CLIPBOARD);
	gtk_text_buffer_copy_clipboard(preview->view_text_tbuf, clipboard);
}
static void clipboard_local_to_remote (GtkMenuItem *menuitem,
                                       gpointer     user_data)
{
	GtkClipboard *clipboard;

	clipboard = gtk_widget_get_clipboard (GTK_WIDGET (menuitem),
	                                      GDK_SELECTION_CLIPBOARD);
	gtk_clipboard_request_text (clipboard, received_text_from_clipboard,
	                            NULL);
}
Exemple #9
0
void
fm__gth_browser_unrealize_cb (GthBrowser *browser)
{
	GtkClipboard *clipboard;

	clipboard = gtk_widget_get_clipboard (GTK_WIDGET (browser), GDK_SELECTION_CLIPBOARD);
	g_signal_handlers_disconnect_by_func (clipboard,
	                                      G_CALLBACK (clipboard_owner_change_cb),
	                                      browser);
}
Exemple #10
0
//選択された範囲をコピーする
void copy_text(void)
{
    GtkTextIter start, end;
    GtkClipboard *clipboard = gtk_widget_get_clipboard(view, GDK_SELECTION_CLIPBOARD);
    
    gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(buffer), &start, &end);
    char *text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, TRUE);
    gtk_clipboard_set_text(clipboard, text, -1);
    free(text);
}
Exemple #11
0
/* ghtml_paste */
void ghtml_paste(GtkWidget * widget)
{
	GHtml * ghtml;
	GtkTextBuffer * buffer;
	GtkClipboard * clipboard;

	ghtml = g_object_get_data(G_OBJECT(widget), "ghtml");
	clipboard = gtk_widget_get_clipboard(ghtml->view,
			GDK_SELECTION_CLIPBOARD);
	gtk_text_buffer_paste_clipboard(ghtml->tbuffer, clipboard, NULL, FALSE);
}
Exemple #12
0
static void gglk_text_paste_clipboard_selection(GglkText *tb,
						GdkAtom selection,
						GtkTextIter *iter)
{
    GtkClipboard *clipboard = gtk_widget_get_clipboard(GTK_WIDGET(tb),
						       selection);
    if(!gtk_text_iter_can_insert(iter, FALSE))
	gtk_text_buffer_get_iter_at_mark(tb->buffer, iter, tb->endedit);

    gtk_text_buffer_paste_clipboard(tb->buffer, clipboard, iter, FALSE);
}
static void clipboard_remote_to_local (GtkMenuItem *menuitem,
                                       gpointer     user_data)
{
	GtkClipboard *clipboard;

	clipboard = gtk_widget_get_clipboard (GTK_WIDGET (menuitem),
	                                      GDK_SELECTION_CLIPBOARD);

	gtk_clipboard_set_text (clipboard, server_cut_text,
	                        strlen (server_cut_text));
}
Exemple #14
0
static gboolean
request_text (gpointer data)
{
    GtkWidget *my_widget;
    GtkClipboard *clipboard;

    my_widget = GTK_WIDGET (data);
    clipboard = gtk_widget_get_clipboard (my_widget, GDK_SELECTION_PRIMARY);
    gtk_clipboard_request_text (clipboard, text_received_cb, my_widget);

    return FALSE;
}
Exemple #15
0
static void
paste_image (GtkMenuItem *item,
             gpointer     data)
{
  GdkClipboard *clipboard;

  clipboard = gtk_widget_get_clipboard (GTK_WIDGET (data));
  gdk_clipboard_read_texture_async (clipboard,
                                    NULL,
                                    paste_image_received,
                                    data);
}
Exemple #16
0
static void on_copy_url_activate(GtkMenuItem * item, gpointer data)
{
	WlHttper *httper = (WlHttper *) data;
	const gchar *url = wl_httper_get_url(httper);
	if (url == NULL)
		return;
	GtkClipboard *cb = gtk_widget_get_clipboard(GTK_WIDGET(httper),
												GDK_SELECTION_CLIPBOARD);
	if (cb) {
		gtk_clipboard_set_text(cb, url, -1);
	}
}
Exemple #17
0
gboolean
mouse_pi(GtkWidget *widget,
         GdkEvent  *event,
         gpointer   nothing)
{
    if(tuner.rds_pi < 0)
        return FALSE;

    gtk_clipboard_set_text(gtk_widget_get_clipboard(ui.window, GDK_SELECTION_CLIPBOARD),
                           gtk_label_get_text(GTK_LABEL(ui.l_pi)),
                           -1);
    return TRUE;
}
Exemple #18
0
gboolean
mouse_rt(GtkWidget *widget,
         GdkEvent  *event,
         gpointer   data)
{
    gchar *str;
    if(conf.replace_spaces)
    {
        str = replace_spaces((gchar*)data);
        gtk_clipboard_set_text(gtk_widget_get_clipboard(ui.window,GDK_SELECTION_CLIPBOARD),
                               str,
                               -1);
        g_free(str);
    }
    else
    {
        gtk_clipboard_set_text(gtk_widget_get_clipboard(ui.window, GDK_SELECTION_CLIPBOARD),
                               (gchar*)data,
                               -1);
    }
    return FALSE;
}
Exemple #19
0
static void
data_sheet_update_clipboard (PsppireSheet *sheet)
{
  GtkClipboard *clipboard =
    gtk_widget_get_clipboard (GTK_WIDGET (sheet),
			      GDK_SELECTION_CLIPBOARD);

  if (!gtk_clipboard_set_with_owner (clipboard, targets,
				     G_N_ELEMENTS (targets),
				     clipboard_get_cb, clipboard_clear_cb,
				     G_OBJECT (sheet)))
    clipboard_clear_cb (clipboard, sheet);
}
Exemple #20
0
void remmina_rdp_cliprdr_detach_owner(RemminaProtocolWidget* gp)
{
	/* When closing a rdp connection, we should check if gp is a clipboard owner.
	 * If it’s an owner, detach it from the clipboard */
	TRACE_CALL(__func__);
	rfContext* rfi = GET_PLUGIN_DATA(gp);
	GtkClipboard* gtkClipboard;

	gtkClipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
	if (gtkClipboard && gtk_clipboard_get_owner(gtkClipboard) == (GObject*)gp) {
		gtk_clipboard_clear(gtkClipboard);
	}

}
Exemple #21
0
/*
 * Get clipboard and 'Copy'
 */
void av_editor_copy_clipboard(const av_editor *editor)
{
  GtkClipboard *clipboard = NULL;

  g_return_if_fail(editor != NULL
                   && editor->textview != NULL
                   && editor->textbuf != NULL);

  clipboard = gtk_widget_get_clipboard(GTK_WIDGET(editor->textview), GDK_SELECTION_CLIPBOARD);

  gtk_text_buffer_copy_clipboard(editor->textbuf, clipboard);

  /* on copy do not scroll, we are already on screen */
}
Exemple #22
0
void text_entry_set_current(TextEntry *entry, struct session *sess)
{
        TextEntryPriv *priv = entry->priv;
        GtkWidget *widget = GTK_WIDGET(entry);
        GtkClipboard *clipboard;
        char *selection = NULL;
        char *text = NULL;
        int start, end;

        g_return_if_fail(gtk_widget_get_realized(widget));

        if (sess == priv->session) {
                return;
        }

        /* If the entry owns PRIMARY, setting the new text will clear PRIMARY;
         * so we need to re-set PRIMARY after setting the text.
         * See bug #345356 and bug #347067.
         */

        clipboard = gtk_widget_get_clipboard(widget, GDK_SELECTION_PRIMARY);
        g_assert(clipboard != NULL);

        if (gtk_clipboard_get_owner(clipboard) == G_OBJECT(entry) &&
            gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) {
                selection = gtk_editable_get_chars(GTK_EDITABLE(entry), start, end);
        }

        if (priv->session) {
                g_hash_table_replace(priv->current_text,
                                     priv->session,
                                     g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))));
        }

        priv->session = sess;

        if (priv->session) {
                text = g_hash_table_lookup(priv->current_text, priv->session);
        }

        gtk_entry_set_text(GTK_ENTRY(entry), text ? text : "");
        gtk_editable_set_position(GTK_EDITABLE(entry), -1);

        /* Restore the selection (note that it's not owned by us anymore!) */
        if (selection) {
                gtk_clipboard_set_text(clipboard, selection, strlen(selection));
                g_free(selection);
        }
}
Exemple #23
0
void
copy_button_clicked (GtkWidget *button,
                     gpointer   user_data)
{
  GtkWidget *entry;
  GdkClipboard *clipboard;

  entry = GTK_WIDGET (user_data);

  /* Get the clipboard object */
  clipboard = gtk_widget_get_clipboard (entry);

  /* Set clipboard text */
  gdk_clipboard_set_text (clipboard, gtk_editable_get_text (GTK_EDITABLE (entry)));
}
Exemple #24
0
void
copy_button_clicked (GtkWidget *button,
                     gpointer   user_data)
{
  GtkWidget *entry;
  GtkClipboard *clipboard;

  entry = GTK_WIDGET (user_data);

  /* Get the clipboard object */
  clipboard = gtk_widget_get_clipboard (entry,
                                        GDK_SELECTION_CLIPBOARD);

  /* Set clipboard text */
  gtk_clipboard_set_text (clipboard, gtk_entry_get_text (GTK_ENTRY (entry)), -1);
}
Exemple #25
0
static gboolean
ide_terminal_copy_link_address (IdeTerminal *self)
{
  IdeTerminalPrivate *priv = ide_terminal_get_instance_private (self);

  g_assert (IDE_IS_TERMINAL (self));
  g_assert (priv->url != NULL);

  if (dzl_str_empty0 (priv->url))
    return FALSE;

  gtk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (self), GDK_SELECTION_CLIPBOARD),
                          priv->url, strlen (priv->url));

  return TRUE;
}
Exemple #26
0
void remmina_rdp_cliprdr_set_clipboard_content(RemminaProtocolWidget* gp, RemminaPluginRdpUiObject* ui)
{
	TRACE_CALL(__func__);
	GtkClipboard* gtkClipboard;
	rfContext* rfi = GET_PLUGIN_DATA(gp);

	gtkClipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
	if (ui->clipboard.format == CB_FORMAT_PNG || ui->clipboard.format == CF_DIB || ui->clipboard.format == CF_DIBV5 || ui->clipboard.format == CB_FORMAT_JPEG) {
		gtk_clipboard_set_image( gtkClipboard, ui->clipboard.data );
		g_object_unref(ui->clipboard.data);
	}else  {
		gtk_clipboard_set_text( gtkClipboard, ui->clipboard.data, -1 );
		free(ui->clipboard.data);
	}

}
Exemple #27
0
static void
copy_image (GtkMenuItem *item,
            gpointer     data)
{
  GdkClipboard *clipboard;
  GdkPaintable *paintable;

  clipboard = gtk_widget_get_clipboard (GTK_WIDGET (data));
  paintable = get_image_paintable (GTK_IMAGE (data));

  if (GDK_IS_TEXTURE (paintable))
    gdk_clipboard_set_texture (clipboard, GDK_TEXTURE (paintable));

  if (paintable)
    g_object_unref (paintable);
}
Exemple #28
0
void
paste_button_clicked (GtkWidget *button,
                      gpointer   user_data)
{
  GtkWidget *entry;
  GdkClipboard *clipboard;

  entry = GTK_WIDGET (user_data);

  /* Get the clipboard object */
  clipboard = gtk_widget_get_clipboard (entry);

  /* Request the contents of the clipboard, contents_received will be
     called when we do get the contents.
   */
  gdk_clipboard_read_text_async (clipboard, NULL, paste_received, entry);
}
Exemple #29
0
static void
ide_editor_frame__search_populate_popup (IdeEditorFrame *self,
                                         GtkWidget      *popup,
                                         GdTaggedEntry  *entry)
{
  g_assert (IDE_IS_EDITOR_FRAME (self));
  g_assert (GTK_IS_WIDGET (popup));
  g_assert (GD_IS_TAGGED_ENTRY (entry));

  if (GTK_IS_MENU_SHELL (popup))
    {
      GMenu *menu;
      GActionGroup *group;
      GAction *action;
      GtkEntryBuffer *buffer;
      GtkClipboard *clipboard;
      gboolean clipboard_contains_text;
      gboolean entry_has_selection;

      group = gtk_widget_get_action_group (GTK_WIDGET (self->search_frame), "search-entry");

      menu = ide_application_get_menu_by_id (IDE_APPLICATION_DEFAULT, "ide-editor-frame-search-menu");
      gtk_menu_shell_bind_model (GTK_MENU_SHELL (popup), G_MENU_MODEL (menu), NULL, TRUE);

      clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD);
      clipboard_contains_text = gtk_clipboard_wait_is_text_available (clipboard);

      action = g_action_map_lookup_action (G_ACTION_MAP (group), "paste-clipboard");
      g_simple_action_set_enabled (G_SIMPLE_ACTION (action), clipboard_contains_text);

      entry_has_selection = gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), NULL, NULL);

      action = g_action_map_lookup_action (G_ACTION_MAP (group), "cut-clipboard");
      g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection);

      action = g_action_map_lookup_action (G_ACTION_MAP (group), "copy-clipboard");
      g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection);

      action = g_action_map_lookup_action (G_ACTION_MAP (group), "delete-selection");
      g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection);

      action = g_action_map_lookup_action (G_ACTION_MAP (group), "select-all");
      buffer = gtk_entry_get_buffer (GTK_ENTRY (self->search_entry));
      g_simple_action_set_enabled (G_SIMPLE_ACTION (action), gtk_entry_buffer_get_length (buffer) > 0);
    }
}
Exemple #30
0
void
gimp_text_tool_editor_button_release (GimpTextTool *text_tool)
{
  GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);

  if (gtk_text_buffer_get_has_selection (buffer))
    {
      GimpTool         *tool  = GIMP_TOOL (text_tool);
      GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
      GtkClipboard     *clipboard;

      clipboard = gtk_widget_get_clipboard (GTK_WIDGET (shell),
                                            GDK_SELECTION_PRIMARY);

      gtk_text_buffer_copy_clipboard (buffer, clipboard);
    }
}