clipboard.cpp revision a9b0c8611f97a0f6bac849cf537e0cf8e37cec1b
/**
* @file
* System-wide clipboard management - implementation.
*/
/* Authors:
* Krzysztof Kosiński <tweenk@o2.pl>
* Jon A. Cruz <jon@joncruz.org>
* Incorporates some code from selection-chemistry.cpp, see that file for more credits.
* Abhishek Sharma
* Tavmjong Bah
*
* Copyright (C) 2008 authors
* Copyright (C) 2010 Jon A. Cruz
* Copyright (C) 2012 Tavmjong Bah (Symbol additions)
*
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* See the file COPYING for details.
*/
#include <gtkmm/clipboard.h>
#include "ui/clipboard.h"
// TODO: reduce header bloat if possible
#include "file.h" // for file_import, used in _pasteImage
#include <list>
#include <algorithm>
#include "gc-core.h"
#include "inkscape.h"
#include "io/stringstream.h"
#include "desktop.h"
#include "desktop-style.h" // for sp_desktop_set_style, used in _pasteStyle
#include "document.h"
#include "document-private.h"
#include "selection.h"
#include "message-stack.h"
#include "context-fns.h"
#include "ui/tools/dropper-tool.h" // used in copy()
#include "style.h"
#include "selection-chemistry.h"
#include "box3d.h"
#include "gradient-drag.h"
#include "sp-marker.h"
#include "sp-item.h"
#include "sp-item-transform.h" // for sp_item_scale_rel, used in _pasteSize
#include "sp-path.h"
#include "sp-pattern.h"
#include "sp-shape.h"
#include "sp-gradient.h"
#include "sp-gradient-reference.h"
#include "sp-linear-gradient.h"
#include "sp-radial-gradient.h"
#include "sp-clippath.h"
#include "sp-mask.h"
#include "sp-textpath.h"
#include "sp-rect.h"
#include "sp-use.h"
#include "sp-symbol.h"
#include "live_effects/lpeobject.h"
#include "live_effects/lpeobject-reference.h"
#include "live_effects/parameter/path.h"
#include "svg/css-ostringstream.h" // used in copy
#include "ui/tools/text-tool.h"
#include "text-editing.h"
#include "ui/tools-switch.h"
#include "path-chemistry.h"
#include "helper/png-write.h"
#include "svg/svg-color.h"
#include "sp-namedview.h"
#include "snap.h"
#include "persp3d.h"
#include "preferences.h"
/// Made up mimetype to represent Gdk::Pixbuf clipboard contents.
#define CLIPBOARD_GDK_PIXBUF_TARGET "image/x-gdk-pixbuf"
#define CLIPBOARD_TEXT_TARGET "text/plain"
#ifdef WIN32
#include <windows.h>
#endif
namespace Inkscape {
namespace UI {
/**
* Default implementation of the clipboard manager.
*/
class ClipboardManagerImpl : public ClipboardManager {
public:
virtual const gchar *getFirstObjectID();
private:
void _copyUsedDefs(SPItem *);
void _copyGradient(SPGradient *);
void _copyPattern(SPPattern *);
void _copyTextPath(SPTextPath *);
Inkscape::XML::Node *_copyNode(Inkscape::XML::Node *, Inkscape::XML::Document *, Inkscape::XML::Node *);
// clipboard callbacks
void _onClear();
// various helpers
void _createInternalClipboard();
void _discardInternalClipboard();
Geom::Scale _getScale(SPDesktop *desktop, Geom::Point const &min, Geom::Point const &max, Geom::Rect const &obj_rect, bool apply_x, bool apply_y);
void _setClipboardTargets();
void _setClipboardColor(guint32);
// private properites
// we need a way to copy plain text AND remember its style;
// the standard _clipnode is only available in an SVG tree, hence this special storage
};
: _clipboardSPDoc(NULL),
{
// Clipboard Formats: http://msdn.microsoft.com/en-us/library/ms649013(VS.85).aspx
// push supported clipboard targets, in order of preference
}
/**
* Copy selection contents to the clipboard.
*/
{
return;
}
// Special case for when the gradient dragger is active - copies gradient color
if (drag->hasSelection()) {
// set the color as clipboard content (text in RRGGBBAA format)
// create a style with this color on fill and opacity in master opacity, so it can be
// pasted on other stops or objects
if (_text_style) {
_text_style = NULL;
}
// print and set properties
if (opacity > 1.0) {
}
return;
}
}
// Special case for when the color picker ("dropper") is active - copies color under cursor
//_setClipboardColor(sp_dropper_context_get_color(desktop->event_context));
return;
}
// Special case for when the text tool is active - if some text is selected, copy plain text,
// not the object that holds it; also copy the style at cursor into
Glib::ustring selected_text = Inkscape::UI::Tools::sp_text_get_selected_text(desktop->event_context);
if (_text_style) {
_text_style = NULL;
}
return;
}
return;
}
_createInternalClipboard(); // construct a new clipboard document
}
/**
* Copy a Live Path Effect path parameter to the clipboard.
* @param pp The path parameter to store in the clipboard.
*/
{
return;
}
return;
}
}
/**
* Copy a symbol from the symbol dialog.
* @param symbol The Inkscape::XML::Node for the symbol.
*/
void ClipboardManagerImpl::copySymbol(Inkscape::XML::Node* symbol, gchar const* style, bool user_symbol)
{
//std::cout << "ClipboardManagerImpl::copySymbol" << std::endl;
return;
}
// We add "_duplicate" to have a well defined symbol name that
// bypasses the "prevent_id_classes" routine. We'll get rid of it
// when we paste.
symbol_name += "_inkscape_duplicate";
scale_units = Inkscape::Util::Quantity::convert(1, "px", nv_repr->attribute("inkscape:document-units"));
false);
}
}
// Set a default style in <use> rather than <symbol> so it can be changed.
}
// This min and max sets offsets, we don't have any so set to zero.
}
/**
* Paste from the system clipboard into the active desktop.
* @param in_place Whether to put the contents where they were when copied.
*/
{
// do any checking whether we really are able to paste before requesting the contents
return false;
}
return false;
}
// Special cases of clipboard content handling go here
// Note that target priority is determined in _getBestTarget.
// TODO: Handle x-special/gnome-copied-files and text/uri-list to support pasting files
// if there is an image on the clipboard, paste it
if ( target == CLIPBOARD_GDK_PIXBUF_TARGET ) {
}
// if there's only text, paste it into a selected text object or create a new one
if ( target == CLIPBOARD_TEXT_TARGET ) {
return _pasteText(desktop);
}
// otherwise, use the import extensions
return false;
}
return true;
}
/**
* Returns the id of the first visible copied object.
*/
{
return NULL;
}
if (!root) {
return NULL;
}
) {
}
if (ch) {
}
return NULL;
}
/**
* Implements the Paste Style action.
*/
{
return false;
}
// check whether something is selected
return false;
}
// no document, but we can try _text_style
if (_text_style) {
return true;
} else {
return false;
}
}
bool pasted = false;
if (clipnode) {
pasted = true;
}
else {
}
return pasted;
}
/**
* Resize the selection or each object in the selection to match the clipboard's size.
* @param separately Whether to scale each object in the selection separately
* @param apply_x Whether to scale the width of objects / selection
* @param apply_y Whether to scale the height of objects / selection
*/
bool ClipboardManagerImpl::pasteSize(SPDesktop *desktop, bool separately, bool apply_x, bool apply_y)
{
return false; // pointless parameters
}
return false;
}
return false;
}
// FIXME: actually, this should accept arbitrary documents
return false;
}
// retrieve size ifomration from the clipboard
bool pasted = false;
if (clipnode) {
// resize each object in the selection
if (separately) {
if (item) {
if ( obj_size ) {
}
} else {
}
}
}
// resize the selection as a whole
else {
if ( sel_size ) {
}
}
pasted = true;
}
return pasted;
}
/**
* Applies a path effect from the clipboard to the selected path.
*/
{
/** @todo FIXME: pastePathEffect crashes when moving the path with the applied effect,
segfaulting in fork_private_if_necessary(). */
return false;
}
return false;
}
if ( tempdoc ) {
if ( clipnode ) {
if ( effectstack ) {
// make sure all selected items are converted to paths first (i.e. rectangles)
for (GSList *itemptr = const_cast<GSList *>(selection->itemList()) ; itemptr ; itemptr = itemptr->next) {
}
return true;
}
}
}
// no_effect:
return false;
}
/**
* Get LPE path data from the clipboard.
* @return The retrieved path data (contents of the d attribute), or "" if no path was found
*/
{
return "";
}
return "";
}
return svgd;
}
/**
* Get object id of a shape or text item from the clipboard.
* @return The retrieved id string (contents of the id attribute), or "" if no shape or text item was found.
*/
{
// basically, when we do a depth-first search, we're stopping
// at the first object to be <svg:path> or <svg:text>.
// but that could then return the id of the object's
// clip path or mask, not the original path!
return "";
}
// 1293979: strip out the defs of the document
}
return "";
}
return svgd;
}
/**
* Iterate over a list of items and copy them to the clipboard.
*/
{
// copy the defs used by all items
if (item) {
} else {
}
}
// copy the representation of the items
if (item) {
// copy complete inherited style
// write the complete accumulated transform passed to us
// (we're dealing with unattached representations, so we write to their attributes
// instead of using sp_item_set_transform)
}
}
// copy style for Paste Style action
if (sorted_items) {
if (item) {
}
// copy path effect from the first path
if (object) {
if (effect) {
}
}
}
if (size) {
}
}
/**
* Recursively copy all the definitions used by a given item to the clipboard defs.
*/
{
// copy fill and stroke styles (patterns and gradients)
}
if ( pattern ) {
}
}
}
if ( pattern ) {
}
}
// For shapes, copy all of the shape's markers
if (shape) {
for (int i = 0 ; i < SP_MARKER_LOC_QTY ; i++) {
}
}
}
// For lpe items, copy lpe stack if applicable
if (lpeitem) {
if (lpeitem->hasPathEffect()) {
for (PathEffectList::iterator it = lpeitem->path_effect_list->begin(); it != lpeitem->path_effect_list->end(); ++it)
{
if (lpeobj) {
}
}
}
}
// For 3D boxes, copy perspectives
{
if (box) {
}
}
// Copy text paths
{
if (textpath) {
}
}
// Copy clipping objects
}
}
// Copy mask objects
// recurse into the mask for its gradients etc.
if (childItem) {
}
}
}
}
// Copy filters
}
}
// recurse
if (childItem) {
}
}
}
/**
* Copy a single gradient to the clipboard's defs element.
*/
{
while (gradient) {
// climb up the refs, copying each one in the chain
}
else {
}
}
}
/**
* Copy a single pattern to the clipboard document's defs element.
*/
{
// climb up the references, copying each one in the chain
while (pattern) {
// items in the pattern may also use gradients and other patterns, so recurse
if (childItem) {
}
}
}
else{
}
}
}
/**
* Copy a text path to the clipboard's defs element.
*/
{
if (!path) {
return;
}
// Do not copy the text path to defs if it's already copied
return;
}
}
/**
* Copy a single XML node from one document to another.
* @param node The node to be copied
* @param target_doc The document to which the node is to be copied
* @param parent The node in the target document which will become the parent of the copied node
* @return Pointer to the copied node
*/
Inkscape::XML::Node *ClipboardManagerImpl::_copyNode(Inkscape::XML::Node *node, Inkscape::XML::Document *target_doc, Inkscape::XML::Node *parent)
{
return dup;
}
/**
* Retrieve a bitmap image from the clipboard and paste it into the active document.
*/
{
return false;
}
// retrieve image data
if (!img) {
return false;
}
// TODO unify with interface.cpp's sp_ui_drag_data_received()
// AARGH stupid
++i;
}
return true;
}
/**
* Paste text into the selected text object or create a new one to hold it.
*/
{
return false;
}
// if the text editing tool is active, paste the text into the active text object
}
// try to parse the text as a color and, if successful, apply it as the current style
if (css) {
return true;
}
return false;
}
/**
* Applies a pasted path effect to a given item.
*/
{
return;
}
return;
}
if (lpeitem)
{
// for each effect in the stack, check if we need to fork it before adding it to the item
{
if (!obj) {
return;
}
}
}
}
/**
* Retrieve the clipboard contents as a document.
* @return Clipboard contents converted to SPDocument, or NULL if no suitable content was present
*/
{
if ( required_target == "" ) {
} else {
}
if ( best_target == "" ) {
return NULL;
}
// FIXME: Temporary hack until we add memory input.
// Save the clipboard contents to some file, then read it
bool file_saved = false;
#ifdef WIN32
{ // Try to save clipboard data as en emf file (using win32 api)
if (OpenClipboard(NULL)) {
if (hglb) {
if (hemf) {
file_saved = true;
}
}
}
}
#endif
if (!file_saved) {
return NULL;
}
// doing this synchronously makes better sense
// TODO: use another method because this one is badly broken imo.
// from documentation: "Returns: A SelectionData object, which will be invalid if retrieving the given target failed."
// I don't know how to check whether an object is 'valid' or not, unusable if that's not possible...
target = sel.get_target(); // this can crash if the result was invalid of last function. No way to check for this :(
// FIXME: Temporary hack until we add memory input.
// Save the clipboard contents to some file, then read it
}
// there is no specific plain SVG input extension, so if we can paste the Inkscape SVG format,
if (target == "image/x-inkscape-svg") {
}
// Use the EMF extension to import metafiles
}
};
return NULL; // this shouldn't happen unless _getBestTarget returns something bogus
}
try {
} catch (...) {
}
return tempdoc;
}
/**
* Callback called when some other application requests data from Inkscape.
*
* Finds a suitable output extension to save the internal clipboard document,
* then saves it to memory and sets the clipboard contents.
*/
{
if (target == "") {
return; // this shouldn't happen
}
if (target == CLIPBOARD_TEXT_TARGET) {
target = "image/x-inkscape-svg";
}
};
return; // this also shouldn't happen
}
// FIXME: Temporary hack until we add support for memory output.
// Save to a temporary file, read it back and then set the clipboard contents
try {
{
Geom::Point origin (_clipboardSPDoc->getRoot()->x.computed, _clipboardSPDoc->getRoot()->y.computed);
unsigned long int width = (unsigned long int) (Inkscape::Util::Quantity::convert(area.width(), "px", "in") * dpi + 0.5);
unsigned long int height = (unsigned long int) (Inkscape::Util::Quantity::convert(area.height(), "in", "px") * dpi + 0.5);
// read from namedview
}
double opacity = 1.0;
}
sp_export_png_file(_clipboardSPDoc, filename, area, width, height, dpi, dpi, bgcolor, NULL, NULL, true, NULL);
}
else
{
// Need to load the extension.
}
}
} catch (...) {
}
}
/**
* Callback when someone else takes the clipboard.
*
* When the clipboard owner changes, this callback clears the internal clipboard document
* to reduce memory usage.
*/
void ClipboardManagerImpl::_onClear()
{
// why is this called before _onGet???
//_discardInternalClipboard();
}
/**
* Creates an internal clipboard document from scratch.
*/
{
if ( _clipboardSPDoc == NULL ) {
//g_assert( _clipboardSPDoc != NULL );
// once we create a SVG document, style will be stored in it, so flush _text_style
if (_text_style) {
_text_style = NULL;
}
}
}
/**
* Deletes the internal clipboard document.
*/
{
if ( _clipboardSPDoc != NULL ) {
}
}
/**
* Get the scale to resize an item, based on the command and desktop state.
*/
Geom::Scale ClipboardManagerImpl::_getScale(SPDesktop *desktop, Geom::Point const &min, Geom::Point const &max, Geom::Rect const &obj_rect, bool apply_x, bool apply_y)
{
double scale_x = 1.0;
double scale_y = 1.0;
if (apply_x) {
}
if (apply_y) {
}
// If the "lock aspect ratio" button is pressed and we paste only a single coordinate,
// resize the second one by the same ratio too
}
}
}
}
/**
* Find the most suitable clipboard target.
*/
{
// GTKmm's wait_for_targets() is broken, see the comment in _inkscape_wait_for_targets()
// clipboard target debugging snippet
/*
g_message("Begin clipboard targets");
for ( std::list<Glib::ustring>::iterator x = targets.begin() ; x != targets.end(); ++x )
g_message("Clipboard target: %s", (*x).data());
g_message("End clipboard targets\n");
//*/
i != _preferred_targets.end() ; ++i)
{
return *i;
}
}
#ifdef WIN32
if (OpenClipboard(NULL))
{ // If both bitmap and metafile are present, pick the one that was exported first.
while (format) {
break;
}
}
if (format == CF_ENHMETAFILE) {
return "CF_ENHMETAFILE";
}
return CLIPBOARD_GDK_PIXBUF_TARGET;
}
}
return "CF_ENHMETAFILE";
}
#endif
if (_clipboard->wait_is_image_available()) {
return CLIPBOARD_GDK_PIXBUF_TARGET;
}
if (_clipboard->wait_is_text_available()) {
return CLIPBOARD_TEXT_TARGET;
}
return "";
}
/**
* Set the clipboard targets to reflect the mimetypes Inkscape can output.
*/
{
#if WITH_GTKMM_3_0
#else
#endif
bool plaintextSet = false;
for (Inkscape::Extension::DB::OutputList::const_iterator out = outlist.begin() ; out != outlist.end() ; ++out) {
if ( !(*out)->deactivated() ) {
if (mime != CLIPBOARD_TEXT_TARGET) {
plaintextSet = true;
}
}
}
}
// Add PNG export explicitly since there is no extension for this...
#ifdef WIN32
// is presented as a CF_BITMAP) this code would not be needed.. ???
// Or maybe there is some other way to achieve the same?
// Note: Metafile is the only format that is rendered and stored in clipboard
// on Copy, all other formats are rendered only when needed by a Paste command.
// FIXME: This should at least be rewritten to use "delayed rendering".
// If possible make it delayed rendering by using GTK API only.
if (OpenClipboard(NULL)) {
if ( _clipboardSPDoc != NULL ) {
}
// FIXME: Temporary hack until we add support for memory output.
// Save to a temporary file, read it back and then set the clipboard contents
try {
if (hemf) {
}
} catch (...) {
}
}
}
}
#endif
}
/**
* Set the string representation of a 32-bit RGBA color as the clipboard contents.
*/
{
}
/**
* Put a notification on the mesage stack.
*/
{
}
// GTKMM's clipboard::wait_for_targets is buggy and might return bogus, see
//
//
// for details. Until this has been fixed upstream we will use our own implementation
// of this method, as copied from /gtkmm-2.16.0/gtk/gtkmm/clipboard.cc.
{
//Get a newly-allocated array of atoms:
gboolean test = gtk_clipboard_wait_for_targets( gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), &targets, &n_targets );
return;
}
//Add the targets to the C++ container:
for (int i = 0; i < n_targets; i++)
{
//Convert the atom to a string:
if (atom_name) {
}
}
}
/* #######################################
ClipboardManager class
####################################### */
ClipboardManager::~ClipboardManager() {}
{
_instance = new ClipboardManagerImpl;
}
return _instance;
}
} // namespace Inkscape
} // namespace IO
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :