static void testWebViewEditorSelectAllEditable(EditorTest* test, gconstpointer)
{
static const char* selectedSpanHTML = "<html><body contentEditable=\"true\">"
"<span id=\"mainspan\">All work and no play <span id=\"subspan\">make Jack a dull</span> boy.</span>"
"<script>document.getSelection().collapse();\n"
"document.getSelection().selectAllChildren(document.getElementById('subspan'));\n"
"</script></body></html>";
g_assert(test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_SELECT_ALL));
test->loadHtml(selectedSpanHTML, 0);
test->waitUntilLoadFinished();
g_assert(test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_SELECT_ALL));
test->copyClipboard();
GUniquePtr<char> clipboardText(gtk_clipboard_wait_for_text(test->m_clipboard));
// Initially only the subspan is selected.
g_assert_cmpstr(clipboardText.get(), ==, "make Jack a dull");
webkit_web_view_execute_editing_command(test->m_webView, WEBKIT_EDITING_COMMAND_SELECT_ALL);
test->copyClipboard();
clipboardText.reset(gtk_clipboard_wait_for_text(test->m_clipboard));
// The mainspan should be selected after calling SELECT_ALL.
g_assert_cmpstr(clipboardText.get(), ==, "All work and no play make Jack a dull boy.");
}
static void
clipman_clicked_not_separated (GtkWidget *menu,
ClipmanPlugin *clipman)
{
gchar *priClip, *defClip;
guint i;
ClipmanAction *action = NULL;
ClipmanClip *clip;
GtkWidget *mi;
priClip = gtk_clipboard_wait_for_text (primaryClip);
defClip = gtk_clipboard_wait_for_text (defaultClip);
for (i = clipman->clips->len; i--;)
{
clip = g_ptr_array_index (clipman->clips, i);
action = g_new0 (ClipmanAction, 1);
action->clipman = clipman;
action->clip = clip;
if (defClip != NULL &&
G_LIKELY (clip->text != NULL) &&
strcmp(clip->text, defClip) == 0)
{
mi = clipman_create_menuitem (action, clipman->clips->len-i, TRUE);
defClip = NULL;
}
else if (priClip != NULL &&
G_LIKELY (clip->text != NULL) &&
strcmp(clip->text, priClip) == 0)
{
mi = clipman_create_menuitem (action, clipman->clips->len-i, TRUE);
priClip = NULL;
}
else
{
mi = clipman_create_menuitem (action, clipman->clips->len-i, FALSE);
}
g_signal_connect (G_OBJECT(mi), "button_release_event",
G_CALLBACK(clipman_item_clicked), action);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
}
g_free (priClip);
g_free (defClip);
mi = gtk_separator_menu_item_new ();
gtk_widget_set_sensitive (mi, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
mi = gtk_menu_item_new_with_label (_("Clear History"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
g_signal_connect (G_OBJECT (mi), "button_release_event",
G_CALLBACK (clipman_clear), clipman);
}
static gboolean
clipman_check (ClipmanPlugin *clipman)
{
gchar *txt;
GdkModifierType state;
/* We ignore the selection clipboard entirely if you've activated this in the options dialog */
if (!clipman->IgnoreSelect)
{
/* Get mouse button information */
gdk_window_get_pointer(NULL, NULL, NULL, &state);
txt = gtk_clipboard_wait_for_text (primaryClip);
if (clipman->PreventEmpty && G_UNLIKELY (txt == NULL))
{
clipman_restore_empty (clipman, PRIMARY);
}
else if (txt != NULL &&
!(state & GDK_BUTTON1_MASK) &&
!clipman_exists (clipman, txt, PRIMARY)
)
{
DBG("Item added from primary clipboard");
clipman_add_clip (clipman, txt, PRIMARY);
clipman_check_array_len (clipman);
}
g_free (txt);
txt = NULL;
}
txt = gtk_clipboard_wait_for_text (defaultClip);
/* Check default clipboard */
if (clipman->PreventEmpty &&
G_UNLIKELY (txt == NULL)
)
{
clipman_restore_empty (clipman, DEFAULT);
}
else if (G_LIKELY (txt != NULL))
{
if (!clipman_exists (clipman, txt, DEFAULT))
{
DBG("Item added from default clipboard");
clipman_add_clip (clipman, txt, DEFAULT);
clipman_check_array_len (clipman);
}
}
g_free (txt);
return TRUE;
}
/* Called during the daemon loop to protect primary/clipboard contents */
static void daemon_check()
{
/* Get current primary/clipboard contents */
gchar *primary_temp = gtk_clipboard_wait_for_text(primary);
gchar *clipboard_temp = gtk_clipboard_wait_for_text(clipboard);
/* Check if primary contents were lost */
if ((primary_temp == NULL) && (primary_text != NULL))
{
/* Check contents */
gint count;
GdkAtom *targets;
gboolean contents = gtk_clipboard_wait_for_targets(primary, &targets, &count);
g_free(targets);
/* Only recover lost contents if there isn't any other type of content in the clipboard */
if (!contents)
gtk_clipboard_set_text(primary, primary_text, -1);
}
else
{
/* Get the button state to check if the mouse button is being held */
GdkModifierType button_state;
gdk_window_get_pointer(NULL, NULL, NULL, &button_state);
if ((primary_temp != NULL) && !(button_state & GDK_BUTTON1_MASK))
{
g_free(primary_text);
primary_text = g_strdup(primary_temp);
}
}
/* Check if clipboard contents were lost */
if ((clipboard_temp == NULL) && (clipboard_text != NULL))
{
/* Check contents */
gint count;
GdkAtom *targets;
gboolean contents = gtk_clipboard_wait_for_targets(clipboard, &targets, &count);
g_free(targets);
/* Only recover lost contents if there isn't any other type of content in the clipboard */
if (!contents)
gtk_clipboard_set_text(clipboard, clipboard_text, -1);
}
else
{
g_free(clipboard_text);
clipboard_text = g_strdup(clipboard_temp);
}
g_free(primary_temp);
g_free(clipboard_temp);
}
/**
* Core asks front end for clipboard contents.
*
* \param buffer UTF-8 text, allocated by front end, ownership yeilded to core
* \param length Byte length of UTF-8 text in buffer
*/
static void gui_get_clipboard(char **buffer, size_t *length)
{
gchar *gtext;
*buffer = NULL;
*length = 0;
/* get clipboard contents from gtk */
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtext = gtk_clipboard_wait_for_text(clipboard); /* conv to utf-8 */
if (gtext == NULL)
return;
*length = strlen(gtext);
*buffer = malloc(*length);
if (*buffer == NULL) {
*length = 0;
g_free(gtext);
return;
}
memcpy(*buffer, gtext, *length);
g_free(gtext);
}
static VALUE
rg_wait_for_text(VALUE self)
{
gchar *str;
str = gtk_clipboard_wait_for_text(_SELF(self));
return str ? CSTR2RVAL(str) : Qnil;
}
//カーソルのある行を削除する
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;
}
gint copy_clipboard_win(gpointer data){
gchar *str=NULL;
GtkClipboard* clipboard;
LOG(LOG_DEBUG, "IN : copy_clipboard()");
#ifdef __WIN32__
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
#else
clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
#endif
str = gtk_clipboard_wait_for_text(clipboard);
if(str == NULL){
goto END;
}
remove_space(str);
search_selected(str);
g_free(str);
END:
if(selection_mode != SELECTION_DO_NOTHING){
auto_lookup_start();
}
LOG(LOG_DEBUG, "OUT : copy_clipboard()");
return (FALSE);
}
static gint console_paste_text (GtkWidget *cview, GdkAtom atom)
{
GtkClipboard *cb = gtk_clipboard_get(atom);
gchar *src = gtk_clipboard_wait_for_text(cb);
if (src != NULL) {
GtkTextBuffer *buf;
GtkTextIter iter;
char *p;
p = strchr(src, '\n');
if (p != NULL) {
/* no newlines allowed! */
*p = '\0';
}
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(cview));
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, src, -1);
g_free(src);
}
return TRUE;
}
void sc_focus_inputbar(Browser *b, const Arg *arg)
{
char *data, *clipboard_text;
if (arg->data) {
if (arg->n == APPEND_URL) {
asprintf(&data, "%s%s", arg->data, webkit_web_view_get_uri(b->UI.view));
} else {
data = strdup(arg->data);
}
browser_notify(b, DEFAULT, data);
free(data);
/* save primary selection - will be overwritten on grab_focus */
clipboard_text = gtk_clipboard_wait_for_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY));
gtk_widget_grab_focus(GTK_WIDGET(b->UI.inputbar));
gtk_editable_set_position(GTK_EDITABLE(b->UI.inputbar), -1);
if (clipboard_text) {
/* restore primary selection */
gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_PRIMARY), clipboard_text, -1);
free(clipboard_text);
}
} else if (!gtk_widget_is_focus(GTK_WIDGET(b->UI.inputbar))) {
gtk_widget_grab_focus(GTK_WIDGET(b->UI.inputbar));
}
if (!gtk_widget_get_visible(GTK_WIDGET(b->UI.inputbar))) {
gtk_widget_show(GTK_WIDGET(b->UI.inputbar));
}
}
/* Returns a string from X selection.
* \param L The Lua VM state.
* \return The number of elements pushed on stack (1).
*/
static gint
luaH_luakit_get_selection(lua_State *L)
{
int n = lua_gettop(L);
GdkAtom atom = GDK_SELECTION_PRIMARY;
if (n) {
const gchar *arg = luaL_checkstring(L, 1);
/* Follow xclip(1) behavior: check only the first character of argument */
switch (arg[0]) {
case 'p':
break;
case 's':
atom = GDK_SELECTION_SECONDARY;
break;
case 'c':
atom = GDK_SELECTION_CLIPBOARD;
break;
default:
luaL_argerror(L, 1, "should be 'primary', 'secondary' or 'clipboard'");
break;
}
}
GtkClipboard *selection = gtk_clipboard_get(atom);
gchar *text = gtk_clipboard_wait_for_text(selection);
lua_pushstring(L, text);
g_free(text);
return 1;
}
static void testWebViewEditorCutCopyPasteNonEditable(EditorTest* test, gconstpointer)
{
static const char* selectedSpanHTML = "<html><body contentEditable=\"false\">"
"<span id=\"mainspan\">All work and no play <span id=\"subspan\">make Jack a dull</span> boy.</span>"
"<script>document.getSelection().collapse();\n"
"document.getSelection().selectAllChildren(document.getElementById('subspan'));\n"
"</script></body></html>";
// Nothing loaded yet.
g_assert(!test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_CUT));
g_assert(!test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_COPY));
g_assert(!test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_PASTE));
test->loadHtml(selectedSpanHTML, 0);
test->waitUntilLoadFinished();
g_assert(test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_COPY));
// It's not possible to cut and paste when content is not editable
// even if there's a selection.
g_assert(!test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_CUT));
g_assert(!test->canExecuteEditingCommand(WEBKIT_EDITING_COMMAND_PASTE));
test->copyClipboard();
GUniquePtr<char> clipboardText(gtk_clipboard_wait_for_text(test->m_clipboard));
g_assert_cmpstr(clipboardText.get(), ==, "make Jack a dull");
}
gboolean
e_composer_paste_text (EMsgComposer *composer,
GtkClipboard *clipboard)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
EHTMLEditorSelection *editor_selection;
gchar *text;
g_return_val_if_fail (E_IS_MSG_COMPOSER (composer), FALSE);
g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), FALSE);
if (!(text = gtk_clipboard_wait_for_text (clipboard)))
return FALSE;
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
editor_selection = e_html_editor_view_get_selection (view);
/* If WebView doesn't have focus, focus it */
if (!gtk_widget_has_focus (GTK_WIDGET (view)))
gtk_widget_grab_focus (GTK_WIDGET (view));
e_html_editor_selection_insert_text (editor_selection, text);
g_free (text);
return TRUE;
}
void PasteboardHelper::getClipboardContents(GtkClipboard* clipboard)
{
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
ASSERT(dataObject);
if (gtk_clipboard_wait_is_text_available(clipboard)) {
GOwnPtr<gchar> textData(gtk_clipboard_wait_for_text(clipboard));
if (textData)
dataObject->setText(String::fromUTF8(textData.get()));
}
if (gtk_clipboard_wait_is_target_available(clipboard, markupAtom)) {
if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, markupAtom)) {
String markup(selectionDataToUTF8String(data));
removeMarkupPrefix(markup);
dataObject->setMarkup(markup);
gtk_selection_data_free(data);
}
}
if (gtk_clipboard_wait_is_target_available(clipboard, uriListAtom)) {
if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, uriListAtom)) {
dataObject->setURIList(selectionDataToUTF8String(data));
gtk_selection_data_free(data);
}
}
}
static void load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
CopyAndPasteFixture* fixture = (CopyAndPasteFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status != WEBKIT_LOAD_FINISHED)
return;
GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_clear(clipboard);
webkit_web_view_copy_clipboard(webView);
gchar* text = gtk_clipboard_wait_for_text(clipboard);
g_assert(text || !fixture->info->expectedContent);
g_assert(!text || !strcmp(text, fixture->info->expectedContent));
g_free(text);
// Verify that the markup starts with the proper content-type meta tag prefix.
GtkSelectionData* selectionData = gtk_clipboard_wait_for_contents(clipboard, gdk_atom_intern("text/html", FALSE));
if (selectionData) {
static const char* markupPrefix = "<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">";
char* markup = g_strndup((const char*) gtk_selection_data_get_data(selectionData),
gtk_selection_data_get_length(selectionData));
g_assert(strlen(markupPrefix) <= strlen(markup));
g_assert(!strncmp(markupPrefix, markup, strlen(markupPrefix)));
g_free(markup);
}
g_assert(!gtk_clipboard_wait_is_uris_available(clipboard));
g_assert(!gtk_clipboard_wait_is_image_available(clipboard));
g_main_loop_quit(fixture->loop);
}
static void fm_path_entry_paste_and_go(GtkMenuItem *menuitem, GtkEntry *entry)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(
gtk_widget_get_display (GTK_WIDGET (menuitem)),GDK_SELECTION_CLIPBOARD);
gchar* full_path = gtk_clipboard_wait_for_text(clipboard);
if (full_path)
{
FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry);
if(priv->path)
fm_path_unref(priv->path);
/* special handling for home dir */
if(full_path[0] == '~' && full_path[1] == G_DIR_SEPARATOR)
priv->path = fm_path_new_relative(fm_path_get_home(), full_path + 2);
else if(full_path[0] == '~' && full_path[1] == 0)
priv->path = fm_path_ref(fm_path_get_home());
else
priv->path = fm_path_new_for_str(full_path);
gchar * disp_name = fm_path_display_name(priv->path, FALSE);
gtk_entry_set_text(entry, disp_name);
g_free(disp_name);
gtk_editable_set_position(GTK_EDITABLE(entry), -1);
g_free(full_path);
fm_path_entry_activate(FM_PATH_ENTRY(entry));
}
}
gint main ( gint argc, gchar* argv[] )
{
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW(window), "Clipboard Demonstration" );
g_object_set( window, "window-position", GTK_WIN_POS_CENTER, "border-width", 10, NULL );
gtk_window_set_default_size( GTK_WINDOW(window), 350, 70 );
g_signal_connect ( GTK_WIDGET(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
GtkWidget *entry = gtk_entry_new();
gtk_container_add( GTK_CONTAINER(window), entry );
gtk_widget_show_all( GTK_WIDGET( window ) );
GdkDisplay *display = gtk_widget_get_display( window );
GtkClipboard *clipboard = gtk_clipboard_get_for_display( display, GDK_SELECTION_CLIPBOARD );
gchar *text = gtk_clipboard_wait_for_text( clipboard );
if ( !text ) {
text = g_strdup("");
}
gtk_entry_set_text( GTK_ENTRY(entry), text );
g_signal_connect( entry, "changed", G_CALLBACK(entry_text_changes), (gpointer)clipboard);
gtk_main();
g_free( text );
return 0;
}
static void
prepopulate_fields(LinkDialog *ld, char *bufsel) {
GtkClipboard *clipboard;
char *clipsel, *url = NULL;
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
clipsel = gtk_clipboard_wait_for_text(clipboard);
if (bufsel && has_url(bufsel)) {
url = bufsel;
} else if (clipsel && has_url(clipsel)) {
url = clipsel;
}
if (bufsel)
gtk_entry_set_text(GTK_ENTRY(ld->etext), bufsel);
if (url) {
char *niceurl;
if (g_str_has_prefix(url, "http://") ||
g_str_has_prefix(url, "ftp://")) {
niceurl = url;
} else {
niceurl = g_strdup_printf("http://%s", url);
}
gtk_entry_set_text(GTK_ENTRY(ld->eurl), niceurl);
if (niceurl != url)
g_free(niceurl);
}
g_free(clipsel);
}
void clipChanged(GtkClipboard* clipboard,gpointer user_data)
{
char* texthold;
char* label;
if (manual==true)
{
manual=false;
return;
}
if (gtk_clipboard_wait_is_text_available(mainClipboard)==true)
{
setCurrentClip();
if(clip[currentClip].text != NULL)
free(clip[currentClip].text);
clip[currentClip].text=gtk_clipboard_wait_for_text(clipboard);
texthold=g_strescape(clip[currentClip].text,NULL);
texthold=g_strstrip(texthold);
if(strlen(clip[currentClip].text)>MAXCLIPMENULEN)
{
sinkInt=asprintf(&label,"%." CLIPENDLENSTR "s...%s",texthold,(char*)&texthold[strlen(texthold)-CLIPENDLEN]);
gtk_menu_item_set_label((GtkMenuItem*)clip[currentClip].menuItem,label);
free(label);
}
else
gtk_menu_item_set_label((GtkMenuItem*)clip[currentClip].menuItem,texthold);
free(texthold);
gtk_widget_show_all(menuPlug);
}
}
PassRefPtr<DocumentFragment> Pasteboard::documentFragment(Frame* frame, PassRefPtr<Range> context,
bool allowPlainText, bool& chosePlainText)
{
GdkAtom textHtml = gdk_atom_intern_static_string("text/html");
GtkClipboard* clipboard = m_helper->getCurrentTarget(frame);
chosePlainText = false;
if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, textHtml)) {
ASSERT(data->data);
String html = String::fromUTF8(reinterpret_cast<gchar*>(data->data), data->length * data->format / 8);
gtk_selection_data_free(data);
if (!html.isEmpty()) {
RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(frame->document(), html, "");
if (fragment)
return fragment.release();
}
}
if (!allowPlainText)
return 0;
if (gchar* utf8 = gtk_clipboard_wait_for_text(clipboard)) {
String text = String::fromUTF8(utf8);
g_free(utf8);
chosePlainText = true;
RefPtr<DocumentFragment> fragment = createFragmentFromText(context.get(), text);
if (fragment)
return fragment.release();
}
return 0;
}
static gboolean
clipman_item_clicked (GtkWidget *mi,
GdkEventButton *ev,
ClipmanAction *action)
{
if (ev->button == 1 && action->clipman->Behaviour == STRICTLY)
{
DBG("Clip copied to his own clipboard (STRICTLY)");
if (action->clip->fromtype == DEFAULT)
gtk_clipboard_set_text(defaultClip, action->clip->text, -1);
if (action->clip->fromtype == PRIMARY)
gtk_clipboard_set_text(primaryClip, action->clip->text, -1);
}
else if (ev->button == 1)
{
DBG("Clip copied to both clipboards");
gtk_clipboard_set_text(defaultClip, action->clip->text, -1);
gtk_clipboard_set_text(primaryClip, action->clip->text, -1);
}
else if (ev->button == 3)
{
if (xfce_confirm (_("Are you sure you want to remove this clip from the history?"),
"gtk-yes",
NULL))
{
DBG ("Removed the selected clip from the History");
if (gtk_clipboard_wait_for_text (defaultClip) &&
!strcmp(gtk_clipboard_wait_for_text (defaultClip), action->clip->text)
)
gtk_clipboard_set_text(defaultClip, "", -1);
if (gtk_clipboard_wait_for_text (primaryClip) &&
!strcmp(gtk_clipboard_wait_for_text (primaryClip), action->clip->text)
)
gtk_clipboard_set_text(primaryClip, "", -1);
g_ptr_array_remove (action->clipman->clips, action->clip);
clipman_free_clip (action->clip);
}
}
return FALSE;
}
void EvalCcRqGETCLIPBOARDTEXT (CrossCallInfo *pcci) /* no params; string result. */
{
gchar *text = gtk_clipboard_wait_for_text(gtk_clipboard_get(GDK_NONE));
char *result = g_strdup(text);
g_free(text);
MakeReturn1Cci (pcci, (int) result);
}
bool cClipboardHandler::PasteTextFromClipboard(string_t& sText) const
{
const char* szText = gtk_clipboard_wait_for_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
if (szText == nullptr) return false;
sText = string::ToString(szText);
g_free(szText);
return true;
}
static const char* ImGui_ImplGtk3Cogl_GetClipboardText(void* user_data)
{
static char *last_clipboard = NULL;
g_clear_pointer(&last_clipboard, g_free);
last_clipboard = gtk_clipboard_wait_for_text(GTK_CLIPBOARD(user_data));
return last_clipboard;
}
dlle___ void cb_get_text__(char** addr_ret) {
GtkClipboard *cb = cb__();
if(!cb)
return;
const char* s = gtk_clipboard_wait_for_text(cb);
if(!s)
return;
*addr_ret = dup__(s);
}
void
selection_changed_cb(WebKitWebView *webkitwebview, gpointer ud) {
(void)ud;
gchar *tmp;
webkit_web_view_copy_clipboard(webkitwebview);
tmp = gtk_clipboard_wait_for_text(gtk_clipboard_get (GDK_SELECTION_CLIPBOARD));
send_event(SELECTION_CHANGED, NULL, TYPE_STR, tmp ? tmp : "", NULL);
g_free(tmp);
}
// Paste the text from the clipboard or the primary selection
StdStrBuf C4AbstractApp::Paste(bool fClipboard)
{
char * r = gtk_clipboard_wait_for_text(gtk_clipboard_get(fClipboard ? GDK_SELECTION_CLIPBOARD : GDK_SELECTION_PRIMARY));
// gtk_clipboard_request_text(gtk_clipboard_get(fClipboard ? GDK_SELECTION_CLIPBOARD : GDK_SELECTION_PRIMARY),
// GtkClipboardTextReceivedFunc callback, gpointer user_data);
StdStrBuf rbuf;
rbuf.Copy(r);
g_free(r);
return rbuf;
}
static jobject get_data_text(JNIEnv *env)
{
gchar *data = gtk_clipboard_wait_for_text(get_clipboard());
if (data == NULL) {
return NULL;
}
jstring jdata = env->NewStringUTF(data);
g_free(data);
return jdata;
}
gboolean command_yank(const Arg *arg, char buf)
{
static char *tmpl = "Yanked: %s";
if (arg->i == COMMAND_YANK_SELECTION) {
char *text = NULL;
/* copy current selection to clipboard */
webkit_web_view_copy_clipboard(vb.gui.webview);
text = gtk_clipboard_wait_for_text(PRIMARY_CLIPBOARD());
if (!text) {
text = gtk_clipboard_wait_for_text(SECONDARY_CLIPBOARD());
}
if (text) {
/* put the text into the yank buffer */
vb_register_add(buf, text);
vb_echo(VB_MSG_NORMAL, false, tmpl, text);
g_free(text);
return true;
}
return false;
}
Arg a = {VB_CLIPBOARD_PRIMARY|VB_CLIPBOARD_SECONDARY};
if (arg->i == COMMAND_YANK_URI) {
/* yank current uri */
a.s = vb.state.uri;
} else {
/* use current arg.s as new clipboard content */
a.s = arg->s;
}
if (a.s) {
/* put the text into the yank buffer */
vb_set_clipboard(&a);
vb_register_add(buf, a.s);
vb_echo(VB_MSG_NORMAL, false, tmpl, a.s);
return true;
}
return false;
}
const char *sys_get_clipboard_text(void* user)
{
GtkClipboard *cb;
static gchar *text = NULL;
gtk_init_check(NULL, NULL);
g_free(text);
cb = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
text = gtk_clipboard_wait_for_text(cb);
return text;
}
