コード例 #1
0
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
    if (info == getIdForTargetType(TargetTypeText))
        gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);

    else if (info == getIdForTargetType(TargetTypeMarkup)) {
        // Some Linux applications refuse to accept pasted markup unless it is
        // prefixed by a content-type meta tag.
        CString markup = (gMarkupPrefix + dataObject->markup()).utf8();
        gtk_selection_data_set(selectionData, markupAtom, 8,
            reinterpret_cast<const guchar*>(markup.data()), markup.length() + 1);

    } else if (info == getIdForTargetType(TargetTypeURIList)) {
        CString uriList = dataObject->uriList().utf8();
        gtk_selection_data_set(selectionData, uriListAtom, 8,
            reinterpret_cast<const guchar*>(uriList.data()), uriList.length() + 1);

    } else if (info == getIdForTargetType(TargetTypeNetscapeURL) && dataObject->hasURL()) {
        String url(dataObject->url());
        String result(url);
        result.append("\n");

        if (dataObject->hasText())
            result.append(dataObject->text());
        else
            result.append(url);

        GOwnPtr<gchar> resultData(g_strdup(result.utf8().data()));
        gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
            reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()) + 1);

    } else if (info == getIdForTargetType(TargetTypeImage))
        gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
}
コード例 #2
0
ファイル: map.c プロジェクト: chubinou/darktable
static void
_view_map_dnd_get_callback(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data,
                                guint target_type, guint time, dt_view_t *self)
{
  dt_map_t *lib = (dt_map_t*)self->data;

  g_assert (selection_data != NULL);

  int imgid = lib->selected_image;

  switch (target_type)
  {
    case DND_TARGET_IMGID:
      gtk_selection_data_set(selection_data, selection_data-> target, _DWORD, (guchar*) &imgid, sizeof(imgid));
      break;
    default: // return the location of the file as a last resort
    case DND_TARGET_URI:
    {
      gchar pathname[DT_MAX_PATH_LEN] = {0};
      dt_image_full_path(imgid, pathname, DT_MAX_PATH_LEN);
      gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host?
      gtk_selection_data_set(selection_data, selection_data-> target, _BYTE, (guchar*) uri, strlen(uri));
      g_free(uri);
      break;
    }
  }
}
コード例 #3
0
ファイル: clipboard.c プロジェクト: bbidulock/dockapps
/*
 * handles request for selection from other apps
 */
gboolean
selection_handle(GtkWidget *widget,
		GtkSelectionData *selection_data,
		guint info,
		guint time_stamp,
		gpointer data)
{
	static gchar	*converted = NULL;

	begin_func("selection_handle");

	if (converted != NULL) {
		g_free(converted);
	}

	if (selected) {
		converted = from_utf8(selected->content);
		gtk_selection_data_set(selection_data,
				GDK_SELECTION_TYPE_STRING,
				8,
				(guchar *) converted,
				strlen(converted));
	} else {
		gtk_selection_data_set(selection_data,
				GDK_SELECTION_TYPE_STRING,
				8,
				(guchar *)"",
				0);
	}

	return_val(TRUE);
}
コード例 #4
0
ファイル: gui.c プロジェクト: lukspdev/lppb
static void  
drag_data_get_handl(GtkWidget          *widget,
		             GdkDragContext     *context,
		             GtkSelectionData   *sel_data,
		             guint               info,
		             guint               time,
		             gpointer            data)
{
    guint i = GPOINTER_TO_UINT(data);

    g_print("\nGet data...\n");
    switch(i) {
        case 0:
            gtk_selection_data_set(sel_data, gtk_selection_data_get_target
                                   (sel_data), 8, (guchar *)"Candidate 0", 11);
            break;
        case 1:
            gtk_selection_data_set(sel_data, gtk_selection_data_get_target
                                   (sel_data), 8, (guchar *)"Candidate 1", 11);
            break;
        case 2:
            gtk_selection_data_set(sel_data, gtk_selection_data_get_target
                                   (sel_data), 8, (guchar *)"Candidate 2", 11);
            break;
        default:
            break;
    }
}
コード例 #5
0
static void _lib_filmstrip_dnd_get_callback(GtkWidget *widget, GdkDragContext *context,
                                            GtkSelectionData *selection_data, guint target_type, guint time,
                                            gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_filmstrip_t *strip = (dt_lib_filmstrip_t *)self->data;

  g_assert(selection_data != NULL);

  int mouse_over_id = strip->mouse_over_id;
  int count = dt_collection_get_selected_count(NULL);
  switch(target_type)
  {
    case DND_TARGET_IMGID:
    {
      int id = ((count == 1) ? mouse_over_id : -1);
      gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _DWORD,
                             (guchar *)&id, sizeof(id));
      break;
    }
    default:             // return the location of the file as a last resort
    case DND_TARGET_URI: // TODO: add all images from the selection
    {
      if(count == 1)
      {
        gchar pathname[PATH_MAX] = { 0 };
        gboolean from_cache = TRUE;
        dt_image_full_path(mouse_over_id, pathname, sizeof(pathname), &from_cache);
        gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host?
        gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _BYTE,
                               (guchar *)uri, strlen(uri));
        g_free(uri);
      }
      else
      {
        sqlite3_stmt *stmt;
        GList *images = NULL;
        DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
                                    "SELECT imgid FROM main.selected_images", -1, &stmt, NULL);
        while(sqlite3_step(stmt) == SQLITE_ROW)
        {
          int id = sqlite3_column_int(stmt, 0);
          gchar pathname[PATH_MAX] = { 0 };
          gboolean from_cache = TRUE;
          dt_image_full_path(id, pathname, sizeof(pathname), &from_cache);
          gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host?
          images = g_list_append(images, uri);
        }
        sqlite3_finalize(stmt);
        gchar *uri_list = dt_util_glist_to_str("\r\n", images);
        g_list_free_full(images, g_free);
        gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _BYTE,
                               (guchar *)uri_list, strlen(uri_list));
        g_free(uri_list);
      }
      break;
    }
  }
}
コード例 #6
0
ファイル: PasteboardHelper.cpp プロジェクト: TaleAi/webkit
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
    if (info == TargetTypeText)
        gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);

    else if (info == TargetTypeMarkup) {
        // Some Linux applications refuse to accept pasted markup unless it is
        // prefixed by a content-type meta tag.
        CString markup = String(gMarkupPrefix + dataObject->markup()).utf8();
        gtk_selection_data_set(selectionData, markupAtom, 8,
                               reinterpret_cast<const guchar*>(markup.data()), markup.length());

    } else if (info == TargetTypeURIList) {
        CString uriList = dataObject->uriList().utf8();
        gtk_selection_data_set(selectionData, uriListAtom, 8,
                               reinterpret_cast<const guchar*>(uriList.data()), uriList.length());

    } else if (info == TargetTypeNetscapeURL && dataObject->hasURL()) {
        String url(dataObject->url());
        String result(url);
        result.append("\n");

        if (dataObject->hasText())
            result.append(dataObject->text());
        else
            result.append(url);

        GUniquePtr<gchar> resultData(g_strdup(result.utf8().data()));
        gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
                               reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));

    } else if (info == TargetTypeImage)
        gtk_selection_data_set_pixbuf(selectionData, dataObject->image());

    else if (info == TargetTypeSmartPaste)
        gtk_selection_data_set_text(selectionData, "", -1);

    else if (info == TargetTypeUnknown) {
        GVariantBuilder builder;
        g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);

        auto types = dataObject->unknownTypes();
        auto end = types.end();
        for (auto it = types.begin(); it != end; ++it) {
            GUniquePtr<gchar> dictItem(g_strdup_printf("{'%s', '%s'}", it->key.utf8().data(), it->value.utf8().data()));
            g_variant_builder_add_parsed(&builder, dictItem.get());
        }

        GRefPtr<GVariant> variant = g_variant_builder_end(&builder);
        GUniquePtr<gchar> serializedVariant(g_variant_print(variant.get(), TRUE));
        gtk_selection_data_set(selectionData, unknownAtom, 1, reinterpret_cast<const guchar*>(serializedVariant.get()), strlen(serializedVariant.get()));
    }
}
コード例 #7
0
static void
xfdesktop_clipboard_manager_get_callback (GtkClipboard     *clipboard,
                                          GtkSelectionData *selection_data,
                                          guint             target_info,
                                          gpointer          user_data)
{
  XfdesktopClipboardManager *manager = XFDESKTOP_CLIPBOARD_MANAGER (user_data);
  GList                  *file_list = NULL;
  gchar                  *string_list;
  gchar                  *data;

  g_return_if_fail (GTK_IS_CLIPBOARD (clipboard));
  g_return_if_fail (XFDESKTOP_IS_CLIPBOARD_MANAGER (manager));
  g_return_if_fail (manager->clipboard == clipboard);

  /* determine the file list from the icon list */
  file_list = xfdesktop_file_utils_file_icon_list_to_file_list (manager->files);

  /* determine the string representation of the file list */
  string_list = xfdesktop_file_utils_file_list_to_string (file_list);

  switch (target_info)
    {
    case TARGET_GNOME_COPIED_FILES:
      data = g_strconcat (manager->files_cutted ? "cut\n" : "copy\n", string_list, NULL);
      gtk_selection_data_set (selection_data,
                              gtk_selection_data_get_target(selection_data),
                              8,
                              (guchar *) data,
                              strlen (data));
      g_free (data);
      break;

    case TARGET_UTF8_STRING:
      gtk_selection_data_set (selection_data,
                              gtk_selection_data_get_target(selection_data),
                              8,
                              (guchar *) string_list,
                              strlen (string_list));
      break;

    default:
      g_assert_not_reached ();
    }

  /* cleanup */
  xfdesktop_file_utils_file_list_free (file_list);
  g_free (string_list);
}
コード例 #8
0
ファイル: music_browser.c プロジェクト: alex1818/aqualung
void
browser_drag_data_get(GtkWidget * widget, GdkDragContext * drag_context,
		      GtkSelectionData * data, guint info, guint time, gpointer user_data) {

	gtk_selection_data_set(data, gtk_selection_data_get_target(data), 8,
			       (const guchar *) "store\0", 6);
}
コード例 #9
0
static void
drag_data_get (GtkWidget *widget,
    GdkDragContext *context,
    GtkSelectionData *selection,
    guint info,
    guint time_)
{
  EmpathyPersonaView *self = EMPATHY_PERSONA_VIEW (widget);
  FolksPersona *persona;
  const gchar *persona_uid;

  if (info != DND_DRAG_TYPE_PERSONA_ID)
    return;

  persona = empathy_persona_view_dup_selected (self);
  if (persona == NULL)
    return;

  persona_uid = folks_persona_get_uid (persona);
  gtk_selection_data_set (selection,
      gdk_atom_intern ("text/x-persona-id", FALSE), 8,
      (guchar *) persona_uid, strlen (persona_uid) + 1);

  g_object_unref (persona);
}
コード例 #10
0
ファイル: actions.c プロジェクト: GNOME/gthumb
static void
clipboard_get_cb (GtkClipboard     *clipboard,
		  GtkSelectionData *selection_data,
		  guint             info,
		  gpointer          user_data_or_owner)
{
	ClipboardData *clipboard_data = user_data_or_owner;
	GdkAtom        targets[1];
	int            n_targets;

	targets[0] = gtk_selection_data_get_target (selection_data);
	n_targets = 1;

	if (gtk_targets_include_uri (targets, n_targets)) {
		gtk_selection_data_set_uris (selection_data, clipboard_data->uris);
	}
	else if (gtk_targets_include_text (targets, n_targets)) {
		char  *str;
		gsize  len;

		str = clipboard_data_convert_to_text (clipboard_data, FALSE, &len);
		gtk_selection_data_set_text (selection_data, str, len);
		g_free (str);
	}
	else if (gtk_selection_data_get_target (selection_data) == GNOME_COPIED_FILES) {
		char  *str;
		gsize  len;

		str = clipboard_data_convert_to_text (clipboard_data, TRUE, &len);
		gtk_selection_data_set (selection_data, GNOME_COPIED_FILES, 8, (guchar *) str, len);
		g_free (str);
	}
}
コード例 #11
0
ファイル: keywords.c プロジェクト: ealasu/darktable
static void _lib_keywords_drag_data_get_callback(GtkWidget *w,
    GdkDragContext *dctx,
    GtkSelectionData *data,
    guint info,
    guint time,
    gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_keywords_t *d = (dt_lib_keywords_t*)self->data;

  /* get iter of item to drag to ssetup drag data */
  GtkTreeIter iter;
  GtkTreeModel *model = NULL;
  GtkTreeSelection *s = gtk_tree_view_get_selection(d->view);

  if (gtk_tree_selection_get_selected(s,&model,&iter))
  {

    /* get tree path as string out of iter into selection data */
    GtkTreePath *path = NULL;
    path = gtk_tree_model_get_path(model,&iter);
    gchar *sp = gtk_tree_path_to_string(path);

    gtk_selection_data_set(data,data->target, 8, (const guchar *)sp, strlen(sp));
  }

}
コード例 #12
0
ファイル: clipbrd.cpp プロジェクト: HackLinux/chandler-1
static void
selection_handler( GtkWidget *WXUNUSED(widget),
                   GtkSelectionData *selection_data,
                   guint WXUNUSED(info),
                   guint WXUNUSED(time),
                   gpointer WXUNUSED(data) )
{
    if (!wxTheClipboard) return;

    if (!wxTheClipboard->m_data) return;

    wxDataObject *data = wxTheClipboard->m_data;

    wxDataFormat format( selection_data->target );

#ifdef __WXDEBUG__
    wxLogTrace(TRACE_CLIPBOARD,
               _T("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s"),
               format.GetId().c_str(),
               wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(),
               wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(),
               wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str()
               );
#endif
    
    if (!data->IsSupportedFormat( format )) return;

    int size = data->GetDataSize( format );

    if (size == 0) return;

    void *d = malloc(size);

    // Text data will be in UTF8 in Unicode mode.
    data->GetDataHere( selection_data->target, d );

#ifdef __WXGTK20__
    // NB: GTK+ requires special treatment of UTF8_STRING data, the text
    //     would show as UTF-8 data interpreted as latin1 (?) in other
    //     GTK+ apps if we used gtk_selection_data_set()
    if (format == wxDataFormat(wxDF_UNICODETEXT))
    {
        gtk_selection_data_set_text(
            selection_data,
            (const gchar*)d,
            size-1 );
    }
    else
#endif
    {
        gtk_selection_data_set(
            selection_data,
            GDK_SELECTION_TYPE_STRING,
            8*sizeof(gchar),
            (unsigned char*) d,
            size-1 );
    }

    free(d);
}
コード例 #13
0
static void tb_editor_drag_data_get_cb(GtkWidget *widget, GdkDragContext *context,
                                       GtkSelectionData *data, guint info, guint ltime,
                                       TBEditorWidget *tbw)
{
    GtkTreeIter iter;
    GtkTreeSelection *selection;
    GtkTreeModel *model;
    GdkAtom atom;
    gchar *name;

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
    if (! gtk_tree_selection_get_selected(selection, &model, &iter))
        return;

    gtk_tree_model_get(model, &iter, TB_EDITOR_COL_ACTION, &name, -1);
    if (name == NULL || *name == '\0')
    {
        g_free(name);
        return;
    }

    atom = gdk_atom_intern(tb_editor_dnd_targets[0].target, FALSE);
    gtk_selection_data_set(data, atom, 8, (guchar*) name, strlen(name));

    g_free(name);

    tbw->drag_source = widget;
}
コード例 #14
0
ファイル: nautilus-dnd.c プロジェクト: rn10950/FVWM95-Updated
/* Common function for drag_data_get_callback calls.
 * Returns FALSE if it doesn't handle drag data */
