clipboard.cpp revision dda97aeba7480d08320ebceecae13b8531db1b81
/** @file
* @brief System-wide clipboard management - implementation
*/
/* Authors:
* Krzysztof Kosiński <tweenk@o2.pl>
* Incorporates some code from selection-chemistry.cpp, see that file for more credits.
*
* Copyright (C) 2008 authors
*
* 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 "ui/clipboard.h"
// TODO: reduce header bloat if possible
#include <list>
#include <algorithm>
#include <gtkmm/clipboard.h>
#include "gc-core.h"
#include "inkscape.h"
#include "io/stringstream.h"
#include "desktop.h"
#include "desktop-handles.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 "dropper-context.h" // used in copy()
#include "style.h"
#include "selection-chemistry.h"
#include "box3d.h"
#include "gradient-drag.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-gradient-fns.h"
#include "sp-linear-gradient-fns.h"
#include "sp-radial-gradient-fns.h"
#include "sp-clippath.h"
#include "sp-mask.h"
#include "sp-textpath.h"
#include "sp-rect.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 _parseColor
#include "file.h" // for file_import, used in _pasteImage
#include "prefs-utils.h" // for prefs_get_string_attribute, used in _pasteImage
#include "text-context.h"
#include "text-editing.h"
#include "tools-switch.h"
#include "libnr/n-art-bpath-2geom.h"
#include "path-chemistry.h"
/// @brief Made up mimetype to represent Gdk::Pixbuf clipboard contents
#define CLIPBOARD_GDK_PIXBUF_TARGET "image/x-gdk-pixbuf"
#define CLIPBOARD_TEXT_TARGET "text/plain"
namespace Inkscape {
namespace UI {
/**
* @brief Default implementation of the clipboard manager
*/
class ClipboardManagerImpl : public ClipboardManager {
public:
virtual void copy();
virtual bool pasteStyle();
virtual bool pasteSize(bool, bool, bool);
virtual bool pastePathEffect();
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 *);
void _pasteDefs(SPDocument *);
bool _pasteImage();
bool _pasteText();
// clipboard callbacks
void _onClear();
// various helpers
void _createInternalClipboard();
void _discardInternalClipboard();
void _setClipboardTargets();
void _setClipboardColor(guint32);
// private properites
};
: _clipboardSPDoc(NULL),
{
// push supported clipboard targets, in order of preference
#ifdef WIN32
#endif
}
/**
* @brief Copy selection contents to the clipboard
*/
void ClipboardManagerImpl::copy()
{
// Special case for when the gradient dragger is active - copies gradient color
if (drag->hasSelection()) {
return;
}
}
// Special case for when the color picker ("dropper") is active - copies color under cursor
return;
}
// Special case for when the text tool is active - if some text is selected, copy plain text,
// not the object that holds it
if (!selected_text.empty()) {
return;
}
}
return;
}
_createInternalClipboard(); // construct a new clipboard document
}
/**
* @brief Copy a Live Path Effect path parameter to the clipboard
* @param pp The path parameter to store in the clipboard
*/
{
}
/**
* @brief 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
// Special cases of clipboard content handling go here 00ff00
// 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 there's only text, paste it into a selected text object or create a new one
// otherwise, use the import extensions
return false;
}
return true;
}
/**
* @brief Implements the Paste Style action
*/
bool ClipboardManagerImpl::pasteStyle()
{
// check whether something is selected
return false;
}
return false;
}
bool pasted = false;
if (clipnode) {
pasted = true;
}
else {
}
return pasted;
}
/**
* @brief 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
*/
{
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) {
}
}
// resize the selection as a whole
else {
}
}
pasted = true;
}
return pasted;
}
/**
* @brief Applies a path effect from the clipboard to the selected path
*/
bool ClipboardManagerImpl::pastePathEffect()
{
/** @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 ( effect ) {
// make sure all selected items are converted to paths first (i.e. rectangles)
sp_selected_path_to_curves(false);
}
return true;
}
}
}
// no_effect:
return false;
}
/**
* @brief 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;
}
/**
* @brief 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
*/
{
return "";
}
return "";
}
return svgd;
}
/**
* @brief Iterate over a list of items and copy them to the clipboard.
*/
{
// copy the defs used by all items
}
// copy the representation of the items
if (!SP_IS_ITEM(i->data)) continue;
// 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) {
}
// copy path effect from the first path
if (effect) {
}
}
}
if (size) {
}
}
/**
* @brief Recursively copy all the definitions used by a given item to the clipboard defs
*/
{
// copy fill and stroke styles (patterns and gradients)
if (SP_IS_PATTERN(server))
}
if (SP_IS_PATTERN(server))
}
// For shapes, copy all of the shape's markers
if (SP_IS_SHAPE(item)) {
for (int i = 0 ; i < SP_MARKER_LOC_QTY ; i++) {
}
}
}
// For lpe items, copy liveeffect if applicable
// TODO: copy the whole effect stack. now it only copies current selected effect
if (SP_IS_LPE_ITEM(item)) {
if (sp_lpe_item_has_path_effect(lpeitem)) {
Inkscape::LivePathEffect::LPEObjectReference* lperef = sp_lpe_item_get_current_lpereference(lpeitem);
}
}
}
// For 3D boxes, copy perspectives
if (SP_IS_BOX3D(item)) {
}
// Copy text paths
if (SP_IS_TEXT_TEXTPATH(item)) {
}
// Copy clipping objects
}
// Copy mask objects
// recurse into the mask for its gradients etc.
if (SP_IS_ITEM(o))
_copyUsedDefs(SP_ITEM(o));
}
}
// Copy filters
if (SP_IS_FILTER(filter)) {
}
}
// recurse
if (SP_IS_ITEM(o))
_copyUsedDefs(SP_ITEM(o));
}
}
/**
* @brief Copy a single gradient to the clipboard's defs element
*/
{
while (gradient) {
// climb up the refs, copying each one in the chain
}
}
/**
* @brief 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
for (SPObject *child = sp_object_first_child(SP_OBJECT(pattern)) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
if (!SP_IS_ITEM (child)) continue;
}
}
}
/**
* @brief 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
}
/**
* @brief 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;
}
/**
* @brief Paste the contents of a document into the active desktop
* @param clipdoc The document to paste
* @param in_place Whether to paste the selection where it was when copied
* @pre @c clipdoc is not empty and items can be added to the current layer
*/
{
// copy definitions
// copy objects
// Don't copy metadata, defs, named views and internal clipboard contents to the document
}
// move the selection to the right position
if(in_place)
{
if (clipnode) {
// this formula was discovered empyrically
}
}
// copied from former sp_selection_paste in selection-chemistry.cpp
else {
if (sel_size) {
}
}
}
/**
* @brief Paste SVG defs from the document retrieved from the clipboard into the active document
* @param clipdoc The document to paste
* @pre @c clipdoc != NULL and pasting into the active document is possible
*/
{
// boilerplate vars copied from _pasteDocument
/// @todo TODO: implement def id collision resolution in ClipboardManagerImpl::_pasteDefs()
/*
// simplistic solution: when a collision occurs, add "a" to id until it's unique
Glib::ustring pasted_id = def->attribute("id");
if ( pasted_id.empty() ) continue; // defs without id are useless
Glib::ustring pasted_id_original = pasted_id;
while(sp_repr_lookup_child(target_defs, "id", pasted_id.data())) {
pasted_id.append("a");
}
if ( pasted_id != pasted_id_original ) {
def->setAttribute("id", pasted_id.data());
// Update the id in the rest of the document so there are no dangling references
// How to do that?
_changeIdReferences(clipdoc, pasted_id_original, pasted_id);
}
*/
continue; // skip duplicate defs - temporary non-solution
}
}
/**
* @brief Retrieve a bitmap image from the clipboard and paste it into the active document
*/
bool ClipboardManagerImpl::_pasteImage()
{
// retrieve image data
if (!img) return false;
// Very stupid hack: Write into a file, then import the file into the document.
// To avoid using tmpfile and POSIX file handles, make the filename based on current time.
// This wasn't my idea, I just copied this from selection-chemistry.cpp
// and just can't think of something saner at the moment. Pasting more than
// one image per second will overwrite the image.
// However, I don't think anyone is able to copy a _different_ image into inkscape
// in 1 second.
char image_filename[128];
gchar const *save_folder;
return true;
}
/**
* @brief Paste text into the selected text object or create a new one to hold it
*/
bool ClipboardManagerImpl::_pasteText()
{
// 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;
}
/**
* @brief Attempt to parse the passed string as a hexadecimal RGB or RGBA color
* @param text The Glib::ustring to parse
* @return New CSS style representation if the parsing was successful, NULL otherwise
*/
{
bool attempt_alpha = false;
// those conditionals guard against parsing e.g. the string "fab" as "fab000"
// (incomplete color) and "45fab71" as "45fab710" (incomplete alpha)
if ( *str == '#' ) {
} else {
}
// skip a leading #, if present
// try to parse first 6 digits
if (attempt_alpha) {// try to parse alpha if there's enough characters
}
// print and set properties
return color_css;
}
return NULL;
}
/**
* @brief Applies a pasted path effect to a given item
*/
{
if ( SP_IS_RECT(item) ) return;
if (SP_IS_LPE_ITEM(item))
{
if (!obj) return;
// if the effect is not used by anyone, we might as well take it
}
}
/**
* @brief 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;
}
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...
Glib::ustring target = sel.get_target(); // this can crash if the result was invalid of last function. No way to check for this :(
// there is no specific plain SVG input extension, so if we can paste the Inkscape SVG format,
if(target == "image/x-inkscape-svg")
return NULL; // this shouldn't happen unless _getBestTarget returns something bogus
// FIXME: Temporary hack until we add memory input.
// Save the clipboard contents to some file, then read it
return tempdoc;
}
/**
* @brief 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.
*/
{
// FIXME: Temporary hack until we add support for memory output.
// Save to a temporary file, read it back and then set the clipboard contents
}
/**
* @brief 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();
}
/**
* @brief Creates an internal clipboard document from scratch
*/
{
if ( _clipboardSPDoc == NULL ) {
//g_assert( _clipboardSPDoc != NULL );
}
}
/**
* @brief Deletes the internal clipboard document
*/
{
if ( _clipboardSPDoc != NULL ) {
}
}
/**
* @brief Get the scale to resize an item, based on the command and desktop state
*/
NR::scale ClipboardManagerImpl::_getScale(Geom::Point &min, Geom::Point &max, NR::Rect &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
}
}
/**
* @brief Find the most suitable clipboard target
*/
{
// clipboard target debugging snippet
/*
g_debug("Begin clipboard targets");
for ( std::list<Glib::ustring>::iterator x = targets.begin() ; x != targets.end(); ++x )
g_debug("Clipboard target: %s", (*x).data());
g_debug("End clipboard targets\n");
//*/
i != _preferred_targets.end() ; ++i)
{
return *i;
}
if (_clipboard->wait_is_image_available())
return CLIPBOARD_GDK_PIXBUF_TARGET;
if (_clipboard->wait_is_text_available())
return CLIPBOARD_TEXT_TARGET;
return "";
}
/**
* @brief Set the clipboard targets to reflect the mimetypes Inkscape can output
*/
{
for (Inkscape::Extension::DB::OutputList::const_iterator out = outlist.begin() ; out != outlist.end() ; ++out) {
}
}
/**
* @brief Set the string representation of a 32-bit RGBA color as the clipboard contents
*/
{
}
/**
* @brief Put a notification on the mesage stack
*/
{
}
/* #######################################
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:encoding=utf-8:textwidth=99 :