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);
}
}
}
//void menu_sensitivity_from_clipboard(gboolean is_clipboard_exist)
void menu_sensitivity_from_clipboard(void)
{
//g_print("clip board checked.\n");
gtk_widget_set_sensitive(menu_item_paste,
gtk_clipboard_wait_is_text_available(
gtk_clipboard_get(GDK_SELECTION_CLIPBOARD)));
}
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);
}
}
static void on_menuitem_edit_activate(void)
{
GtkWidget *widget = gtk_window_get_focus(gui.window);
bool selectable = false;
bool editable = false;
bool selection_ready = false;
bool clipboard_ready = false;
if (GTK_IS_ENTRY(widget)) {
selectable = gtk_entry_get_text_length(GTK_ENTRY(widget));
editable = gtk_editable_get_editable(GTK_EDITABLE(widget));
selection_ready = gtk_editable_get_selection_bounds(
GTK_EDITABLE(widget), NULL, NULL);
clipboard_ready = gtk_clipboard_wait_is_text_available(
gtk_clipboard_get(GDK_NONE));
}
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_cut),
selection_ready && editable);
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_copy),
selection_ready);
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_paste),
editable && clipboard_ready);
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_delete),
selection_ready && editable);
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_select_all),
selectable);
}
static gboolean waitForClipboardText(EditorTest* test)
{
test->m_triesCount++;
if (gtk_clipboard_wait_is_text_available(test->m_clipboard) || test->m_triesCount > kClipboardWaitMaxTries) {
g_main_loop_quit(test->m_mainLoop);
return FALSE;
}
return TRUE;
}
gchar* get_clipboard_text (void)
{
GtkClipboard *c = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
if (! c)
return NULL;
if (! gtk_clipboard_wait_is_text_available (c))
return NULL;
return gtk_clipboard_wait_for_text (c);
}
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);
}
}
static void fm_path_entry_populate_popup(GtkEntry *entry, GtkMenu *menu, gpointer user_data)
{
GtkWidget* menuitem;
GtkClipboard* clipboard = gtk_clipboard_get_for_display(
gtk_widget_get_display (entry), GDK_SELECTION_CLIPBOARD);
menuitem = gtk_menu_item_new_with_mnemonic(_("Paste and go"));
gtk_widget_show(menuitem);
/* Insert menu item after default Paste menu item */
gtk_menu_shell_insert (menu, menuitem, 3);
g_signal_connect(menuitem, "activate",
G_CALLBACK(fm_path_entry_paste_and_go), entry);
if (!gtk_clipboard_wait_is_text_available(clipboard))
gtk_widget_set_sensitive(menuitem, FALSE);
}
void on_edit_menu_activate(GtkMenuItem *menuitem, gpointer unused_data)
{
GtkWidget *tb = gglk_get_line_input_view();
GtkWidget *sel = gglk_get_selection_view();
gboolean text = FALSE;
if(tb) {
text = gtk_clipboard_wait_is_text_available(
gtk_widget_get_clipboard(tb, GDK_SELECTION_CLIPBOARD));
}
gtk_widget_set_sensitive(lookup_widget(GTK_WIDGET(menuitem), "cut1"),
sel != NULL);
gtk_widget_set_sensitive(lookup_widget(GTK_WIDGET(menuitem), "copy1"),
sel != NULL);
gtk_widget_set_sensitive(lookup_widget(GTK_WIDGET(menuitem), "paste1"),
text);
gtk_widget_set_sensitive(lookup_widget(GTK_WIDGET(menuitem), "clear"),
tb != NULL);
}
static void
chat_window_edit_activate_cb (GtkWidget *menuitem,
EmpathyChatWindow *window)
{
EmpathyChatWindowPriv *priv;
GtkClipboard *clipboard;
GtkTextBuffer *buffer;
gboolean text_available;
priv = GET_PRIV (window);
g_return_if_fail (priv->current_chat != NULL);
if (!empathy_chat_get_tp_chat (priv->current_chat)) {
gtk_widget_set_sensitive (priv->menu_edit_copy, FALSE);
gtk_widget_set_sensitive (priv->menu_edit_cut, FALSE);
gtk_widget_set_sensitive (priv->menu_edit_paste, FALSE);
return;
}
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->current_chat->input_text_view));
if (gtk_text_buffer_get_selection_bounds (buffer, NULL, NULL)) {
gtk_widget_set_sensitive (priv->menu_edit_copy, TRUE);
gtk_widget_set_sensitive (priv->menu_edit_cut, TRUE);
} else {
gboolean selection;
selection = empathy_chat_view_get_selection_bounds (priv->current_chat->view,
NULL, NULL);
gtk_widget_set_sensitive (priv->menu_edit_cut, FALSE);
gtk_widget_set_sensitive (priv->menu_edit_copy, selection);
}
clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
text_available = gtk_clipboard_wait_is_text_available (clipboard);
gtk_widget_set_sensitive (priv->menu_edit_paste, text_available);
}
static VALUE
rg_wait_is_text_available_p(VALUE self)
{
return CBOOL2RVAL(gtk_clipboard_wait_is_text_available(_SELF(self)));
}
bool cClipboardHandler::IsTextOnClipboard() const
{
return (gtk_clipboard_wait_is_text_available(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD)) == TRUE);
}
Php::Value GtkClipboard_::wait_is_text_available()
{
gboolean ret = gtk_clipboard_wait_is_text_available (GTK_CLIPBOARD(instance));
return ret;
}
// Is there something in the clipboard?
bool C4AbstractApp::IsClipboardFull(bool fClipboard)
{
return gtk_clipboard_wait_is_text_available(gtk_clipboard_get(fClipboard ? GDK_SELECTION_CLIPBOARD : GDK_SELECTION_PRIMARY));
}
void EvalCcRqCLIPBOARDHASTEXT (CrossCallInfo *pcci) /* no arguments; bool result. */
{
MakeReturn1Cci (pcci,(int) gtk_clipboard_wait_is_text_available(gtk_clipboard_get(GDK_NONE)));
}
/**
\author Peter G. Baum
**/
int gnoclClipboardCmd (
ClientData data,
Tcl_Interp *interp,
int objc,
Tcl_Obj * const objv[] )
{
GnoclOption options[] =
{
{ "-primary", GNOCL_BOOL, NULL },
{ NULL }
};
const int usePrimaryIdx = 0;
static const char *cmd[] = { "hasText", "setText", "getText", "clear",
NULL
};
enum optIdx { HasTextIdx, SetTextIdx, GetTextIdx, ClearIdx };
int idx;
int optNum;
GtkClipboard *clip;
int usePrimary = 0;
if ( objc < 2 )
{
Tcl_WrongNumArgs ( interp, 1, objv, "option" );
return TCL_ERROR;
}
if ( Tcl_GetIndexFromObj ( interp, objv[1], cmd, "option", TCL_EXACT,
&idx ) != TCL_OK )
return TCL_ERROR;
if ( idx == SetTextIdx )
{
optNum = 2;
if ( objc < 3 )
{
Tcl_WrongNumArgs ( interp, 1, objv, "text ?option value?" );
return TCL_ERROR;
}
}
else
{
optNum = 1;
if ( objc < 2 )
{
Tcl_WrongNumArgs ( interp, 1, objv, NULL );
return TCL_ERROR;
}
}
if ( gnoclParseOptions ( interp, objc - optNum, objv + optNum, options )
!= TCL_OK )
return TCL_ERROR;
if ( options[usePrimaryIdx].status == GNOCL_STATUS_CHANGED )
usePrimary = options[usePrimaryIdx].val.b;
clip = gtk_clipboard_get ( usePrimary ? gdk_atom_intern ( "PRIMARY", 1 )
: GDK_NONE );
switch ( idx )
{
case HasTextIdx:
{
int ret = gtk_clipboard_wait_is_text_available ( clip );
Tcl_SetObjResult ( interp, Tcl_NewBooleanObj ( ret ) );
}
break;
case SetTextIdx:
gtk_clipboard_set_text ( clip, Tcl_GetString ( objv[2] ), -1 );
break;
case GetTextIdx:
{
char *txt = gtk_clipboard_wait_for_text ( clip );
if ( txt )
{
Tcl_SetObjResult ( interp, Tcl_NewStringObj ( txt, -1 ) );
g_free ( txt );
}
/* FIXME? else error? */
}
break;
case ClearIdx:
gtk_clipboard_clear ( clip );
break;
}
return TCL_OK;
}