gboolean
nautilus_drag_drag_data_get (GtkWidget *widget,
			GdkDragContext *context,
			GtkSelectionData *selection_data,
			guint info,
			guint32 time,
			gpointer container_context,
			NautilusDragEachSelectedItemIterator each_selected_item_iterator)
{
	GString *result;
		
	switch (info) {
	case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
		result = g_string_new (NULL);
		(* each_selected_item_iterator) (add_one_gnome_icon, container_context, result);
		break;
		
	case NAUTILUS_ICON_DND_URI_LIST:
	case NAUTILUS_ICON_DND_TEXT:
		result = g_string_new (NULL);
		(* each_selected_item_iterator) (add_one_uri, container_context, result);
		break;

	default:
		return FALSE;
	}
	
	gtk_selection_data_set (selection_data,
				selection_data->target,
				8, result->str, result->len);

	return TRUE;
}
コード例 #15
0
ファイル: egg-toolbar-editor.c プロジェクト: GNOME/galeon
static void
drag_data_get_cb (GtkWidget          *widget,
		  GdkDragContext     *context,
		  GtkSelectionData   *selection_data,
		  guint               info,
		  guint32             time,
		  EggToolbarEditor   *editor)
{
  GtkAction *action;
  const char *target;

  action = GTK_ACTION (g_object_get_data (G_OBJECT (widget), "egg-action"));

  if (action)
    {
      target = gtk_action_get_name (action);
    }
  else
    {
      target = "separator";
    }

  gtk_selection_data_set (selection_data,
                          selection_data->target, 8,
                          (const guchar *)target, strlen (target));
}
コード例 #16
0
static void  
drag_data_get_cb (GtkWidget        *widget,
		  GdkDragContext   *context,
		  GtkSelectionData *selection_data,
		  guint             info,
		  guint             time,
		  Launcher         *launcher)
{
	char *location;
	
	g_return_if_fail (launcher != NULL);

	location = launcher->location;

	if (info == TARGET_URI_LIST) {
		char *uri[2];

		uri[0] = panel_launcher_get_uri (location);
		uri[1] = NULL;

		gtk_selection_data_set_uris (selection_data, uri);

		g_free (uri[0]);
	} else if (info == TARGET_ICON_INTERNAL)
		gtk_selection_data_set (selection_data,
					gtk_selection_data_get_target (selection_data), 8,
					(unsigned char *) location,
					strlen (location));

}
コード例 #17
0
ファイル: sql.c プロジェクト: abougouffa/mdbtools
static void 
gmdb_sql_dnd_dataget_cb(
    GtkWidget *w, GdkDragContext *dc,
    GtkSelectionData *selection_data, guint info, guint t,
    GladeXML *xml)
{
gchar tablename[256];
//gchar *tablename = "Orders";
gchar *name;
GtkTreeSelection *select;
GtkTreeStore *store;
GtkTreeView *tree;
GtkTreeIter iter2;

	tree = (GtkTreeView *) glade_xml_get_widget(xml, "sql_treeview");
	select = gtk_tree_view_get_selection(GTK_TREE_VIEW (tree));
	store = (GtkTreeStore *) gtk_tree_view_get_model(tree);
	gtk_tree_selection_get_selected (select, NULL, &iter2);
	gtk_tree_model_get (GTK_TREE_MODEL(store), &iter2, 0, &name, -1);

	strcpy(tablename,name);
	g_free(name);
	//strcpy(tablename, "Shippers");
	gtk_selection_data_set(
		selection_data,
		GDK_SELECTION_TYPE_STRING,
		8,  /* 8 bits per character. */
		(guchar*)tablename, strlen(tablename));
}
コード例 #18
0
ファイル: clipboard.c プロジェクト: Alexey-Yakovenko/deadbeef
static void
clipboard_get_clipboard_data (GtkClipboard *clip, GtkSelectionData *sel, guint info, gpointer user_data)
{
    clipboard_data_context_t *clip_ctx = (clipboard_data_context_t *)user_data;
    GdkAtom target = gtk_selection_data_get_target (sel);

    GString *uri_list = g_string_sized_new (clip_ctx->num_tracks * 256);
    guchar *buf = NULL;
    gint buf_len = 0;
    if (info == TARGET_SAMEWIDGET) {
        buf = (guchar *)clip_ctx;
        buf_len = sizeof (clipboard_data_context_t);
    }
    else if (info == GNOME_COPIED_FILES) {
        g_string_append (uri_list, clip_ctx->cut ? "cut\n" : "copy\n");
        clipboard_write_gnome_uri_list (clip_ctx, uri_list);
        buf = (guchar *)uri_list->str;
        buf_len = uri_list->len + 1;
    }
    else /* text/uri-list format */ {
        clipboard_write_uri_list (clip_ctx, uri_list);
        buf = (guchar *)uri_list->str;
        buf_len = uri_list->len + 1;
    }
    gtk_selection_data_set (sel, target, 8, buf, buf_len);
    g_string_free (uri_list, TRUE);
}
コード例 #19
0
ファイル: psppire-data-editor.c プロジェクト: RobertDash/pspp
static void
clipboard_get_cb (GtkClipboard     *clipboard,
		  GtkSelectionData *selection_data,
		  guint             info,
		  gpointer          data)
{
  GString *string = NULL;

  switch (info)
    {
    case SELECT_FMT_TEXT:
      string = clip_to_text ();
      break;
    case SELECT_FMT_HTML:
      string = clip_to_html ();
      break;
    default:
      g_assert_not_reached ();
    }

  gtk_selection_data_set (selection_data, selection_data->target,
			  8,
			  (const guchar *) string->str, string->len);

  g_string_free (string, TRUE);
}
コード例 #20
0
ファイル: info.c プロジェクト: thaidao/Workspace_Ex
static void info_window_dnd_data_set(GtkWidget *widget, GdkDragContext *context,
				     GtkSelectionData *selection_data, guint info,
				     guint time, gpointer data)
{
	InfoData *id = data;
	const gchar *path;

	path = image_get_path(id->image);
	if (path)
		{
		gchar *text;
		gint len;
		GList *list;
		gint plain_text;

		switch (info)
			{
			case TARGET_URI_LIST:
				plain_text = FALSE;
				break;
			case TARGET_TEXT_PLAIN:
			default:
				plain_text = TRUE;
				break;
			}
		list = g_list_append(NULL, (gchar *)path);
		text = uri_text_from_list(list, &len, plain_text);
		g_list_free(list);

		gtk_selection_data_set(selection_data, selection_data->target,
				       8, (guchar *)text, len);
		g_free(text);
		}
}
コード例 #21
0
static void
drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx,
  GtkSelectionData *data, guint info, guint time,
  AccountsWindow *dialog)
{
  if (data->target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE)) {
    GtkTreeRowReference *ref;
    GtkTreePath *source_row;
    GtkTreeIter iter;
    PurpleAccount *account = NULL;
    GValue val = {0};

    ref = g_object_get_data(G_OBJECT(ctx), "gtk-tree-view-source-row");
    source_row = gtk_tree_row_reference_get_path(ref);

    if (source_row == NULL) return; 

    gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, source_row);
    gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter,
      COLUMN_DATA, &val);

    dialog->drag_iter = iter;

    account = g_value_get_pointer(&val);

    gtk_selection_data_set(data, gdk_atom_intern("PURPLE_ACCOUNT", FALSE),
      8, (void *)&account, sizeof(account));

    gtk_tree_path_free(source_row);
  }
}
コード例 #22
0
ファイル: nemo-location-bar.c プロジェクト: mtwebster/nemo
static void
drag_data_get_callback (GtkWidget *widget,
		  	GdkDragContext *context,
		  	GtkSelectionData *selection_data,
		  	guint info,
		 	guint32 time,
			gpointer callback_data)
{
	NemoLocationBar *self;
	GFile *location;
	gchar *uri;

	g_assert (selection_data != NULL);
	self = callback_data;

	location = nemo_location_bar_get_location (self);
	uri = g_file_get_uri (location);

	switch (info) {
	case NEMO_DND_URI_LIST:
	case NEMO_DND_TEXT_PLAIN:
		gtk_selection_data_set (selection_data,
					gtk_selection_data_get_target (selection_data),
					8, (guchar *) uri,
					strlen (uri));
		break;
	default:
		g_assert_not_reached ();
	}
	g_free (uri);
	g_object_unref (location);
}
コード例 #23
0
static void
drag_data_get_callback (GtkWidget *widget,
		  	GdkDragContext *context,
		  	GtkSelectionData *selection_data,
		  	guint info,
		 	guint32 time,
			gpointer callback_data)
{
	AthenaLocationBar *self;
	char *entry_text;

	g_assert (selection_data != NULL);
	self = callback_data;

	entry_text = athena_location_bar_get_location (self);

	switch (info) {
	case ATHENA_DND_URI_LIST:
	case ATHENA_DND_TEXT_PLAIN:
		gtk_selection_data_set (selection_data,
					gtk_selection_data_get_target (selection_data),
					8, (guchar *) entry_text,
					strlen (entry_text));
		break;
	default:
		g_assert_not_reached ();
	}
	g_free (entry_text);
}
コード例 #24
0
static void
drag_data_get_cb (GtkWidget          *widget,
		  GdkDragContext     *context,
		  GtkSelectionData   *selection_data,
		  guint               info,
		  guint32             time,
		  EggEditableToolbar *etoolbar)
{
  EggToolbarsModel *model;
  const char *name;
  char *data;

  g_return_if_fail (EGG_IS_EDITABLE_TOOLBAR (etoolbar));
  model = egg_editable_toolbar_get_model (etoolbar);

  name = g_object_get_data (G_OBJECT (widget), EGG_ITEM_NAME);
  if (name == NULL)
    {
      name = g_object_get_data (G_OBJECT (gtk_widget_get_parent (widget)), EGG_ITEM_NAME);
      g_return_if_fail (name != NULL);
    }

  data = egg_toolbars_model_get_data (model, gtk_selection_data_get_target (selection_data), name);
  if (data != NULL)
    {
      gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (unsigned char *)data, strlen (data));
      g_free (data);
    }
}
コード例 #25
0
ファイル: mimeview.c プロジェクト: moreorless/claws-mail
static void mimeview_drag_data_get(GtkWidget	    *widget,
				   GdkDragContext   *drag_context,
				   GtkSelectionData *selection_data,
				   guint	     info,
				   guint	     time,
				   MimeView	    *mimeview)
{
	gchar *filename, *uriname;
	MimeInfo *partinfo;

	if (!mimeview->opened) return;
	if (!mimeview->file) return;

	partinfo = mimeview_get_selected_part(mimeview);
	if (!partinfo) return;

	filename = g_basename(get_part_name(partinfo));
	if (*filename == '\0') return;

	filename = g_strconcat(get_mime_tmp_dir(), G_DIR_SEPARATOR_S,
			       filename, NULL);

	if (procmime_get_part(filename, partinfo) < 0)
		alertpanel_error
			(_("Can't save the part of multipart message."));

	uriname = g_strconcat("file://", filename, NULL);
	gtk_selection_data_set(selection_data, selection_data->target, 8,
			       uriname, strlen(uriname));

	g_free(uriname);
	g_free(filename);
}
コード例 #26
0
ファイル: testselection.c プロジェクト: Aridna/gtk2
void
selection_get (GtkWidget *widget, 
	       GtkSelectionData *selection_data,
	       guint      info,
	       guint      time,
	       gpointer   data)
{
  guchar *buffer;
  gint len;
  GdkAtom type = GDK_NONE;

  if (!selection_string)
    {
      buffer = NULL;
      len = 0;
    }      
  else
    {
      buffer = (guchar *)selection_string->str;
      len = selection_string->len;
    }

  switch (info)
    {
    case COMPOUND_TEXT:
    case TEXT:
      type = seltypes[COMPOUND_TEXT];
    case STRING:
      type = seltypes[STRING];
    }
  
  gtk_selection_data_set (selection_data, type, 8, buffer, len);
}
コード例 #27
0
ファイル: gtkselection.c プロジェクト: sam-m888/gtk
static gboolean
selection_set_compound_text (GtkSelectionData *selection_data,
			     const gchar      *str,
			     gint              len)
{
  gboolean result = FALSE;

#ifdef GDK_WINDOWING_X11
  gchar *tmp;
  guchar *text;
  GdkAtom encoding;
  gint format;
  gint new_length;

  if (GDK_IS_X11_DISPLAY (selection_data->display))
    {
      tmp = g_strndup (str, len);
      if (gdk_x11_display_utf8_to_compound_text (selection_data->display, tmp,
                                                 &encoding, &format, &text, &new_length))
        {
          gtk_selection_data_set (selection_data, encoding, format, text, new_length);
          gdk_x11_free_compound_text (text);

          result = TRUE;
        }
      g_free (tmp);
    }
#endif

  return result;
}
コード例 #28
0
ファイル: fileview.c プロジェクト: dimkr/emelfm
/* This is called automatically when a drag is initiated 
 * It build a URI list of the selected filenames to set as the drag data
 */
static void
clist_drag_data_get(GtkWidget            *widget,
                    GdkDragContext       *context,
                    GtkSelectionData     *data,
                    guint                info_arg,
                    guint                time,
                    FileView             *view)
{
  FileInfo *info;
  GList *base, *tmp;
  GString *uri_list = g_string_sized_new(PATH_MAX);

  disable_refresh();
  base = tmp = get_selection(view);
  
  for (; tmp != NULL; tmp = tmp->next)
  {
    info = tmp->data;
    g_string_sprintfa(uri_list, "file:%s/%s\r\n", view->dir, info->filename);
  }

  gtk_selection_data_set(data, data->target, 8, uri_list->str, uri_list->len);
  g_string_free(uri_list, TRUE);
  g_list_free(base);
  reenable_refresh();
}
コード例 #29
0
ファイル: fm-dnd-src.c プロジェクト: gilir/libfm-debian
static void
on_drag_data_get ( GtkWidget *src_widget,
				   GdkDragContext *drag_context,
				   GtkSelectionData *sel_data,
				   guint info,
				   guint time,
				   FmDndSrc* ds )
{
    GdkAtom type;

    /*  Don't call the default handler  */
    g_signal_stop_emission_by_name( src_widget, "drag-data-get" );
    drag_context->actions = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;

	type = gdk_atom_intern_static_string(fm_default_dnd_src_targets[info].target);
	switch( info )
	{
	case FM_DND_SRC_TARGET_FM_LIST:
		/* just store the pointer in GtkSelection since this is used 
		 * within the same app. */
		gtk_selection_data_set(sel_data, type, 8,
								&ds->files, sizeof(gpointer));
		break;
	case FM_DND_SRC_TARGET_URI_LIST:
		{
			gchar* uri;
			GString* uri_list = g_string_sized_new( 8192 );
			GList* l;
			FmFileInfo* file;
			char* full_path;

			for( l = fm_list_peek_head_link(ds->files); l; l=l->next )
			{
				file = (FmFileInfo*)l->data;
				uri = fm_path_to_uri(file->path);
				g_string_append( uri_list, uri );
				g_free( uri );
				g_string_append( uri_list, "\r\n" );
			}
			gtk_selection_data_set ( sel_data, type, 8,
									 ( guchar* ) uri_list->str, uri_list->len + 1 );
			g_string_free( uri_list, TRUE );
		}
		break;
	}
}
コード例 #30
0
static void set_jstring_data(GtkSelectionData *selection_data, GdkAtom target, jstring data)
{
    const char *text_data = mainEnv->GetStringUTFChars(data, NULL);
    guint ntext_data = strlen(text_data);

    //XXX is target == type ??
    gtk_selection_data_set(selection_data, target, 8, (const guchar *)text_data, ntext_data);
    mainEnv->ReleaseStringUTFChars(data, text_data);
}