diff --git a/liborigin/tree.hh b/liborigin/tree.hh
index ca742fc2b..71a13a4e4 100644
--- a/liborigin/tree.hh
+++ b/liborigin/tree.hh
@@ -1,2664 +1,2667 @@
 /*
 
    $Id: tree.hh,v 1.147 2007/10/19 11:24:24 peekas Exp $
 
    STL-like templated tree class.
    Copyright (C) 2001-2006  Kasper Peeters <kasper.peeters@aei.mpg.de>.
 
 */
 
 /** \mainpage tree.hh
     \author   Kasper Peeters
     \version  2.4
     \date     18-Oct-2007
     \see      http://www.aei.mpg.de/~peekas/tree/
     \see      http://www.aei.mpg.de/~peekas/tree/ChangeLog
 
    The tree.hh library for C++ provides an STL-like container class
    for n-ary trees, templated over the data stored at the
    nodes. Various types of iterators are provided (post-order,
    pre-order, and others). Where possible the access methods are
    compatible with the STL or alternative algorithms are
    available.
 */
 
 
 /*
    The tree.hh code is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; version 2 or 3.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA  02110-1301  USA
 */
 
 /** \todo
    - New-style move members are not completely finished yet.
    - It would be good to have an iterator which can iterate over all
      nodes below a given node.
    - Fixed depth iterators do not iterate over the entire range if there
      are 'holes' in the tree.
    - If a range uses const iter_base& as end iterator, things will
      inevitably go wrong, because upcast from iter_base to a non-sibling_iter
      is incorrect. This upcast should be removed (and then all illegal uses
      as previously in 'equal' will be flagged by the compiler). This requires
      new copy constructors though.
    - There's a bug in replace(sibling_iterator, ...) when the ranges
      sit next to each other. Turned up in append_child(iter,iter)
      but has been avoided now.
    - "std::operator<" does not work correctly on our iterators, and for some
      reason a globally defined template operator< did not get picked up.
      Using a comparison class now, but this should be investigated.
 */
 
 #ifndef tree_hh_
 #define tree_hh_
 
 #include <cassert>
 #include <memory>
 #include <stdexcept>
 #include <iterator>
 #include <set>
 #include <queue>
 #include <iostream>
 
 // HP-style construct/destroy have gone from the standard,
 // so here is a copy.
 
 namespace kp {
 
 template <class T1, class T2>
 void constructor(T1* p, T2& val)
    {
    new ((void *) p) T1(val);
    }
 
 template <class T1>
 void constructor(T1* p)
    {
    new ((void *) p) T1;
    }
 
 template <class T1>
 void destructor(T1* p)
    {
    p->~T1();
    }
 
 };
 
 /// A node in the tree, combining links to other nodes as well as the actual data.
 template<class T>
 class tree_node_ { // size: 5*4=20 bytes (on 32 bit arch), can be reduced by 8.
    public:
       tree_node_<T> *parent;
       tree_node_<T> *first_child, *last_child;
       tree_node_<T> *prev_sibling, *next_sibling;
       T data;
 }; // __attribute__((packed));
 
 template <class T, class tree_node_allocator = std::allocator<tree_node_<T> > >
 class tree {
    protected:
       typedef tree_node_<T> tree_node;
    public:
       /// Value of the data stored at a node.
       typedef T value_type;
 
       class iterator_base;
       class pre_order_iterator;
       class post_order_iterator;
       class sibling_iterator;
       class leaf_iterator;
 
       tree();
       tree(const T&);
       tree(const iterator_base&);
       tree(const tree<T, tree_node_allocator>&);
       ~tree();
       void operator=(const tree<T, tree_node_allocator>&);
 
       /// Base class for iterators, only pointers stored, no traversal logic.
 #ifdef __SGI_STL_PORT
       class iterator_base : public stlport::bidirectional_iterator<T, ptrdiff_t> {
 #else
       class iterator_base {
 #endif
          public:
             typedef T                               value_type;
             typedef T*                              pointer;
             typedef T&                              reference;
             typedef size_t                          size_type;
             typedef ptrdiff_t                       difference_type;
             typedef std::bidirectional_iterator_tag iterator_category;
 
             iterator_base();
             iterator_base(tree_node *);
 
             T&             operator*() const;
             T*             operator->() const;
 
             /// When called, the next increment/decrement skips children of this node.
             void         skip_children();
             /// Number of children of the node pointed to by the iterator.
             unsigned int number_of_children() const;
 
             sibling_iterator begin() const;
             sibling_iterator end() const;
 
             tree_node *node;
          protected:
             bool skip_current_children_;
       };
 
       /// Depth-first iterator, first accessing the node, then its children.
       class pre_order_iterator : public iterator_base {
          public:
             pre_order_iterator();
             pre_order_iterator(tree_node *);
             pre_order_iterator(const iterator_base&);
             pre_order_iterator(const sibling_iterator&);
 
             bool    operator==(const pre_order_iterator&) const;
             bool    operator!=(const pre_order_iterator&) const;
             pre_order_iterator&  operator++();
             pre_order_iterator&  operator--();
             pre_order_iterator   operator++(int);
             pre_order_iterator   operator--(int);
             pre_order_iterator&  operator+=(unsigned int);
             pre_order_iterator&  operator-=(unsigned int);
       };
 
       /// Depth-first iterator, first accessing the children, then the node itself.
       class post_order_iterator : public iterator_base {
          public:
             post_order_iterator();
             post_order_iterator(tree_node *);
             post_order_iterator(const iterator_base&);
             post_order_iterator(const sibling_iterator&);
 
             bool    operator==(const post_order_iterator&) const;
             bool    operator!=(const post_order_iterator&) const;
             post_order_iterator&  operator++();
             post_order_iterator&  operator--();
             post_order_iterator   operator++(int);
             post_order_iterator   operator--(int);
             post_order_iterator&  operator+=(unsigned int);
             post_order_iterator&  operator-=(unsigned int);
 
             /// Set iterator to the first child as deep as possible down the tree.
             void descend_all();
       };
 
       /// Breadth-first iterator, using a queue
       class breadth_first_queued_iterator : public iterator_base {
          public:
             breadth_first_queued_iterator();
             breadth_first_queued_iterator(tree_node *);
             breadth_first_queued_iterator(const iterator_base&);
 
             bool    operator==(const breadth_first_queued_iterator&) const;
             bool    operator!=(const breadth_first_queued_iterator&) const;
             breadth_first_queued_iterator&  operator++();
             breadth_first_queued_iterator   operator++(int);
             breadth_first_queued_iterator&  operator+=(unsigned int);
 
          private:
             std::queue<tree_node *> traversal_queue;
       };
 
       /// The default iterator types throughout the tree class.
       typedef pre_order_iterator            iterator;
       typedef breadth_first_queued_iterator breadth_first_iterator;
 
       /// Iterator which traverses only the nodes at a given depth from the root.
       class fixed_depth_iterator : public iterator_base {
          public:
             fixed_depth_iterator();
             fixed_depth_iterator(tree_node *);
             fixed_depth_iterator(const iterator_base&);
             fixed_depth_iterator(const sibling_iterator&);
             fixed_depth_iterator(const fixed_depth_iterator&);
 
             bool    operator==(const fixed_depth_iterator&) const;
             bool    operator!=(const fixed_depth_iterator&) const;
             fixed_depth_iterator&  operator++();
             fixed_depth_iterator&  operator--();
             fixed_depth_iterator   operator++(int);
             fixed_depth_iterator   operator--(int);
             fixed_depth_iterator&  operator+=(unsigned int);
             fixed_depth_iterator&  operator-=(unsigned int);
 
             tree_node *first_parent_;
          private:
             void set_first_parent_();
             void find_leftmost_parent_();
       };
 
       /// Iterator which traverses only the nodes which are siblings of each other.
       class sibling_iterator : public iterator_base {
          public:
             sibling_iterator();
             sibling_iterator(tree_node *);
             sibling_iterator(const sibling_iterator&);
             sibling_iterator(const iterator_base&);
 
             bool    operator==(const sibling_iterator&) const;
             bool    operator!=(const sibling_iterator&) const;
             sibling_iterator&  operator++();
             sibling_iterator&  operator--();
             sibling_iterator   operator++(int);
             sibling_iterator   operator--(int);
             sibling_iterator&  operator+=(unsigned int);
             sibling_iterator&  operator-=(unsigned int);
 
             tree_node *range_first() const;
             tree_node *range_last() const;
             tree_node *parent_;
          private:
             void set_parent_();
       };
 
       /// Iterator which traverses only the leaves.
       class leaf_iterator : public iterator_base {
          public:
             leaf_iterator();
             leaf_iterator(tree_node *);
             leaf_iterator(const sibling_iterator&);
             leaf_iterator(const iterator_base&);
 
             bool    operator==(const leaf_iterator&) const;
             bool    operator!=(const leaf_iterator&) const;
             leaf_iterator&  operator++();
             leaf_iterator&  operator--();
             leaf_iterator   operator++(int);
             leaf_iterator   operator--(int);
             leaf_iterator&  operator+=(unsigned int);
             leaf_iterator&  operator-=(unsigned int);
       };
 
       /// Return iterator to the beginning of the tree.
       inline pre_order_iterator   begin() const;
       /// Return iterator to the end of the tree.
       inline pre_order_iterator   end() const;
       /// Return post-order iterator to the beginning of the tree.
       post_order_iterator  begin_post() const;
       /// Return post-order iterator to the end of the tree.
       post_order_iterator  end_post() const;
       /// Return fixed-depth iterator to the first node at a given depth from the given iterator.
       fixed_depth_iterator begin_fixed(const iterator_base&, unsigned int) const;
       /// Return fixed-depth iterator to end of the nodes at given depth from the given iterator.
       fixed_depth_iterator end_fixed(const iterator_base&, unsigned int) const;
       /// Return breadth-first iterator to the first node at a given depth.
       breadth_first_queued_iterator begin_breadth_first() const;
       /// Return breadth-first iterator to end of the nodes at given depth.
       breadth_first_queued_iterator end_breadth_first() const;
       /// Return sibling iterator to the first child of given node.
       sibling_iterator     begin(const iterator_base&) const;
       /// Return sibling iterator to the end of the children of a given node.
       sibling_iterator     end(const iterator_base&) const;
       /// Return leaf iterator to the first leaf of the tree.
       leaf_iterator   begin_leaf() const;
       /// Return leaf iterator to the last leaf of the tree.
       leaf_iterator   end_leaf() const;
 
       /// Return iterator to the parent of a node.
       template<typename iter> static iter parent(iter);
       /// Return iterator to the previous sibling of a node.
       template<typename iter> iter previous_sibling(iter) const;
       /// Return iterator to the next sibling of a node.
       template<typename iter> iter next_sibling(iter) const;
       /// Return iterator to the next node at a given depth.
       template<typename iter> iter next_at_same_depth(iter) const;
 
       /// Erase all nodes of the tree.
       void     clear();
       /// Erase element at position pointed to by iterator, return incremented iterator.
       template<typename iter> iter erase(iter);
       /// Erase all children of the node pointed to by iterator.
       void     erase_children(const iterator_base&);
 
       /// Insert empty node as last/first child of node pointed to by position.
       template<typename iter> iter append_child(iter position);
       template<typename iter> iter prepend_child(iter position);
       /// Insert node as last/first child of node pointed to by position.
       template<typename iter> iter append_child(iter position, const T& x);
       template<typename iter> iter prepend_child(iter position, const T& x);
       /// Append the node (plus its children) at other_position as last/first child of position.
       template<typename iter> iter append_child(iter position, iter other_position);
       template<typename iter> iter prepend_child(iter position, iter other_position);
       /// Append the nodes in the from-to range (plus their children) as last/first children of position.
       template<typename iter> iter append_children(iter position, sibling_iterator from, sibling_iterator to);
       template<typename iter> iter prepend_children(iter position, sibling_iterator from, sibling_iterator to);
 
       /// Short-hand to insert topmost node in otherwise empty tree.
       pre_order_iterator set_head(const T& x);
       /// Insert node as previous sibling of node pointed to by position.
       template<typename iter> iter insert(iter position, const T& x);
       /// Specialisation of previous member.
       sibling_iterator insert(sibling_iterator position, const T& x);
       /// Insert node (with children) pointed to by subtree as previous sibling of node pointed to by position.
       template<typename iter> iter insert_subtree(iter position, const iterator_base& subtree);
       /// Insert node as next sibling of node pointed to by position.
       template<typename iter> iter insert_after(iter position, const T& x);
       /// Insert node (with children) pointed to by subtree as next sibling of node pointed to by position.
       template<typename iter> iter insert_subtree_after(iter position, const iterator_base& subtree);
 
       /// Replace node at 'position' with other node (keeping same children); 'position' becomes invalid.
       template<typename iter> iter replace(iter position, const T& x);
       /// Replace node at 'position' with subtree starting at 'from' (do not erase subtree at 'from'); see above.
       template<typename iter> iter replace(iter position, const iterator_base& from);
       /// Replace string of siblings (plus their children) with copy of a new string (with children); see above
       sibling_iterator replace(sibling_iterator orig_begin, sibling_iterator orig_end,
                                sibling_iterator new_begin,  sibling_iterator new_end);
 
       /// Move all children of node at 'position' to be siblings, returns position.
       template<typename iter> iter flatten(iter position);
       /// Move nodes in range to be children of 'position'.
       template<typename iter> iter reparent(iter position, sibling_iterator begin, sibling_iterator end);
       /// Move all child nodes of 'from' to be children of 'position'.
       template<typename iter> iter reparent(iter position, iter from);
 
       /// Replace node with a new node, making the old node a child of the new node.
       template<typename iter> iter wrap(iter position, const T& x);
 
       /// Move 'source' node (plus its children) to become the next sibling of 'target'.
       template<typename iter> iter move_after(iter target, iter source);
       /// Move 'source' node (plus its children) to become the previous sibling of 'target'.
       template<typename iter> iter move_before(iter target, iter source);
       sibling_iterator move_before(sibling_iterator target, sibling_iterator source);
       /// Move 'source' node (plus its children) to become the node at 'target' (erasing the node at 'target').
       template<typename iter> iter move_ontop(iter target, iter source);
 
       /// Merge with other tree, creating new branches and leaves only if they are not already present.
       void     merge(sibling_iterator, sibling_iterator, sibling_iterator, sibling_iterator,
                      bool duplicate_leaves=false);
       /// Sort (std::sort only moves values of nodes, this one moves children as well).
       void     sort(sibling_iterator from, sibling_iterator to, bool deep=false);
       template<class StrictWeakOrdering>
       void     sort(sibling_iterator from, sibling_iterator to, StrictWeakOrdering comp, bool deep=false);
       /// Compare two ranges of nodes (compares nodes as well as tree structure).
       template<typename iter>
       bool     equal(const iter& one, const iter& two, const iter& three) const;
       template<typename iter, class BinaryPredicate>
       bool     equal(const iter& one, const iter& two, const iter& three, BinaryPredicate) const;
       template<typename iter>
       bool     equal_subtree(const iter& one, const iter& two) const;
       template<typename iter, class BinaryPredicate>
       bool     equal_subtree(const iter& one, const iter& two, BinaryPredicate) const;
       /// Extract a new tree formed by the range of siblings plus all their children.
       tree     subtree(sibling_iterator from, sibling_iterator to) const;
       void     subtree(tree&, sibling_iterator from, sibling_iterator to) const;
       /// Exchange the node (plus subtree) with its sibling node (do nothing if no sibling present).
       void     swap(sibling_iterator it);
       /// Exchange two nodes (plus subtrees)
       void     swap(iterator, iterator);
 
       /// Count the total number of nodes.
       int      size() const;
       /// Count the total number of nodes below the indicated node (plus one).
       int      size(const iterator_base&) const;
       /// Check if tree is empty.
       bool     empty() const;
       /// Compute the depth to the root.
       int      depth(const iterator_base&) const;
       /// Determine the maximal depth of the tree.
       int      max_depth() const;
       /// Determine the maximal depth of the tree below a given one.
       int      max_depth(const iterator_base&) const;
       /// Count the number of children of node at position.
       static unsigned int number_of_children(const iterator_base&);
       /// Count the number of 'next' siblings of node at iterator.
       unsigned int number_of_siblings(const iterator_base&) const;
       /// Determine whether node at position is in the subtrees with root in the range.
       bool     is_in_subtree(const iterator_base& position, const iterator_base& begin,
                              const iterator_base& end) const;
       /// Determine whether the iterator is an 'end' iterator and thus not actually pointing to a node.
       bool     is_valid(const iterator_base&) const;
 
       /// Determine the index of a node in the range of siblings to which it belongs.
       unsigned int index(sibling_iterator it) const;
       /// Inverse of 'index': return the n-th child of the node at position.
       sibling_iterator  child(const iterator_base& position, unsigned int) const;
 
       /// Comparator class for iterators (compares pointer values; why doesn't this work automatically?)
       class iterator_base_less {
          public:
             bool operator()(const typename tree<T, tree_node_allocator>::iterator_base& one,
                             const typename tree<T, tree_node_allocator>::iterator_base& two) const
                {
                return one.node < two.node;
                }
       };
       tree_node *head, *feet;    // head/feet are always dummy; if an iterator points to them it is invalid
    private:
       tree_node_allocator alloc_;
       void head_initialise_();
       void copy_(const tree<T, tree_node_allocator>& other);
 
       /// Comparator class for two nodes of a tree (used for sorting and searching).
       template<class StrictWeakOrdering>
       class compare_nodes {
          public:
             compare_nodes(StrictWeakOrdering comp) : comp_(comp) {};
 
             bool operator()(const tree_node *a, const tree_node *b)
                {
                static StrictWeakOrdering comp;
                return comp(a->data, b->data);
                }
          private:
             StrictWeakOrdering comp_;
       };
 };
 
 //template <class T, class tree_node_allocator>
 //class iterator_base_less {
 // public:
 //    bool operator()(const typename tree<T, tree_node_allocator>::iterator_base& one,
 //                  const typename tree<T, tree_node_allocator>::iterator_base& two) const
 //       {
 //       txtout << "operatorclass<" << one.node < two.node << std::endl;
 //       return one.node < two.node;
 //       }
 //};
 
 // template <class T, class tree_node_allocator>
 // bool operator<(const typename tree<T, tree_node_allocator>::iterator& one,
 //                const typename tree<T, tree_node_allocator>::iterator& two)
 //    {
 //    txtout << "operator< " << one.node < two.node << std::endl;
 //    if(one.node < two.node) return true;
 //    return false;
 //    }
 //
 // template <class T, class tree_node_allocator>
 // bool operator==(const typename tree<T, tree_node_allocator>::iterator& one,
 //                const typename tree<T, tree_node_allocator>::iterator& two)
 //    {
 //    txtout << "operator== " << one.node == two.node << std::endl;
 //    if(one.node == two.node) return true;
 //    return false;
 //    }
 //
 // template <class T, class tree_node_allocator>
 // bool operator>(const typename tree<T, tree_node_allocator>::iterator_base& one,
 //                const typename tree<T, tree_node_allocator>::iterator_base& two)
 //    {
 //    txtout << "operator> " << one.node < two.node << std::endl;
 //    if(one.node > two.node) return true;
 //    return false;
 //    }
 
 
 
 // Tree
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::tree()
    {
    head_initialise_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::tree(const T& x)
    {
    head_initialise_();
    set_head(x);
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::tree(const iterator_base& other)
    {
    head_initialise_();
    set_head((*other));
    replace(begin(), other);
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::~tree()
    {
    clear();
    alloc_.deallocate(head,1);
    alloc_.deallocate(feet,1);
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::head_initialise_()
    {
    head = alloc_.allocate(1,0); // MSVC does not have default second argument
    feet = alloc_.allocate(1,0);
 
    head->parent=0;
    head->first_child=0;
    head->last_child=0;
    head->prev_sibling=0; //head;
    head->next_sibling=feet; //head;
 
    feet->parent=0;
    feet->first_child=0;
    feet->last_child=0;
    feet->prev_sibling=head;
    feet->next_sibling=0;
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::operator=(const tree<T, tree_node_allocator>& other)
    {
    copy_(other);
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::tree(const tree<T, tree_node_allocator>& other)
    {
    head_initialise_();
    copy_(other);
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::copy_(const tree<T, tree_node_allocator>& other)
    {
    clear();
    pre_order_iterator it=other.begin(), to=begin();
    while(it!=other.end()) {
       to=insert(to, (*it));
       it.skip_children();
       ++it;
       }
    to=begin();
    it=other.begin();
    while(it!=other.end()) {
       to=replace(to, it);
       to.skip_children();
       it.skip_children();
       ++to;
       ++it;
       }
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::clear()
    {
    if(head)
       while(head->next_sibling!=feet)
          erase(pre_order_iterator(head->next_sibling));
    }
 
 template<class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::erase_children(const iterator_base& it)
    {
 // std::cout << "erase_children " << it.node << std::endl;
    if(it.node==0) return;
 
    tree_node *cur=it.node->first_child;
    tree_node *prev=0;
 
    while(cur!=0) {
       prev=cur;
       cur=cur->next_sibling;
       erase_children(pre_order_iterator(prev));
       kp::destructor(&prev->data);
       alloc_.deallocate(prev,1);
       }
    it.node->first_child=0;
    it.node->last_child=0;
 // std::cout << "exit" << std::endl;
    }
 
 template<class T, class tree_node_allocator>
 template<class iter>
 iter tree<T, tree_node_allocator>::erase(iter it)
    {
    tree_node *cur=it.node;
    assert(cur!=head);
    iter ret=it;
    ret.skip_children();
    ++ret;
    erase_children(it);
    if(cur->prev_sibling==0) {
       cur->parent->first_child=cur->next_sibling;
       }
    else {
       cur->prev_sibling->next_sibling=cur->next_sibling;
       }
    if(cur->next_sibling==0) {
       cur->parent->last_child=cur->prev_sibling;
       }
    else {
       cur->next_sibling->prev_sibling=cur->prev_sibling;
       }
 
    kp::destructor(&cur->data);
    alloc_.deallocate(cur,1);
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::begin() const
    {
    return pre_order_iterator(head->next_sibling);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::end() const
    {
    return pre_order_iterator(feet);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::breadth_first_queued_iterator tree<T, tree_node_allocator>::begin_breadth_first() const
    {
    return breadth_first_queued_iterator(head->next_sibling);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::breadth_first_queued_iterator tree<T, tree_node_allocator>::end_breadth_first() const
    {
    return breadth_first_queued_iterator();
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::begin_post() const
    {
    tree_node *tmp=head->next_sibling;
    if(tmp!=feet) {
       while(tmp->first_child)
          tmp=tmp->first_child;
       }
    return post_order_iterator(tmp);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::end_post() const
    {
    return post_order_iterator(feet);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::begin_fixed(const iterator_base& pos, unsigned int dp) const
    {
    tree_node *tmp=pos.node;
    unsigned int curdepth=0;
    while(curdepth<dp) { // go down one level
       while(tmp->first_child==0) {
          if(tmp->next_sibling==0) {
             // try to walk up and then right again
             do {
                tmp=tmp->parent;
                if(tmp==0)
                   throw std::range_error("tree: begin_fixed out of range");
                --curdepth;
                } while(tmp->next_sibling==0);
             }
          tmp=tmp->next_sibling;
          }
       tmp=tmp->first_child;
       ++curdepth;
       }
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::end_fixed(const iterator_base& pos, unsigned int dp) const
    {
    assert(1==0); // FIXME: not correct yet: use is_valid() as a temporary workaround
    tree_node *tmp=pos.node;
    unsigned int curdepth=1;
    while(curdepth<dp) { // go down one level
       while(tmp->first_child==0) {
          tmp=tmp->next_sibling;
          if(tmp==0)
             throw std::range_error("tree: end_fixed out of range");
          }
       tmp=tmp->first_child;
       ++curdepth;
       }
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::begin(const iterator_base& pos) const
    {
    assert(pos.node!=0);
    if(pos.node->first_child==0) {
       return end(pos);
       }
    return pos.node->first_child;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::end(const iterator_base& pos) const
    {
    sibling_iterator ret(0);
    ret.parent_=pos.node;
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator tree<T, tree_node_allocator>::begin_leaf() const
    {
    tree_node *tmp=head->next_sibling;
    if(tmp!=feet) {
       while(tmp->first_child)
          tmp=tmp->first_child;
       }
    return leaf_iterator(tmp);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator tree<T, tree_node_allocator>::end_leaf() const
    {
    return leaf_iterator(feet);
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::parent(iter position)
    {
    assert(position.node!=0);
    return iter(position.node->parent);
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::previous_sibling(iter position) const
    {
    assert(position.node!=0);
    iter ret(position);
    ret.node=position.node->prev_sibling;
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::next_sibling(iter position) const
    {
    assert(position.node!=0);
    iter ret(position);
    ret.node=position.node->next_sibling;
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::next_at_same_depth(iter position) const
    {
    assert(position.node!=0);
    iter ret(position);
 
    if(position.node->next_sibling) {
       ret.node=position.node->next_sibling;
       }
    else {
       int relative_depth=0;
       upper:
       do {
          ret.node=ret.node->parent;
          if(ret.node==0) return ret;
          --relative_depth;
          } while(ret.node->next_sibling==0);
       lower:
       ret.node=ret.node->next_sibling;
       while(ret.node->first_child==0) {
          if(ret.node->next_sibling==0)
             goto upper;
          ret.node=ret.node->next_sibling;
          if(ret.node==0) return ret;
          }
       while(relative_depth<0 && ret.node->first_child!=0) {
          ret.node=ret.node->first_child;
          ++relative_depth;
          }
       if(relative_depth<0) {
          if(ret.node->next_sibling==0) goto upper;
          else                          goto lower;
          }
       }
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::append_child(iter position)
    {
    assert(position.node!=head);
    assert(position.node);
 
    tree_node *tmp=alloc_.allocate(1,0);
    kp::constructor(&tmp->data);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->parent=position.node;
    if(position.node->last_child!=0) {
       position.node->last_child->next_sibling=tmp;
       }
    else {
       position.node->first_child=tmp;
       }
    tmp->prev_sibling=position.node->last_child;
    position.node->last_child=tmp;
    tmp->next_sibling=0;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::prepend_child(iter position)
    {
    assert(position.node!=head);
    assert(position.node);
 
    tree_node *tmp=alloc_.allocate(1,0);
    kp::constructor(&tmp->data);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->parent=position.node;
    if(position.node->first_child!=0) {
       position.node->first_child->prev_sibling=tmp;
       }
    else {
       position.node->last_child=tmp;
       }
    tmp->next_sibling=position.node->first_child;
    position.node->prev_child=tmp;
    tmp->prev_sibling=0;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::append_child(iter position, const T& x)
    {
    // If your program fails here you probably used 'append_child' to add the top
    // node to an empty tree. From version 1.45 the top element should be added
    // using 'insert'. See the documentation for further information, and sorry about
    // the API change.
    assert(position.node!=head);
    assert(position.node);
 
    tree_node* tmp = alloc_.allocate(1,0);
    kp::constructor(&tmp->data, x);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->parent=position.node;
    if(position.node->last_child!=0) {
       position.node->last_child->next_sibling=tmp;
       }
    else {
       position.node->first_child=tmp;
       }
    tmp->prev_sibling=position.node->last_child;
    position.node->last_child=tmp;
    tmp->next_sibling=0;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::prepend_child(iter position, const T& x)
    {
    assert(position.node!=head);
    assert(position.node);
 
    tree_node* tmp = alloc_.allocate(1,0);
    kp::constructor(&tmp->data, x);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->parent=position.node;
    if(position.node->first_child!=0) {
       position.node->first_child->prev_sibling=tmp;
       }
    else {
       position.node->last_child=tmp;
       }
    tmp->next_sibling=position.node->first_child;
    position.node->first_child=tmp;
    tmp->prev_sibling=0;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::append_child(iter position, iter other)
    {
    assert(position.node!=head);
    assert(position.node);
 
    sibling_iterator aargh=append_child(position, value_type());
    return replace(aargh, other);
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::prepend_child(iter position, iter other)
    {
    assert(position.node!=head);
    assert(position.node);
 
    sibling_iterator aargh=prepend_child(position, value_type());
    return replace(aargh, other);
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::append_children(iter position, sibling_iterator from, sibling_iterator to)
    {
    assert(position.node!=head);
    assert(position.node);
 
    iter ret=from;
 
    while(from!=to) {
       insert_subtree(position.end(), from);
       ++from;
       }
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::prepend_children(iter position, sibling_iterator from, sibling_iterator to)
    {
    assert(position.node!=head);
    assert(position.node);
 
    iter ret=from;
 
    while(from!=to) {
       insert_subtree(position.begin(), from);
       ++from;
       }
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::set_head(const T& x)
    {
    assert(head->next_sibling==feet);
    return insert(iterator(feet), x);
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::insert(iter position, const T& x)
    {
    if(position.node==0) {
       position.node=feet; // Backward compatibility: when calling insert on a null node,
                           // insert before the feet.
       }
    tree_node* tmp = alloc_.allocate(1,0);
    kp::constructor(&tmp->data, x);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->parent=position.node->parent;
    tmp->next_sibling=position.node;
    tmp->prev_sibling=position.node->prev_sibling;
    position.node->prev_sibling=tmp;
 
    if(tmp->prev_sibling==0) {
       if(tmp->parent) // when inserting nodes at the head, there is no parent
          tmp->parent->first_child=tmp;
       }
    else
       tmp->prev_sibling->next_sibling=tmp;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::insert(sibling_iterator position, const T& x)
    {
    tree_node* tmp = alloc_.allocate(1,0);
    kp::constructor(&tmp->data, x);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->next_sibling=position.node;
    if(position.node==0) { // iterator points to end of a subtree
       tmp->parent=position.parent_;
       tmp->prev_sibling=position.range_last();
       tmp->parent->last_child=tmp;
       }
    else {
       tmp->parent=position.node->parent;
       tmp->prev_sibling=position.node->prev_sibling;
       position.node->prev_sibling=tmp;
       }
 
    if(tmp->prev_sibling==0) {
       if(tmp->parent) // when inserting nodes at the head, there is no parent
          tmp->parent->first_child=tmp;
       }
    else
       tmp->prev_sibling->next_sibling=tmp;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::insert_after(iter position, const T& x)
    {
    tree_node* tmp = alloc_.allocate(1,0);
    kp::constructor(&tmp->data, x);
    tmp->first_child=0;
    tmp->last_child=0;
 
    tmp->parent=position.node->parent;
    tmp->prev_sibling=position.node;
    tmp->next_sibling=position.node->next_sibling;
    position.node->next_sibling=tmp;
 
    if(tmp->next_sibling==0) {
       if(tmp->parent) // when inserting nodes at the head, there is no parent
          tmp->parent->last_child=tmp;
       }
    else {
       tmp->next_sibling->prev_sibling=tmp;
       }
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::insert_subtree(iter position, const iterator_base& subtree)
    {
    // insert dummy
    iter it=insert(position, value_type());
    // replace dummy with subtree
    return replace(it, subtree);
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::insert_subtree_after(iter position, const iterator_base& subtree)
    {
    // insert dummy
    iter it=insert_after(position, value_type());
    // replace dummy with subtree
    return replace(it, subtree);
    }
 
 // template <class T, class tree_node_allocator>
 // template <class iter>
 // iter tree<T, tree_node_allocator>::insert_subtree(sibling_iterator position, iter subtree)
 //    {
 //    // insert dummy
 //    iter it(insert(position, value_type()));
 //    // replace dummy with subtree
 //    return replace(it, subtree);
 //    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::replace(iter position, const T& x)
    {
    kp::destructor(&position.node->data);
    kp::constructor(&position.node->data, x);
    return position;
    }
 
 template <class T, class tree_node_allocator>
 template <class iter>
 iter tree<T, tree_node_allocator>::replace(iter position, const iterator_base& from)
    {
    assert(position.node!=head);
    tree_node *current_from=from.node;
    tree_node *start_from=from.node;
    tree_node *current_to  =position.node;
 
    // replace the node at position with head of the replacement tree at from
 // std::cout << "warning!" << position.node << std::endl;
    erase_children(position);
 // std::cout << "no warning!" << std::endl;
    tree_node* tmp = alloc_.allocate(1,0);
    kp::constructor(&tmp->data, (*from));
    tmp->first_child=0;
    tmp->last_child=0;
    if(current_to->prev_sibling==0) {
       if(current_to->parent!=0)
          current_to->parent->first_child=tmp;
       }
    else {
       current_to->prev_sibling->next_sibling=tmp;
       }
    tmp->prev_sibling=current_to->prev_sibling;
    if(current_to->next_sibling==0) {
       if(current_to->parent!=0)
          current_to->parent->last_child=tmp;
       }
    else {
       current_to->next_sibling->prev_sibling=tmp;
       }
    tmp->next_sibling=current_to->next_sibling;
    tmp->parent=current_to->parent;
    kp::destructor(&current_to->data);
    alloc_.deallocate(current_to,1);
    current_to=tmp;
 
    // only at this stage can we fix 'last'
    tree_node *last=from.node->next_sibling;
 
    pre_order_iterator toit=tmp;
    // copy all children
    do {
       assert(current_from!=0);
       if(current_from->first_child != 0) {
          current_from=current_from->first_child;
          toit=append_child(toit, current_from->data);
          }
       else {
          while(current_from->next_sibling==0 && current_from!=start_from) {
             current_from=current_from->parent;
             toit=parent(toit);
             assert(current_from!=0);
             }
          current_from=current_from->next_sibling;
          if(current_from!=last) {
             toit=append_child(parent(toit), current_from->data);
             }
          }
       } while(current_from!=last);
 
    return current_to;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::replace(
    sibling_iterator orig_begin,
    sibling_iterator orig_end,
    sibling_iterator new_begin,
    sibling_iterator new_end)
    {
    tree_node *orig_first=orig_begin.node;
    tree_node *new_first=new_begin.node;
    tree_node *orig_last=orig_first;
    while((++orig_begin)!=orig_end)
       orig_last=orig_last->next_sibling;
    tree_node *new_last=new_first;
    while((++new_begin)!=new_end)
       new_last=new_last->next_sibling;
 
    // insert all siblings in new_first..new_last before orig_first
    bool first=true;
    pre_order_iterator ret;
    while(1==1) {
       pre_order_iterator tt=insert_subtree(pre_order_iterator(orig_first), pre_order_iterator(new_first));
       if(first) {
          ret=tt;
          first=false;
          }
       if(new_first==new_last)
          break;
       new_first=new_first->next_sibling;
       }
 
    // erase old range of siblings
    bool last=false;
    tree_node *next=orig_first;
    while(1==1) {
       if(next==orig_last)
          last=true;
       next=next->next_sibling;
       erase((pre_order_iterator)orig_first);
       if(last)
          break;
       orig_first=next;
       }
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::flatten(iter position)
    {
    if(position.node->first_child==0)
       return position;
 
    tree_node *tmp=position.node->first_child;
    while(tmp) {
       tmp->parent=position.node->parent;
       tmp=tmp->next_sibling;
       }
    if(position.node->next_sibling) {
       position.node->last_child->next_sibling=position.node->next_sibling;
       position.node->next_sibling->prev_sibling=position.node->last_child;
       }
    else {
       position.node->parent->last_child=position.node->last_child;
       }
    position.node->next_sibling=position.node->first_child;
    position.node->next_sibling->prev_sibling=position.node;
    position.node->first_child=0;
    position.node->last_child=0;
 
    return position;
    }
 
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 iter tree<T, tree_node_allocator>::reparent(iter position, sibling_iterator begin, sibling_iterator end)
    {
    tree_node *first=begin.node;
    tree_node *last=first;
 
    assert(first!=position.node);
 
    if(begin==end) return begin;
    // determine last node
    while((++begin)!=end) {
       last=last->next_sibling;
       }
    // move subtree
    if(first->prev_sibling==0) {
       first->parent->first_child=last->next_sibling;
       }
    else {
       first->prev_sibling->next_sibling=last->next_sibling;
       }
    if(last->next_sibling==0) {
       last->parent->last_child=first->prev_sibling;
       }
    else {
       last->next_sibling->prev_sibling=first->prev_sibling;
       }
    if(position.node->first_child==0) {
       position.node->first_child=first;
       position.node->last_child=last;
       first->prev_sibling=0;
       }
    else {
       position.node->last_child->next_sibling=first;
       first->prev_sibling=position.node->last_child;
       position.node->last_child=last;
       }
    last->next_sibling=0;
 
    tree_node *pos=first;
    while(1==1) {
       pos->parent=position.node;
       if(pos==last) break;
       pos=pos->next_sibling;
       }
 
    return first;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter> iter tree<T, tree_node_allocator>::reparent(iter position, iter from)
    {
    if(from.node->first_child==0) return position;
    return reparent(position, from.node->first_child, end(from));
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter> iter tree<T, tree_node_allocator>::wrap(iter position, const T& x)
    {
    assert(position.node!=0);
    sibling_iterator fr=position, to=position;
    ++to;
    iter ret = insert(position, x);
    reparent(ret, fr, to);
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter> iter tree<T, tree_node_allocator>::move_after(iter target, iter source)
    {
    tree_node *dst=target.node;
    tree_node *src=source.node;
    assert(dst);
    assert(src);
 
    if(dst==src) return source;
    if(dst->next_sibling)
       if(dst->next_sibling==src) // already in the right spot
          return source;
 
    // take src out of the tree
    if(src->prev_sibling!=0) src->prev_sibling->next_sibling=src->next_sibling;
    else                     src->parent->first_child=src->next_sibling;
    if(src->next_sibling!=0) src->next_sibling->prev_sibling=src->prev_sibling;
    else                     src->parent->last_child=src->prev_sibling;
 
    // connect it to the new point
    if(dst->next_sibling!=0) dst->next_sibling->prev_sibling=src;
    else                     dst->parent->last_child=src;
    src->next_sibling=dst->next_sibling;
    dst->next_sibling=src;
    src->prev_sibling=dst;
    src->parent=dst->parent;
    return src;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter> iter tree<T, tree_node_allocator>::move_before(iter target, iter source)
    {
    tree_node *dst=target.node;
    tree_node *src=source.node;
    assert(dst);
    assert(src);
 
    if(dst==src) return source;
    if(dst->prev_sibling)
       if(dst->prev_sibling==src) // already in the right spot
          return source;
 
    // take src out of the tree
    if(src->prev_sibling!=0) src->prev_sibling->next_sibling=src->next_sibling;
    else                     src->parent->first_child=src->next_sibling;
    if(src->next_sibling!=0) src->next_sibling->prev_sibling=src->prev_sibling;
    else                     src->parent->last_child=src->prev_sibling;
 
    // connect it to the new point
    if(dst->prev_sibling!=0) dst->prev_sibling->next_sibling=src;
    else                     dst->parent->first_child=src;
    src->prev_sibling=dst->prev_sibling;
    dst->prev_sibling=src;
    src->next_sibling=dst;
    src->parent=dst->parent;
    return src;
    }
 
 // specialisation for sibling_iterators
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::move_before(sibling_iterator target,
                                                                                          sibling_iterator source)
    {
    tree_node *dst=target.node;
    tree_node *src=source.node;
    tree_node *dst_prev_sibling;
    if(dst==0) { // must then be an end iterator
       dst_prev_sibling=target.parent_->last_child;
       assert(dst_prev_sibling);
       }
    else dst_prev_sibling=dst->prev_sibling;
    assert(src);
 
    if(dst==src) return source;
    if(dst_prev_sibling)
       if(dst_prev_sibling==src) // already in the right spot
          return source;
 
    // take src out of the tree
    if(src->prev_sibling!=0) src->prev_sibling->next_sibling=src->next_sibling;
    else                     src->parent->first_child=src->next_sibling;
    if(src->next_sibling!=0) src->next_sibling->prev_sibling=src->prev_sibling;
    else                     src->parent->last_child=src->prev_sibling;
 
    // connect it to the new point
    if(dst_prev_sibling!=0) dst_prev_sibling->next_sibling=src;
    else                    target.parent_->first_child=src;
    src->prev_sibling=dst_prev_sibling;
    if(dst) {
       dst->prev_sibling=src;
       src->parent=dst->parent;
       }
    src->next_sibling=dst;
    return src;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter> iter tree<T, tree_node_allocator>::move_ontop(iter target, iter source)
    {
    tree_node *dst=target.node;
    tree_node *src=source.node;
    assert(dst);
    assert(src);
 
    if(dst==src) return source;
 
    // remember connection points
    tree_node *b_prev_sibling=dst->prev_sibling;
    tree_node *b_next_sibling=dst->next_sibling;
    tree_node *b_parent=dst->parent;
 
    // remove target
    erase(target);
 
    // take src out of the tree
    if(src->prev_sibling!=0) src->prev_sibling->next_sibling=src->next_sibling;
    else                     src->parent->first_child=src->next_sibling;
    if(src->next_sibling!=0) src->next_sibling->prev_sibling=src->prev_sibling;
    else                     src->parent->last_child=src->prev_sibling;
 
    // connect it to the new point
    if(b_prev_sibling!=0) b_prev_sibling->next_sibling=src;
    else                  b_parent->first_child=src;
    if(b_next_sibling!=0) b_next_sibling->prev_sibling=src;
    else                  b_parent->last_child=src;
    src->prev_sibling=b_prev_sibling;
    src->next_sibling=b_next_sibling;
    src->parent=b_parent;
    return src;
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::merge(sibling_iterator to1,   sibling_iterator to2,
                                           sibling_iterator from1, sibling_iterator from2,
                                           bool duplicate_leaves)
    {
    sibling_iterator fnd;
    while(from1!=from2) {
       if((fnd=std::find(to1, to2, (*from1))) != to2) { // element found
          if(from1.begin()==from1.end()) { // full depth reached
             if(duplicate_leaves)
                append_child(parent(to1), (*from1));
             }
          else { // descend further
             merge(fnd.begin(), fnd.end(), from1.begin(), from1.end(), duplicate_leaves);
             }
          }
       else { // element missing
          insert_subtree(to2, from1);
          }
       ++from1;
       }
    }
 
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::sort(sibling_iterator from, sibling_iterator to, bool deep)
    {
    std::less<T> comp;
    sort(from, to, comp, deep);
    }
 
 template <class T, class tree_node_allocator>
 template <class StrictWeakOrdering>
 void tree<T, tree_node_allocator>::sort(sibling_iterator from, sibling_iterator to,
                                         StrictWeakOrdering comp, bool deep)
    {
    if(from==to) return;
    // make list of sorted nodes
    // CHECK: if multiset stores equivalent nodes in the order in which they
    // are inserted, then this routine should be called 'stable_sort'.
    std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> > nodes(comp);
    sibling_iterator it=from, it2=to;
    while(it != to) {
       nodes.insert(it.node);
       ++it;
       }
    // reassemble
    --it2;
 
    // prev and next are the nodes before and after the sorted range
    tree_node *prev=from.node->prev_sibling;
    tree_node *next=it2.node->next_sibling;
    typename std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> >::iterator nit=nodes.begin(), eit=nodes.end();
    if(prev==0) {
       if((*nit)->parent!=0) // to catch "sorting the head" situations, when there is no parent
          (*nit)->parent->first_child=(*nit);
       }
    else prev->next_sibling=(*nit);
 
    --eit;
    while(nit!=eit) {
       (*nit)->prev_sibling=prev;
       if(prev)
          prev->next_sibling=(*nit);
       prev=(*nit);
       ++nit;
       }
    // prev now points to the last-but-one node in the sorted range
    if(prev)
       prev->next_sibling=(*eit);
 
    // eit points to the last node in the sorted range.
    (*eit)->next_sibling=next;
    (*eit)->prev_sibling=prev; // missed in the loop above
    if(next==0) {
       if((*eit)->parent!=0) // to catch "sorting the head" situations, when there is no parent
          (*eit)->parent->last_child=(*eit);
       }
    else next->prev_sibling=(*eit);
 
    if(deep) {  // sort the children of each node too
       sibling_iterator bcs(*nodes.begin());
       sibling_iterator ecs(*eit);
       ++ecs;
       while(bcs!=ecs) {
          sort(begin(bcs), end(bcs), comp, deep);
          ++bcs;
          }
       }
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 bool tree<T, tree_node_allocator>::equal(const iter& one_, const iter& two, const iter& three_) const
    {
    std::equal_to<T> comp;
    return equal(one_, two, three_, comp);
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter>
 bool tree<T, tree_node_allocator>::equal_subtree(const iter& one_, const iter& two_) const
    {
    std::equal_to<T> comp;
    return equal_subtree(one_, two_, comp);
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter, class BinaryPredicate>
 bool tree<T, tree_node_allocator>::equal(const iter& one_, const iter& two, const iter& three_, BinaryPredicate fun) const
    {
    pre_order_iterator one(one_), three(three_);
 
 // if(one==two && is_valid(three) && three.number_of_children()!=0)
 //    return false;
    while(one!=two && is_valid(three)) {
       if(!fun(*one,*three))
          return false;
       if(one.number_of_children()!=three.number_of_children())
          return false;
       ++one;
       ++three;
       }
    return true;
    }
 
 template <class T, class tree_node_allocator>
 template <typename iter, class BinaryPredicate>
 bool tree<T, tree_node_allocator>::equal_subtree(const iter& one_, const iter& two_, BinaryPredicate fun) const
    {
    pre_order_iterator one(one_), two(two_);
 
    if(!fun(*one,*two)) return false;
    if(number_of_children(one)!=number_of_children(two)) return false;
    return equal(begin(one),end(one),begin(two),fun);
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator> tree<T, tree_node_allocator>::subtree(sibling_iterator from, sibling_iterator to) const
    {
    tree tmp;
    tmp.set_head(value_type());
    tmp.replace(tmp.begin(), tmp.end(), from, to);
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::subtree(tree& tmp, sibling_iterator from, sibling_iterator to) const
    {
    tmp.set_head(value_type());
    tmp.replace(tmp.begin(), tmp.end(), from, to);
    }
 
 template <class T, class tree_node_allocator>
 int tree<T, tree_node_allocator>::size() const
    {
    int i=0;
    pre_order_iterator it=begin(), eit=end();
    while(it!=eit) {
       ++i;
       ++it;
       }
    return i;
    }
 
 template <class T, class tree_node_allocator>
 int tree<T, tree_node_allocator>::size(const iterator_base& top) const
    {
    int i=0;
    pre_order_iterator it=top, eit=top;
    eit.skip_children();
    ++eit;
    while(it!=eit) {
       ++i;
       ++it;
       }
    return i;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::empty() const
    {
    pre_order_iterator it=begin(), eit=end();
    return (it==eit);
    }
 
 template <class T, class tree_node_allocator>
 int tree<T, tree_node_allocator>::depth(const iterator_base& it) const
    {
    tree_node* pos=it.node;
    assert(pos!=0);
    int ret=0;
    while(pos->parent!=0) {
       pos=pos->parent;
       ++ret;
       }
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 int tree<T, tree_node_allocator>::max_depth() const
    {
    return max_depth(begin());
    }
 
 
 template <class T, class tree_node_allocator>
 int tree<T, tree_node_allocator>::max_depth(const iterator_base& pos) const
    {
    tree_node *tmp=pos.node;
    int curdepth=0, maxdepth=0;
    while(true) { // try to walk the bottom of the tree
       while(tmp->first_child==0) {
          if(tmp==pos.node) return maxdepth;
          if(tmp->next_sibling==0) {
             // try to walk up and then right again
             do {
                tmp=tmp->parent;
                if(tmp==0) return maxdepth;
                --curdepth;
                } while(tmp->next_sibling==0);
             }
          if(tmp==pos.node) return maxdepth;
          tmp=tmp->next_sibling;
          }
       tmp=tmp->first_child;
       ++curdepth;
       maxdepth=std::max(curdepth, maxdepth);
       }
    }
 
 template <class T, class tree_node_allocator>
 unsigned int tree<T, tree_node_allocator>::number_of_children(const iterator_base& it)
    {
    tree_node *pos=it.node->first_child;
    if(pos==0) return 0;
 
    unsigned int ret=1;
 //   while(pos!=it.node->last_child) {
 //      ++ret;
 //      pos=pos->next_sibling;
 //      }
    while((pos=pos->next_sibling))
       ++ret;
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 unsigned int tree<T, tree_node_allocator>::number_of_siblings(const iterator_base& it) const
    {
    tree_node *pos=it.node;
    unsigned int ret=0;
    // count forward
    while(pos->next_sibling &&
          pos->next_sibling!=head &&
          pos->next_sibling!=feet) {
       ++ret;
       pos=pos->next_sibling;
       }
    // count backward
    pos=it.node;
    while(pos->prev_sibling &&
          pos->prev_sibling!=head &&
          pos->prev_sibling!=feet) {
       ++ret;
       pos=pos->prev_sibling;
       }
 
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::swap(sibling_iterator it)
    {
    tree_node *nxt=it.node->next_sibling;
    if(nxt) {
       if(it.node->prev_sibling)
          it.node->prev_sibling->next_sibling=nxt;
       else
          it.node->parent->first_child=nxt;
       nxt->prev_sibling=it.node->prev_sibling;
       tree_node *nxtnxt=nxt->next_sibling;
       if(nxtnxt)
          nxtnxt->prev_sibling=it.node;
       else
          it.node->parent->last_child=it.node;
       nxt->next_sibling=it.node;
       it.node->prev_sibling=nxt;
       it.node->next_sibling=nxtnxt;
       }
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::swap(iterator one, iterator two)
    {
    // if one and two are adjacent siblings, use the sibling swap
    if(one.node->next_sibling==two.node) swap(one);
    else if(two.node->next_sibling==one.node) swap(two);
    else {
       tree_node *nxt1=one.node->next_sibling;
       tree_node *nxt2=two.node->next_sibling;
       tree_node *pre1=one.node->prev_sibling;
       tree_node *pre2=two.node->prev_sibling;
       tree_node *par1=one.node->parent;
       tree_node *par2=two.node->parent;
 
       // reconnect
       one.node->parent=par2;
       one.node->next_sibling=nxt2;
       if(nxt2) nxt2->prev_sibling=one.node;
       else     par2->last_child=one.node;
       one.node->prev_sibling=pre2;
       if(pre2) pre2->next_sibling=one.node;
       else     par2->first_child=one.node;
 
       two.node->parent=par1;
       two.node->next_sibling=nxt1;
       if(nxt1) nxt1->prev_sibling=two.node;
       else     par1->last_child=two.node;
       two.node->prev_sibling=pre1;
       if(pre1) pre1->next_sibling=two.node;
       else     par1->first_child=two.node;
       }
    }
 
 // template <class BinaryPredicate>
 // tree<T, tree_node_allocator>::iterator tree<T, tree_node_allocator>::find_subtree(
 //    sibling_iterator subfrom, sibling_iterator subto, iterator from, iterator to,
 //    BinaryPredicate fun) const
 //    {
 //    assert(1==0); // this routine is not finished yet.
 //    while(from!=to) {
 //       if(fun(*subfrom, *from)) {
 //
 //          }
 //       }
 //    return to;
 //    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::is_in_subtree(const iterator_base& it, const iterator_base& begin,
                                                  const iterator_base& end) const
    {
    // FIXME: this should be optimised.
    pre_order_iterator tmp=begin;
    while(tmp!=end) {
       if(tmp==it) return true;
       ++tmp;
       }
    return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::is_valid(const iterator_base& it) const
    {
    if(it.node==0 || it.node==feet || it.node==head) return false;
    else return true;
    }
 
 template <class T, class tree_node_allocator>
 unsigned int tree<T, tree_node_allocator>::index(sibling_iterator it) const
    {
    unsigned int ind=0;
    if(it.node->parent==0) {
       while(it.node->prev_sibling!=head) {
          it.node=it.node->prev_sibling;
          ++ind;
          }
       }
    else {
       while(it.node->prev_sibling!=0) {
          it.node=it.node->prev_sibling;
          ++ind;
          }
       }
    return ind;
    }
 
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::child(const iterator_base& it, unsigned int num) const
    {
    tree_node *tmp=it.node->first_child;
    while(num--) {
       assert(tmp!=0);
       tmp=tmp->next_sibling;
       }
    return tmp;
    }
 
 
 
 
 // Iterator base
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::iterator_base::iterator_base()
    : node(0), skip_current_children_(false)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::iterator_base::iterator_base(tree_node *tn)
    : node(tn), skip_current_children_(false)
    {
    }
 
 template <class T, class tree_node_allocator>
 T& tree<T, tree_node_allocator>::iterator_base::operator*() const
    {
    return node->data;
    }
 
 template <class T, class tree_node_allocator>
 T* tree<T, tree_node_allocator>::iterator_base::operator->() const
    {
    return &(node->data);
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::post_order_iterator::operator!=(const post_order_iterator& other) const
    {
    if(other.node!=this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::post_order_iterator::operator==(const post_order_iterator& other) const
    {
    if(other.node==this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::pre_order_iterator::operator!=(const pre_order_iterator& other) const
    {
    if(other.node!=this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::pre_order_iterator::operator==(const pre_order_iterator& other) const
    {
    if(other.node==this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::sibling_iterator::operator!=(const sibling_iterator& other) const
    {
    if(other.node!=this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::sibling_iterator::operator==(const sibling_iterator& other) const
    {
    if(other.node==this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::leaf_iterator::operator!=(const leaf_iterator& other) const
    {
    if(other.node!=this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::leaf_iterator::operator==(const leaf_iterator& other) const
    {
    if(other.node==this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::iterator_base::begin() const
    {
    if(node->first_child==0)
       return end();
 
    sibling_iterator ret(node->first_child);
    ret.parent_=this->node;
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::iterator_base::end() const
    {
    sibling_iterator ret(0);
    ret.parent_=node;
    return ret;
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::iterator_base::skip_children()
    {
    skip_current_children_=true;
    }
 
 template <class T, class tree_node_allocator>
 unsigned int tree<T, tree_node_allocator>::iterator_base::number_of_children() const
    {
    tree_node *pos=node->first_child;
    if(pos==0) return 0;
 
    unsigned int ret=1;
    while(pos!=node->last_child) {
       ++ret;
       pos=pos->next_sibling;
       }
    return ret;
    }
 
 
 
 // Pre-order iterator
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator()
    : iterator_base(0)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator(tree_node *tn)
    : iterator_base(tn)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator(const iterator_base &other)
    : iterator_base(other.node)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator(const sibling_iterator& other)
    : iterator_base(other.node)
    {
    if(this->node==0) {
       if(other.range_last()!=0)
          this->node=other.range_last();
       else
          this->node=other.parent_;
       this->skip_children();
       ++(*this);
       }
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator++()
    {
    assert(this->node!=0);
    if(!this->skip_current_children_ && this->node->first_child != 0) {
       this->node=this->node->first_child;
       }
    else {
       this->skip_current_children_=false;
       while(this->node->next_sibling==0) {
          this->node=this->node->parent;
          if(this->node==0)
             return *this;
          }
       this->node=this->node->next_sibling;
       }
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator--()
    {
    assert(this->node!=0);
    if(this->node->prev_sibling) {
       this->node=this->node->prev_sibling;
       while(this->node->last_child)
          this->node=this->node->last_child;
       }
    else {
       this->node=this->node->parent;
       if(this->node==0)
          return *this;
       }
    return *this;
 }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::pre_order_iterator::operator++(int n)
    {
+   n = 0;
    pre_order_iterator copy = *this;
    ++(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::pre_order_iterator::operator--(int n)
 {
+   n = 0;
   pre_order_iterator copy = *this;
   --(*this);
   return copy;
 }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator+=(unsigned int num)
    {
    while(num>0) {
       ++(*this);
       --num;
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator-=(unsigned int num)
    {
    while(num>0) {
       --(*this);
       --num;
       }
    return (*this);
    }
 
 
 
 // Post-order iterator
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator()
    : iterator_base(0)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator(tree_node *tn)
    : iterator_base(tn)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator(const iterator_base &other)
    : iterator_base(other.node)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator(const sibling_iterator& other)
    : iterator_base(other.node)
    {
    if(this->node==0) {
       if(other.range_last()!=0)
          this->node=other.range_last();
       else
          this->node=other.parent_;
       this->skip_children();
       ++(*this);
       }
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator++()
    {
    assert(this->node!=0);
    if(this->node->next_sibling==0) {
       this->node=this->node->parent;
       this->skip_current_children_=false;
       }
    else {
       this->node=this->node->next_sibling;
       if(this->skip_current_children_) {
          this->skip_current_children_=false;
          }
       else {
          while(this->node->first_child)
             this->node=this->node->first_child;
          }
       }
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator--()
    {
    assert(this->node!=0);
    if(this->skip_current_children_ || this->node->last_child==0) {
       this->skip_current_children_=false;
       while(this->node->prev_sibling==0)
          this->node=this->node->parent;
       this->node=this->node->prev_sibling;
       }
    else {
       this->node=this->node->last_child;
       }
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::post_order_iterator::operator++(int)
    {
    post_order_iterator copy = *this;
    ++(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::post_order_iterator::operator--(int)
    {
    post_order_iterator copy = *this;
    --(*this);
    return copy;
    }
 
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator+=(unsigned int num)
    {
    while(num>0) {
       ++(*this);
       --num;
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator-=(unsigned int num)
    {
    while(num>0) {
       --(*this);
       --num;
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::post_order_iterator::descend_all()
    {
    assert(this->node!=0);
    while(this->node->first_child)
       this->node=this->node->first_child;
    }
 
 
 // Breadth-first iterator
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::breadth_first_queued_iterator::breadth_first_queued_iterator()
    : iterator_base()
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::breadth_first_queued_iterator::breadth_first_queued_iterator(tree_node *tn)
    : iterator_base(tn)
    {
    traversal_queue.push(tn);
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::breadth_first_queued_iterator::breadth_first_queued_iterator(const iterator_base& other)
    : iterator_base(other.node)
    {
    traversal_queue.push(other.node);
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::breadth_first_queued_iterator::operator!=(const breadth_first_queued_iterator& other) const
    {
    if(other.node!=this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::breadth_first_queued_iterator::operator==(const breadth_first_queued_iterator& other) const
    {
    if(other.node==this->node) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::breadth_first_queued_iterator& tree<T, tree_node_allocator>::breadth_first_queued_iterator::operator++()
    {
    assert(this->node!=0);
 
    // Add child nodes and pop current node
    sibling_iterator sib=this->begin();
    while(sib!=this->end()) {
       traversal_queue.push(sib.node);
       ++sib;
       }
    traversal_queue.pop();
    if(traversal_queue.size()>0)
       this->node=traversal_queue.front();
    else
       this->node=0;
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::breadth_first_queued_iterator tree<T, tree_node_allocator>::breadth_first_queued_iterator::operator++(int n)
    {
+   n = 0;
    breadth_first_queued_iterator copy = *this;
    ++(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::breadth_first_queued_iterator& tree<T, tree_node_allocator>::breadth_first_queued_iterator::operator+=(unsigned int num)
    {
    while(num>0) {
       ++(*this);
       --num;
       }
    return (*this);
    }
 
 
 
 // Fixed depth iterator
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator()
    : iterator_base()
    {
    set_first_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(tree_node *tn)
    : iterator_base(tn)
    {
    set_first_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(const iterator_base& other)
    : iterator_base(other.node)
    {
    set_first_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(const sibling_iterator& other)
    : iterator_base(other.node), first_parent_(other.parent_)
    {
    find_leftmost_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(const fixed_depth_iterator& other)
    : iterator_base(other.node), first_parent_(other.first_parent_)
    {
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::fixed_depth_iterator::operator==(const fixed_depth_iterator& other) const
    {
    if(other.node==this->node && other.first_parent_==first_parent_) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 bool tree<T, tree_node_allocator>::fixed_depth_iterator::operator!=(const fixed_depth_iterator& other) const
    {
    if(other.node!=this->node || other.first_parent_!=first_parent_) return true;
    else return false;
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::fixed_depth_iterator::set_first_parent_()
    {
    return; // FIXME: we do not use first_parent_ yet, and it actually needs some serious reworking if
            // it is ever to work at the 'head' level.
    first_parent_=0;
    if(this->node==0) return;
    if(this->node->parent!=0)
       first_parent_=this->node->parent;
    if(first_parent_)
       find_leftmost_parent_();
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::fixed_depth_iterator::find_leftmost_parent_()
    {
    return; // FIXME: see 'set_first_parent()'
    tree_node *tmppar=first_parent_;
    while(tmppar->prev_sibling) {
       tmppar=tmppar->prev_sibling;
       if(tmppar->first_child)
          first_parent_=tmppar;
       }
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator++()
    {
    assert(this->node!=0);
 
    if(this->node->next_sibling) {
       this->node=this->node->next_sibling;
       }
    else {
       int relative_depth=0;
       upper:
       do {
          this->node=this->node->parent;
          if(this->node==0) return *this;
          --relative_depth;
          } while(this->node->next_sibling==0);
       lower:
       this->node=this->node->next_sibling;
       while(this->node->first_child==0) {
          if(this->node->next_sibling==0)
             goto upper;
          this->node=this->node->next_sibling;
          if(this->node==0) return *this;
          }
       while(relative_depth<0 && this->node->first_child!=0) {
          this->node=this->node->first_child;
          ++relative_depth;
          }
       if(relative_depth<0) {
          if(this->node->next_sibling==0) goto upper;
          else                          goto lower;
          }
       }
    return *this;
 
 // if(this->node->next_sibling!=0) {
 //    this->node=this->node->next_sibling;
 //    assert(this->node!=0);
 //    if(this->node->parent==0 && this->node->next_sibling==0) // feet element
 //       this->node=0;
 //    }
 // else {
 //    tree_node *par=this->node->parent;
 //    do {
 //       par=par->next_sibling;
 //       if(par==0) { // FIXME: need to keep track of this!
 //          this->node=0;
 //          return *this;
 //          }
 //       } while(par->first_child==0);
 //    this->node=par->first_child;
 //    }
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator--()
    {
    assert(this->node!=0);
    if(this->node->prev_sibling!=0) {
       this->node=this->node->prev_sibling;
       assert(this->node!=0);
       if(this->node->parent==0 && this->node->prev_sibling==0) // head element
          this->node=0;
       }
    else {
       tree_node *par=this->node->parent;
       do {
          par=par->prev_sibling;
          if(par==0) { // FIXME: need to keep track of this!
             this->node=0;
             return *this;
             }
          } while(par->last_child==0);
       this->node=par->last_child;
       }
    return *this;
 }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::fixed_depth_iterator::operator++(int)
    {
    fixed_depth_iterator copy = *this;
    ++(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::fixed_depth_iterator::operator--(int)
 {
   fixed_depth_iterator copy = *this;
   --(*this);
   return copy;
 }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator-=(unsigned int num)
    {
    while(num>0) {
       --(*this);
       --(num);
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator+=(unsigned int num)
    {
    while(num>0) {
       ++(*this);
       --(num);
       }
    return *this;
    }
 
 // FIXME: add the other members of fixed_depth_iterator.
 
 
 // Sibling iterator
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator()
    : iterator_base()
    {
    set_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator(tree_node *tn)
    : iterator_base(tn)
    {
    set_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator(const iterator_base& other)
    : iterator_base(other.node)
    {
    set_parent_();
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator(const sibling_iterator& other)
    : iterator_base(other), parent_(other.parent_)
    {
    }
 
 template <class T, class tree_node_allocator>
 void tree<T, tree_node_allocator>::sibling_iterator::set_parent_()
    {
    parent_=0;
    if(this->node==0) return;
    if(this->node->parent!=0)
       parent_=this->node->parent;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator++()
    {
    if(this->node)
       this->node=this->node->next_sibling;
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator--()
    {
    if(this->node) this->node=this->node->prev_sibling;
    else {
       assert(parent_);
       this->node=parent_->last_child;
       }
    return *this;
 }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::sibling_iterator::operator++(int)
    {
    sibling_iterator copy = *this;
    ++(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::sibling_iterator::operator--(int)
    {
    sibling_iterator copy = *this;
    --(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator+=(unsigned int num)
    {
    while(num>0) {
       ++(*this);
       --num;
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator-=(unsigned int num)
    {
    while(num>0) {
       --(*this);
       --num;
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::tree_node *tree<T, tree_node_allocator>::sibling_iterator::range_first() const
    {
    tree_node *tmp=parent_->first_child;
    return tmp;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::tree_node *tree<T, tree_node_allocator>::sibling_iterator::range_last() const
    {
    return parent_->last_child;
    }
 
 // Leaf iterator
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::leaf_iterator::leaf_iterator()
    : iterator_base(0)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::leaf_iterator::leaf_iterator(tree_node *tn)
    : iterator_base(tn)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::leaf_iterator::leaf_iterator(const iterator_base &other)
    : iterator_base(other.node)
    {
    }
 
 template <class T, class tree_node_allocator>
 tree<T, tree_node_allocator>::leaf_iterator::leaf_iterator(const sibling_iterator& other)
    : iterator_base(other.node)
    {
    if(this->node==0) {
       if(other.range_last()!=0)
          this->node=other.range_last();
       else
          this->node=other.parent_;
       ++(*this);
       }
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator& tree<T, tree_node_allocator>::leaf_iterator::operator++()
    {
    assert(this->node!=0);
    while(this->node->next_sibling==0) {
       if (this->node->parent==0) return *this;
       this->node=this->node->parent;
       }
    this->node=this->node->next_sibling;
    while(this->node->first_child)
       this->node=this->node->first_child;
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator& tree<T, tree_node_allocator>::leaf_iterator::operator--()
    {
    assert(this->node!=0);
    while (this->node->prev_sibling==0) {
       if (this->node->parent==0) return *this;
       this->node=this->node->parent;
       }
    this->node=this->node->prev_sibling;
    while(this->node->last_child)
       this->node=this->node->last_child;
    return *this;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator tree<T, tree_node_allocator>::leaf_iterator::operator++(int)
    {
    leaf_iterator copy = *this;
    ++(*this);
    return copy;
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator tree<T, tree_node_allocator>::leaf_iterator::operator--(int)
    {
    leaf_iterator copy = *this;
    --(*this);
    return copy;
    }
 
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator& tree<T, tree_node_allocator>::leaf_iterator::operator+=(unsigned int num)
    {
    while(num>0) {
       ++(*this);
       --num;
       }
    return (*this);
    }
 
 template <class T, class tree_node_allocator>
 typename tree<T, tree_node_allocator>::leaf_iterator& tree<T, tree_node_allocator>::leaf_iterator::operator-=(unsigned int num)
    {
    while(num>0) {
       --(*this);
       --num;
       }
    return (*this);
    }
 
 #endif
 
 // Local variables:
 // default-tab-width: 3
 // End:
diff --git a/src/backend/datapicker/Segment.cpp b/src/backend/datapicker/Segment.cpp
index fc5e6cf60..e68ad4d14 100644
--- a/src/backend/datapicker/Segment.cpp
+++ b/src/backend/datapicker/Segment.cpp
@@ -1,217 +1,217 @@
 /***************************************************************************
     File                 : Segment.cpp
     Project              : LabPlot
     Description          : Graphics-item for curve of Datapicker
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Ankit Wagadre (wagadre.ankit@gmail.com)
  ***************************************************************************/
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "Segment.h"
 #include "SegmentPrivate.h"
 #include "backend/datapicker/DatapickerImage.h"
 #include "backend/datapicker/DatapickerPoint.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/datapicker/Datapicker.h"
 
 #include <QPainter>
 #include <QGraphicsScene>
 #include <QDesktopWidget>
 
 #include <KLocale>
 
 /**
  * \class Segment
  * \brief graphics-item class for curve-segment
  */
 
 Segment::Segment(DatapickerImage* image):
 	yLast(0), length(0), m_image(image), d_ptr(new SegmentPrivate(this)) {
 	m_image->scene()->addItem(this->graphicsItem());
 	init();
 }
 
 Segment::~Segment() {
 }
 
 void Segment::init() {
 	Q_D(Segment);
 	d->scaleFactor = Worksheet::convertToSceneUnits(1, Worksheet::Inch)/QApplication::desktop()->physicalDpiX();
 }
 
 QGraphicsItem* Segment::graphicsItem() const {
 	return d_ptr;
 }
 
 void Segment::setParentGraphicsItem(QGraphicsItem* item) {
 	Q_D(Segment);
 	d->setParentItem(item);
 }
 
 void Segment::retransform() {
 	Q_D(Segment);
 	d->retransform();
 }
 
 bool Segment::isVisible() const {
 	Q_D(const Segment);
 	return d->isVisible();
 }
 
 void Segment::setVisible(bool on) {
 	Q_D(Segment);
 	d->setVisible(on);
 }
 
 //##############################################################################
 //####################### Private implementation ###############################
 //##############################################################################
 SegmentPrivate::SegmentPrivate(Segment *owner)
 	: m_hovered(false),
 	  q(owner) {
 	setFlag(QGraphicsItem::ItemIsSelectable);
 	setFlag(QGraphicsItem::ItemSendsGeometryChanges);
 	setAcceptHoverEvents(true);
 	setVisible(false);
 }
 
 /*!
     calculates the position and the bounding box of the item. Called on geometry or properties changes.
  */
 void SegmentPrivate::retransform() {
 	for (auto* line : q->path) {
 		linePath.moveTo(line->p1());
 		linePath.lineTo(line->p2());
 	}
 	boundingRectangle = linePath.boundingRect();
 	recalcShapeAndBoundingRect();
 }
 
 /*!
     Returns the outer bounds of the item as a rectangle.
  */
 QRectF SegmentPrivate::boundingRect() const {
 	return transformedBoundingRectangle;
 }
 
 /*!
     Returns the shape of this item as a QPainterPath in local coordinates.
 */
 QPainterPath SegmentPrivate::shape() const {
 	return itemShape;
 }
 
 /*!
   recalculates the outer bounds and the shape of the item.
 */
 void SegmentPrivate::recalcShapeAndBoundingRect() {
 	prepareGeometryChange();
 	QMatrix matrix;
 	matrix.scale(scaleFactor, scaleFactor);
 	transformedBoundingRectangle = matrix.mapRect(boundingRectangle);
 	itemShape = QPainterPath();
 	itemShape.addRect(transformedBoundingRectangle);
 }
 
 void SegmentPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget * widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	QPen pen(Qt::green);
 	QPen hoveredPen = QPen(QColor(128,179,255), 3, Qt::SolidLine);
-	float hoveredOpacity = 0.6;
+	qreal hoveredOpacity = 0.6;
 	QPen selectedPen = QPen(Qt::darkBlue, 3, Qt::SolidLine);
-	float selectedOpacity = 0.3;
+	qreal selectedOpacity = 0.3;
 
 	painter->save();
 	painter->setPen(pen);
 	painter->scale(scaleFactor, scaleFactor);
 	painter->drawPath(linePath);
 	painter->restore();
 
 	if (m_hovered && !isSelected()) {
 		painter->setPen(hoveredPen);
 		painter->setOpacity(hoveredOpacity);
 		painter->drawPath(itemShape);
 	}
 
 	if (isSelected()) {
 		painter->setPen(selectedPen);
 		painter->setOpacity(selectedOpacity);
 		painter->drawPath(itemShape);
 	}
 }
 
 void SegmentPrivate::hoverEnterEvent(QGraphicsSceneHoverEvent*) {
 	if (!isSelected()) {
 		m_hovered = true;
 		update();
 	}
 }
 
 void SegmentPrivate::hoverLeaveEvent(QGraphicsSceneHoverEvent*) {
 	if (m_hovered) {
 		m_hovered = false;
 		update();
 	}
 }
 
 QVariant SegmentPrivate::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) {
 	if ( change == QGraphicsItem::ItemSelectedChange && value == true ) {
 		Datapicker* datapicker = dynamic_cast<Datapicker*>(q->m_image->parentAspect());
 		Q_ASSERT(datapicker);
 		if (datapicker->activeCurve()) {
 			int count = 0;
 			QList<QPointF> posList;
 			posList.clear();
 			for (QLine* line : q->path) {
 				const int l = (line->y1() > line->y2())?line->y2():line->y1();
 				const int h = (line->y1() > line->y2())?line->y1():line->y2();
 
 				for (int i = l; i <= h; ++i) {
 					if (count%q->m_image->pointSeparation() == 0) {
 						bool positionUsed = false;
 						const QVector<DatapickerPoint*> curvePointsList = datapicker->activeCurve()->children<DatapickerPoint>(AbstractAspect::IncludeHidden);
 						for (const auto* point : curvePointsList) {
 							if ( point->position() == QPoint(line->x1(), i)*scaleFactor )
 								positionUsed = true;
 						}
 
 						if (!positionUsed)
 							posList<<QPoint(line->x1(), i)*scaleFactor;
 					}
 					count++;
 				}
 			}
 
 			if (!posList.isEmpty()) {
 				datapicker->activeCurve()->beginMacro(i18n("%1: draw points over segment", datapicker->activeCurve()->name()));
 				for (const QPointF& pos : posList)
 					datapicker->addNewPoint(pos, datapicker->activeCurve());
 				datapicker->activeCurve()->endMacro();
 			}
 		}
 
 		//no need to keep segment selected
 		return false;
 	}
 
 	return QGraphicsItem::itemChange(change, value);
 }
diff --git a/src/backend/worksheet/plots/cartesian/CartesianPlot.h b/src/backend/worksheet/plots/cartesian/CartesianPlot.h
index d93014ebd..ffcb95af0 100644
--- a/src/backend/worksheet/plots/cartesian/CartesianPlot.h
+++ b/src/backend/worksheet/plots/cartesian/CartesianPlot.h
@@ -1,283 +1,283 @@
 
 /***************************************************************************
     File                 : CartesianPlot.h
     Project              : LabPlot
     Description          : Cartesian plot
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2017 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef CARTESIANPLOT_H
 #define CARTESIANPLOT_H
 
 #include "backend/worksheet/plots/AbstractPlot.h"
 #include "backend/worksheet/plots/cartesian/Histogram.h"
 
 #include <math.h>
 
 class QDropEvent;
 class QToolBar;
 class CartesianPlotPrivate;
 class CartesianPlotLegend;
 class AbstractColumn;
 class XYCurve;
 class XYEquationCurve;
 class XYDataReductionCurve;
 class XYDifferentiationCurve;
 class XYIntegrationCurve;
 class XYInterpolationCurve;
 class XYSmoothCurve;
 class XYFitCurve;
 class XYFourierFilterCurve;
 class KConfig;
 class XYFourierTransformCurve;
 
 class CartesianPlot:public AbstractPlot {
 	Q_OBJECT
 
 public:
 	explicit CartesianPlot(const QString &name);
 	virtual ~CartesianPlot();
 
 	enum Scale {ScaleLinear, ScaleLog10, ScaleLog2, ScaleLn, ScaleSqrt, ScaleX2};
 	enum Type {FourAxes, TwoAxes, TwoAxesCentered, TwoAxesCenteredZero};
 	enum RangeType {RangeFree, RangeLast, RangeFirst};
 	enum RangeBreakStyle {RangeBreakSimple, RangeBreakVertical, RangeBreakSloped};
 	enum MouseMode {SelectionMode, ZoomSelectionMode, ZoomXSelectionMode, ZoomYSelectionMode};
 	enum NavigationOperation {ScaleAuto, ScaleAutoX, ScaleAutoY, ZoomIn, ZoomOut, ZoomInX, ZoomOutX,
 	                          ZoomInY, ZoomOutY, ShiftLeftX, ShiftRightX, ShiftUpY, ShiftDownY
 	                         };
 
 	struct RangeBreak {
 		RangeBreak() : start(NAN), end(NAN), position(0.5), style(RangeBreakSloped) {}
 		bool isValid() const {
 			return (!std::isnan(start) && !std::isnan(end));
 		}
-		float start;
-		float end;
-		float position;
+		double start;
+		double end;
+		double position;
 		RangeBreakStyle style;
 	};
 
 	//simple wrapper for QList<RangeBreaking> in order to get our macros working
 	struct RangeBreaks {
 		RangeBreaks() : lastChanged(-1) {
 			RangeBreak b;
 			list << b;
 		};
 		QList<RangeBreak> list;
 		int lastChanged;
 	};
 
 	void initDefault(Type = FourAxes);
 	QIcon icon() const override;
 	QMenu* createContextMenu() override;
 	QMenu* analysisMenu();
 	void setRect(const QRectF&) override;
 	QRectF plotRect();
 	void setMouseMode(const MouseMode);
 	MouseMode mouseMode() const;
 	void navigate(NavigationOperation);
 	void setSuppressDataChangedSignal(bool);
 	const QList<QColor>& themeColorPalette() const;
 	void processDropEvent(QDropEvent*);
 
 	virtual void save(QXmlStreamWriter*) const override;
 	virtual bool load(XmlStreamReader*, bool preview) override;
 	virtual void loadThemeConfig(const KConfig&) override;
 	void saveTheme(KConfig& config);
 
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeType, rangeType, RangeType)
 	BASIC_D_ACCESSOR_DECL(int, rangeLastValues, RangeLastValues)
 	BASIC_D_ACCESSOR_DECL(int, rangeFirstValues, RangeFirstValues)
 	BASIC_D_ACCESSOR_DECL(bool, autoScaleX, AutoScaleX)
 	BASIC_D_ACCESSOR_DECL(bool, autoScaleY, AutoScaleY)
 	BASIC_D_ACCESSOR_DECL(double, xMin, XMin)
 	BASIC_D_ACCESSOR_DECL(double, xMax, XMax)
 	BASIC_D_ACCESSOR_DECL(double, yMin, YMin)
 	BASIC_D_ACCESSOR_DECL(double, yMax, YMax)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::Scale, xScale, XScale)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::Scale, yScale, YScale)
 	BASIC_D_ACCESSOR_DECL(bool, xRangeBreakingEnabled, XRangeBreakingEnabled)
 	BASIC_D_ACCESSOR_DECL(bool, yRangeBreakingEnabled, YRangeBreakingEnabled)
 	CLASS_D_ACCESSOR_DECL(RangeBreaks, xRangeBreaks, XRangeBreaks)
 	CLASS_D_ACCESSOR_DECL(RangeBreaks, yRangeBreaks, YRangeBreaks)
 
 	QString theme() const;
 
 	typedef CartesianPlotPrivate Private;
 
 public slots:
 	void setTheme(const QString&);
 
 private:
 	void init();
 	void initActions();
 	void initMenus();
 	void setColorPalette(const KConfig&);
 	const XYCurve* currentCurve() const;
 
 	CartesianPlotLegend* m_legend;
-	float m_zoomFactor;
+	double m_zoomFactor;
 	QList<QColor> m_themeColorPalette;
 	bool m_menusInitialized;
 
 	QAction* visibilityAction;
 
 	//"add new" actions
 	QAction* addCurveAction;
 	QAction* addEquationCurveAction;
 	QAction* addHistogramPlot;
 	QAction* addDataReductionCurveAction;
 	QAction* addDifferentiationCurveAction;
 	QAction* addIntegrationCurveAction;
 	QAction* addInterpolationCurveAction;
 	QAction* addSmoothCurveAction;
 	QAction* addFitCurveAction;
 	QAction* addFourierFilterCurveAction;
 	QAction* addFourierTransformCurveAction;
 	QAction* addHorizontalAxisAction;
 	QAction* addVerticalAxisAction;
 	QAction* addLegendAction;
 	QAction* addCustomPointAction;
 
 	//scaling, zooming, navigation actions
 	QAction* scaleAutoXAction;
 	QAction* scaleAutoYAction;
 	QAction* scaleAutoAction;
 	QAction* zoomInAction;
 	QAction* zoomOutAction;
 	QAction* zoomInXAction;
 	QAction* zoomOutXAction;
 	QAction* zoomInYAction;
 	QAction* zoomOutYAction;
 	QAction* shiftLeftXAction;
 	QAction* shiftRightXAction;
 	QAction* shiftUpYAction;
 	QAction* shiftDownYAction;
 
 	//analysis menu actions
 	QAction* addDataOperationAction;
 	QAction* addDataReductionAction;
 	QAction* addDifferentiationAction;
 	QAction* addIntegrationAction;
 	QAction* addInterpolationAction;
 	QAction* addSmoothAction;
 	QVector <QAction *> addFitAction;
 	QAction* addFourierFilterAction;
 
 	QMenu* addNewMenu;
 	QMenu* zoomMenu;
 	QMenu* dataAnalysisMenu;
 	QMenu* themeMenu;
 
 	Q_DECLARE_PRIVATE(CartesianPlot)
 
 public slots:
 	void addHorizontalAxis();
 	void addVerticalAxis();
 	void addCurve();
 	void addHistogram();
 	void addEquationCurve();
 	void addDataReductionCurve();
 	void addDifferentiationCurve();
 	void addIntegrationCurve();
 	void addInterpolationCurve();
 	void addSmoothCurve();
 	void addFitCurve();
 	void addFourierFilterCurve();
 	void addFourierTransformCurve();
 	void addLegend();
 	void addCustomPoint();
 	void scaleAuto();
 	void scaleAutoX();
 	void scaleAutoY();
 	void zoomIn();
 	void zoomOut();
 	void zoomInX();
 	void zoomOutX();
 	void zoomInY();
 	void zoomOutY();
 	void shiftLeftX();
 	void shiftRightX();
 	void shiftUpY();
 	void shiftDownY();
 	void dataChanged();
 
 private slots:
 	void updateLegend();
 	void childAdded(const AbstractAspect*);
 	void childRemoved(const AbstractAspect* parent, const AbstractAspect* before, const AbstractAspect* child);
 
 	void xDataChanged();
 	void yDataChanged();
 	void HistogramdataChanged();
 	void xHistogramDataChanged();
 	void yHistogramDataChanged();
 	void curveVisibilityChanged();
 
 	//SLOTs for changes triggered via QActions in the context menu
 	void visibilityChanged();
 	void loadTheme(const QString&);
 
 protected:
 	CartesianPlot(const QString &name, CartesianPlotPrivate *dd);
 
 signals:
 	friend class CartesianPlotSetCRangeTypeCmd;
 	friend class CartesianPlotSetCRangeLastValuesCmd;
 	friend class CartesianPlotSetCRangeFirstValuesCmd;
 	friend class CartesianPlotSetRectCmd;
 	friend class CartesianPlotSetAutoScaleXCmd;
 	friend class CartesianPlotSetXMinCmd;
 	friend class CartesianPlotSetXMaxCmd;
 	friend class CartesianPlotSetXScaleCmd;
 	friend class CartesianPlotSetAutoScaleYCmd;
 	friend class CartesianPlotSetYMinCmd;
 	friend class CartesianPlotSetYMaxCmd;
 	friend class CartesianPlotSetYScaleCmd;
 	friend class CartesianPlotSetXRangeBreakingEnabledCmd;
 	friend class CartesianPlotSetYRangeBreakingEnabledCmd;
 	friend class CartesianPlotSetXRangeBreaksCmd;
 	friend class CartesianPlotSetYRangeBreaksCmd;
 	friend class CartesianPlotSetThemeCmd;
 	void rangeTypeChanged(CartesianPlot::RangeType);
 	void rangeLastValuesChanged(int);
 	void rangeFirstValuesChanged(int);
 	void rectChanged(QRectF&);
 	void xAutoScaleChanged(bool);
 	void xMinChanged(double);
 	void xMaxChanged(double);
 	void xScaleChanged(int);
 	void yAutoScaleChanged(bool);
 	void yMinChanged(double);
 	void yMaxChanged(double);
 	void yScaleChanged(int);
 	void xRangeBreakingEnabledChanged(bool);
 	void xRangeBreaksChanged(const CartesianPlot::RangeBreaks&);
 	void yRangeBreakingEnabledChanged(bool);
 	void yRangeBreaksChanged(const CartesianPlot::RangeBreaks&);
 	void themeChanged(const QString&);
 };
 
 #endif
diff --git a/src/commonfrontend/worksheet/WorksheetView.h b/src/commonfrontend/worksheet/WorksheetView.h
index e81157a0c..58829dc7c 100644
--- a/src/commonfrontend/worksheet/WorksheetView.h
+++ b/src/commonfrontend/worksheet/WorksheetView.h
@@ -1,272 +1,272 @@
 /***************************************************************************
     File                 : WorksheetView.h
     Project              : LabPlot
     Description          : Worksheet view
     --------------------------------------------------------------------
     Copyright            : (C) 2009-2016 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef WORKSHEETVIEW_H
 #define WORKSHEETVIEW_H
 
 #include <QGraphicsView>
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include <QtPrintSupport/QPrinter>
 
 class QMenu;
 class QToolBar;
 class QToolButton;
 class QWheelEvent;
 class QTimeLine;
 
 class AbstractAspect;
 class WorksheetElement;
 
 class WorksheetView : public QGraphicsView {
 	Q_OBJECT
 
 public:
 	explicit WorksheetView(Worksheet* worksheet);
 
 	enum ExportFormat {Pdf, Svg, Png};
 	enum GridStyle {NoGrid, LineGrid, DotGrid};
 	enum ExportArea {ExportBoundingBox, ExportSelection, ExportWorksheet};
 
 	struct GridSettings {
 		GridStyle style;
 		QColor color;
 		int horizontalSpacing;
 		int verticalSpacing;
-		float opacity;
+		double opacity;
 	};
 
 	void setScene(QGraphicsScene*);
 	void exportToFile(const QString&, const ExportFormat, const ExportArea, const bool, const int);
 	void exportToClipboard();
 	void setIsClosing();
 	void setIsBeingPresented(bool presenting);
 
 private:
 	enum MouseMode {SelectionMode, NavigationMode, ZoomSelectionMode};
 	enum CartesianPlotActionMode {ApplyActionToSelection, ApplyActionToAll};
 
 	void initActions();
 	void initMenus();
 	void processResize();
 	void drawForeground(QPainter*, const QRectF&) override;
 	void drawBackground(QPainter*, const QRectF&) override;
 	void drawBackgroundItems(QPainter*, const QRectF&);
 	bool isPlotAtPos(const QPoint&) const;
 	CartesianPlot* plotAt(const QPoint&) const;
 	void exportPaint(QPainter* painter, const QRectF& targetRect, const QRectF& sourceRect, const bool);
 	void cartesianPlotAdd(CartesianPlot*, QAction*);
 
 	//events
 	virtual void resizeEvent(QResizeEvent*) override;
 	virtual void contextMenuEvent(QContextMenuEvent*) override;
 	virtual void wheelEvent(QWheelEvent*) override;
 	virtual void mousePressEvent(QMouseEvent*) override;
 	virtual void mouseReleaseEvent(QMouseEvent*) override;
 	virtual void mouseMoveEvent(QMouseEvent*) override;
 	virtual void keyPressEvent(QKeyEvent*) override;
 	virtual void dragEnterEvent(QDragEnterEvent*) override;
 	virtual void dragMoveEvent(QDragMoveEvent*) override;
 	virtual void dropEvent(QDropEvent*) override;
 
 	Worksheet* m_worksheet;
 	MouseMode m_mouseMode;
 	CartesianPlotActionMode m_cartesianPlotActionMode;
 	CartesianPlot::MouseMode m_cartesianPlotMouseMode;
 	bool m_selectionBandIsShown;
 	QPoint m_selectionStart;
 	QPoint m_selectionEnd;
 	int magnificationFactor;
 	QGraphicsPixmapItem* m_magnificationWindow;
 	GridSettings m_gridSettings;
 	QList<QGraphicsItem*> m_selectedItems;
 	bool m_suppressSelectionChangedEvent;
 	WorksheetElement* lastAddedWorksheetElement;
 	QTimeLine* m_fadeInTimeLine;
 	QTimeLine* m_fadeOutTimeLine;
 	bool m_isClosing;
 	bool m_menusInitialized;
 
 	//Menus
 	QMenu* m_addNewMenu;
 	QMenu* m_addNewCartesianPlotMenu;
 	QMenu* m_zoomMenu;
 	QMenu* m_magnificationMenu;
 	QMenu* m_layoutMenu;
 	QMenu* m_gridMenu;
 	QMenu* m_themeMenu;
 	QMenu* m_viewMouseModeMenu;
 	QMenu* m_cartesianPlotMenu;
 	QMenu* m_cartesianPlotMouseModeMenu;
 	QMenu* m_cartesianPlotAddNewMenu;
 	QMenu* m_cartesianPlotZoomMenu;
 	QMenu* m_cartesianPlotActionModeMenu;
 	QMenu* m_dataManipulationMenu;
 
 	QToolButton* tbNewCartesianPlot;
 	QToolButton* tbZoom;
 	QToolButton* tbMagnification;
 	QAction* currentZoomAction;
 	QAction* currentMagnificationAction;
 
 	//Actions
 	QAction* selectAllAction;
 	QAction* deleteAction;
 	QAction* backspaceAction;
 
 	QAction* zoomInViewAction;
 	QAction* zoomOutViewAction;
 	QAction* zoomOriginAction;
 	QAction* zoomFitPageHeightAction;
 	QAction* zoomFitPageWidthAction;
 	QAction* zoomFitSelectionAction;
 
 	QAction* navigationModeAction;
 	QAction* zoomSelectionModeAction;
 	QAction* selectionModeAction;
 
 	QAction* addCartesianPlot1Action;
 	QAction* addCartesianPlot2Action;
 	QAction* addCartesianPlot3Action;
 	QAction* addCartesianPlot4Action;
 	QAction* addTextLabelAction;
 	QAction* addHistogram;
 	QAction* addBarChartPlot;
 
 	QAction* verticalLayoutAction;
 	QAction* horizontalLayoutAction;
 	QAction* gridLayoutAction;
 	QAction* breakLayoutAction;
 
 	QAction* noGridAction;
 	QAction* denseLineGridAction;
 	QAction* sparseLineGridAction;
 	QAction* denseDotGridAction;
 	QAction* sparseDotGridAction;
 	QAction* customGridAction;
 	QAction* snapToGridAction;
 
 	QAction* noMagnificationAction;
 	QAction* twoTimesMagnificationAction;
 	QAction* threeTimesMagnificationAction;
 	QAction* fourTimesMagnificationAction;
 	QAction* fiveTimesMagnificationAction;
 
 	QAction* showPresenterMode;
 	//Actions for cartesian plots
 	QAction* cartesianPlotApplyToSelectionAction;
 	QAction* cartesianPlotApplyToAllAction;
 	QAction* cartesianPlotSelectionModeAction;
 	QAction* cartesianPlotZoomSelectionModeAction;
 	QAction* cartesianPlotZoomXSelectionModeAction;
 	QAction* cartesianPlotZoomYSelectionModeAction;
 
 	QAction* addCurveAction;
 	QAction* addEquationCurveAction;
 	QAction* addDataOperationCurveAction;
 	QAction* addDataReductionCurveAction;
 	QAction* addDifferentiationCurveAction;
 	QAction* addIntegrationCurveAction;
 	QAction* addInterpolationCurveAction;
 	QAction* addSmoothCurveAction;
 	QAction* addFitCurveAction;
 	QAction* addFourierFilterCurveAction;
 	QAction* addFourierTransformCurveAction;
 	QAction* addHorizontalAxisAction;
 	QAction* addVerticalAxisAction;
 	QAction* addLegendAction;
 	QAction* addCustomPointAction;
 
 	QAction* scaleAutoXAction;
 	QAction* scaleAutoYAction;
 	QAction* scaleAutoAction;
 	QAction* zoomInAction;
 	QAction* zoomOutAction;
 	QAction* zoomInXAction;
 	QAction* zoomOutXAction;
 	QAction* zoomInYAction;
 	QAction* zoomOutYAction;
 	QAction* shiftLeftXAction;
 	QAction* shiftRightXAction;
 	QAction* shiftUpYAction;
 	QAction* shiftDownYAction;
 
 	// Analysis menu
 	QAction* addDataOperationAction;
 	QAction* addDataReductionAction;
 	QAction* addDifferentiationAction;
 	QAction* addIntegrationAction;
 	QAction* addInterpolationAction;
 	QAction* addSmoothAction;
 	QAction* addFitAction;
 	QAction* addFourierFilterAction;
 	QAction* addFourierTransformAction;
 
 public slots:
 	void createContextMenu(QMenu*);
 	void createAnalysisMenu(QMenu*);
 	void fillToolBar(QToolBar*);
 	void fillCartesianPlotToolBar(QToolBar*);
 	void print(QPrinter*);
 	void selectItem(QGraphicsItem*);
 	void presenterMode();
 
 private slots:
 	void addNew(QAction*);
 	void aspectAboutToBeRemoved(const AbstractAspect*);
 	void selectAllElements();
 	void deleteElement();
 
 	void mouseModeChanged(QAction*);
 	void useViewSizeRequested();
 	void changeZoom(QAction*);
 	void magnificationChanged(QAction*);
 	void changeLayout(QAction*);
 	void changeGrid(QAction*);
 	void changeSnapToGrid();
 
 	void deselectItem(QGraphicsItem*);
 	void selectionChanged();
 	void updateBackground();
 	void layoutChanged(Worksheet::Layout);
 
 	void fadeIn(qreal);
 	void fadeOut(qreal);
 
 	//SLOTs for cartesian plots
 	void cartesianPlotActionModeChanged(QAction*);
 	void cartesianPlotMouseModeChanged(QAction*);
 	void cartesianPlotNavigationChanged(QAction*);
 	void cartesianPlotAddNew(QAction*);
 	void handleCartesianPlotActions();
 
 signals:
 	void statusInfo(const QString&);
 };
 
 #endif
diff --git a/src/kdefrontend/datasources/ImportOpj.cpp b/src/kdefrontend/datasources/ImportOpj.cpp
index 974681a9c..8e4fd985d 100644
--- a/src/kdefrontend/datasources/ImportOpj.cpp
+++ b/src/kdefrontend/datasources/ImportOpj.cpp
@@ -1,718 +1,719 @@
 /***************************************************************************
     File                 : ImportOpj.cpp
     Project              : LabPlot
     Description          : Import Origin project
     --------------------------------------------------------------------
     Copyright            : (C) 2017 Stefan Gerlach (stefan.gerlach@uni.kn)
 	adapted from SciDAVis (importOPJ.cpp)
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "ImportOpj.h"
 #include "backend/lib/macros.h"
 #include "backend/core/Project.h"
 #include "backend/core/Workbook.h"
 #include "backend/core/column/Column.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/note/Note.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlotLegend.h"
 #include "backend/worksheet/TextLabel.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 
 #include <liborigin/OriginFile.h>
 
 #include <QProgressBar>
 #include <QStatusBar>
 #include <algorithm>
 
 /*!
     \class ImportOpj
     \brief Importing an Origin project.
 
 	\ingroup kdefrontend
  */
 ImportOpj::ImportOpj(Folder *folder, const QString& filename, bool preview) : p(folder) {
 	Q_UNUSED(preview);
 	DEBUG("Opj import started ...");
 
 	OriginFile opj((const char *)filename.toLocal8Bit());
 	int status = opj.parse();
-	DEBUG("Parsing done with status " << status);
+	WARNING("Parsing done with status " << status);
 //	if (status != 0)
 //		return;
 	DEBUG("Starting conversion ...");
 
 	importTables(opj);
 //TODO	importGraphs(opj);
 //TODO	importNotes(opj);
 //      if(filename.endsWith(".opj", Qt::CaseInsensitive))
 //              createProjectTree(opj);
 
 }
 
 int ImportOpj::importTables(const OriginFile &opj) {
 	// excels (origin workbook with one or more sheets)
 	for (unsigned int e = 0; e < opj.excelCount(); ++e) {
 		DEBUG("Reading Spreadsheet " << e);
 			Origin::Excel excelwb = opj.excel(e);
 			if (excelwb.sheets.size() == 1) {	// single sheet -> spreadsheet
 				Origin::SpreadSheet spread = excelwb.sheets[0];
 				spread.name = excelwb.name;
 				spread.label = excelwb.label;
 				importSpreadsheet(0, opj, spread);
 			}
 			else {		// multiple sheets -> workbook
 				Workbook *workbook = new Workbook(0, excelwb.name.c_str() + QString(" - ") + excelwb.label.c_str());
 				for (unsigned int s = 0; s < excelwb.sheets.size(); ++s) {
 					Origin::SpreadSheet spread = excelwb.sheets[s];
 					importSpreadsheet(workbook, opj, spread);
 				}
 				p->addChildFast(workbook);
 			}
 	}
 
 	// matrices
 	for (unsigned int m = 0; m < opj.matrixCount(); ++m) {
 		Origin::Matrix matrix = opj.matrix(m);
 		importMatrix(opj, matrix);
 	}
 
 	return 0;
 }
 
 int ImportOpj::importSpreadsheet(Workbook* workbook, const OriginFile &opj, const Origin::SpreadSheet &spread) {
 	Q_UNUSED(opj);
 	int cols = spread.columns.size();
 	int rows = spread.maxRows;
 	//TODO
 	if (rows > 1000)
 		rows = 1000;
 	if (!cols) // do not create spreadsheet without columns
 		return -1;
 
 	//TODO QLocale locale = mw->locale();
 	Spreadsheet* spreadsheet;
 	if (workbook == 0 && spread.label.length() > 0)	// single sheet with label (long name)
 		spreadsheet = new Spreadsheet(0, spread.name.c_str() + QString(" - ") + spread.label.c_str());
 	else			// multiple sheets (TODO: name of sheets are not saved in liborigin: "Sheet1", "Sheet2", ...)
 		spreadsheet = new Spreadsheet(0, spread.name.c_str());
 	DEBUG("OK rows = " << rows);
 	spreadsheet->setRowCount(rows);
 	DEBUG("OK DONE");
 	spreadsheet->setColumnCount(cols);
 
 	int scaling_factor = 10; //in Origin width is measured in characters while here in pixels --- need to be accurate
 	for (int j = 0; j < cols; ++j) {
 		Origin::SpreadColumn column = spread.columns[j];
 		Column *col = spreadsheet->column(j);
 
 		QString name(column.name.c_str());
 		col->setName(name.replace(QRegExp(".*_"),""));
 		if (column.command.size() > 0)
 			col->setFormula(Interval<int>(0, rows), QString(column.command.c_str()));
 		col->setComment(QString(column.comment.c_str()));
 		col->setWidth((int)column.width * scaling_factor);
 
 		switch (column.type) {
 		case Origin::SpreadColumn::X:
 			col->setPlotDesignation(AbstractColumn::X);
 			break;
 		case Origin::SpreadColumn::Y:
 			col->setPlotDesignation(AbstractColumn::Y);
 			break;
 		case Origin::SpreadColumn::Z:
 			col->setPlotDesignation(AbstractColumn::Z);
 			break;
 		case Origin::SpreadColumn::XErr:
 			col->setPlotDesignation(AbstractColumn::XError);
 			break;
 		case Origin::SpreadColumn::YErr:
 			col->setPlotDesignation(AbstractColumn::YError);
 			break;
 		case Origin::SpreadColumn::Label:
 		case Origin::SpreadColumn::NONE:
 		default:
 			col->setPlotDesignation(AbstractColumn::NoDesignation);
 		}
 
 		QString format;
 		switch(column.valueType) {
 		case Origin::Numeric:
 		case Origin::TextNumeric: {
 			/* TODO: check this
 			A TextNumeric column in Origin is a column whose filled cells contain either a double or a string.
 			Here there is no equivalent column type.
 			Set the column type as 'Numeric' or 'Text' depending on the type of first element in column.
 			IDEA: Add a "per column" flag, settable at import dialog, to choose between both types.
 			 */
 			double datavalue;
 			bool setAsText = false;
 			col->setColumnMode(AbstractColumn::Numeric);
 			//printf("column has %ld rows\n", column.data.size());
 			for (int i = 0; i < std::min((int)column.data.size(), rows); ++i) {
 				Origin::variant v(column.data.at(i));
 				//printf("i=%d type = %d\n", i, v.type);
 				if (v.type() == Origin::Variant::V_DOUBLE) {
 					//printf("DOUBLE !\n");
 					datavalue = v.as_double();
 					//printf("datavalue = %g\n", datavalue);
 					if (datavalue == _ONAN) continue; // mark for empty cell
 					if (!setAsText)
 						col->setValueAt(i, datavalue);
 //TODO					else	// convert double to string for Text columns
 //						col->setTextAt(i, locale.toString(datavalue, 'g', 16));
 				} else if (v.type() == Origin::Variant::V_STRING) { // string
 					//printf("STRING !\n");
 					if (!setAsText && i == 0) {
 						col->setColumnMode(AbstractColumn::Text);
 						setAsText = true;
 					}
 					col->setTextAt(i, v.as_string());
 				} else {
 					printf("ERROR: data type = %d unknown!\n", v.type());
 				}
 			}
 			if (column.numericDisplayType != 0) {
 				int f = 0;
 				switch(column.valueTypeSpecification) {
 				case Origin::Decimal:
 					f=1;
 					break;
 				case Origin::Scientific:
 					f=2;
 					break;
 				case Origin::Engineering:
 				case Origin::DecimalWithMarks:
 					break;
 				}
 
 				Double2StringFilter *filter = static_cast<Double2StringFilter*>(col->outputFilter());
 				filter->setNumericFormat(f);
 				filter->setNumDigits(column.decimalPlaces);
 			}
 			break;
 		}
 		case Origin::Text:
 			col->setColumnMode(AbstractColumn::Text);
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setTextAt(i, column.data[i].as_string());
 			break;
 		case Origin::Time: {
 			switch(column.valueTypeSpecification + 128) {
 			case Origin::TIME_HH_MM:
 				format="hh:mm";
 				break;
 			case Origin::TIME_HH:
 				format="hh";
 				break;
 			case Origin::TIME_HH_MM_SS:
 				format="hh:mm:ss";
 				break;
 			case Origin::TIME_HH_MM_SS_ZZ:
 				format="hh:mm:ss.zzz";
 				break;
 			case Origin::TIME_HH_AP:
 				format="hh ap";
 				break;
 			case Origin::TIME_HH_MM_AP:
 				format="hh:mm ap";
 				break;
 			case Origin::TIME_MM_SS:
 				format="mm:ss";
 				break;
 			case Origin::TIME_MM_SS_ZZ:
 				format="mm:ss.zzz";
 				break;
 			case Origin::TIME_HHMM:
 				format="hhmm";
 				break;
 			case Origin::TIME_HHMMSS:
 				format="hhmmss";
 				break;
 			case Origin::TIME_HH_MM_SS_ZZZ:
 				format="hh:mm:ss.zzz";
 				break;
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::DateTime);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::Date: {
 			switch(column.valueTypeSpecification) {
 			case Origin::DATE_DD_MM_YYYY:
 				format="dd/MM/yyyy";
 				break;
 			case Origin::DATE_DD_MM_YYYY_HH_MM:
 				format="dd/MM/yyyy HH:mm";
 				break;
 			case Origin::DATE_DD_MM_YYYY_HH_MM_SS:
 				format="dd/MM/yyyy HH:mm:ss";
 				break;
 			case Origin::DATE_DDMMYYYY:
 			case Origin::DATE_DDMMYYYY_HH_MM:
 			case Origin::DATE_DDMMYYYY_HH_MM_SS:
 				format="dd.MM.yyyy";
 					break;
 			case Origin::DATE_MMM_D:
 				format="MMM d";
 				break;
 			case Origin::DATE_M_D:
 				format="M/d";
 				break;
 			case Origin::DATE_D:
 				format="d";
 				break;
 			case Origin::DATE_DDD:
 			case Origin::DATE_DAY_LETTER:
 				format="ddd";
 				break;
 			case Origin::DATE_YYYY:
 				format="yyyy";
 				break;
 			case Origin::DATE_YY:
 				format="yy";
 				break;
 			case Origin::DATE_YYMMDD:
 			case Origin::DATE_YYMMDD_HH_MM:
 			case Origin::DATE_YYMMDD_HH_MM_SS:
 			case Origin::DATE_YYMMDD_HHMM:
 			case Origin::DATE_YYMMDD_HHMMSS:
 				format="yyMMdd";
 				break;
 			case Origin::DATE_MMM:
 			case Origin::DATE_MONTH_LETTER:
 				format="MMM";
 				break;
 			case Origin::DATE_M_D_YYYY:
 				format="M-d-yyyy";
 				break;
 			default:
 				format="dd.MM.yyyy";
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::DateTime);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::Month: {
 			switch (column.valueTypeSpecification) {
 			case Origin::MONTH_MMM:
 				format = "MMM";
 				break;
 			case Origin::MONTH_MMMM:
 				format = "MMMM";
 				break;
 			case Origin::MONTH_LETTER:
 				format = "M";
 				break;
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::Month);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::Day: {
 			switch(column.valueTypeSpecification) {
 			case Origin::DAY_DDD:
 				format = "ddd";
 				break;
 			case Origin::DAY_DDDD:
 				format = "dddd";
 				break;
 			case Origin::DAY_LETTER:
 				format = "d";
 				break;
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::Day);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::ColumnHeading:
 		case Origin::TickIndexedDataset:
 		case Origin::Categorical:
 			break;
 		}
 	}
 
 	//TODO
 //	if (spread.hidden || spread.loose)
 //		mw->hideWindow(spreadsheet);
 
 	if (workbook == 0) // single sheet
 		p->addChildFast(spreadsheet);
 	else	// multiple sheets
 		workbook->addChild(spreadsheet);
 
 	return 0;
 }
 
 int ImportOpj::importMatrix(const OriginFile &opj, const Origin::Matrix &matrix) {
 	Q_UNUSED(opj);
 
 	unsigned int layers = matrix.sheets.size();
 	int scaling_factor = 10; //in Origin width is measured in characters while here in pixels --- need to be accurate
 	for (unsigned int l = 0; l < layers; ++l) {
 		Origin::MatrixSheet layer = matrix.sheets[l];
 		int colCount = layer.columnCount;
 		int rowCount = layer.rowCount;
 
 		Matrix* m = new Matrix(0, matrix.name.c_str());
 		m->setRowCount(rowCount);
 		m->setColumnCount(colCount);
 		if (!m)
 			return false;
 		m->setFormula(layer.command.c_str());
 		for (int j = 0; j < colCount; j++)
 			m->setColumnWidth(j, layer.width * scaling_factor);
 
 		for (int i = 0; i < rowCount; i++) {
 		for (int j = 0; j < colCount; j++) {
 			m->setCell(i, j, layer.data[j + i*colCount]);
 		}
 		}
 
 		char format = 'g';
 		int prec = 6;
 		switch (layer.valueTypeSpecification) {
 		case 0: //Decimal 1000
 			format='f';
 			prec = layer.decimalPlaces;
 			break;
 		case 1: //Scientific
 			format='e';
 			prec = layer.decimalPlaces;
 			break;
 		case 2: //Engineering
 		case 3: //Decimal 1,000
 			format='g';
 			prec = layer.significantDigits;
 			break;
 		}
 
 		//TODO: prec not support by Matrix
 		Q_UNUSED(prec);
 		m->setNumericFormat(format);
 
 		p->addChildFast(m);
 	}
 
 	return 0;
 }
 
 int ImportOpj::importNotes(const OriginFile &opj) {
 //	int visible_count = 0;
 	for(unsigned int n = 0; n < opj.noteCount(); ++n) {
 		Origin::Note _note = opj.note(n);
 		QString name = _note.name.c_str();
 		QRegExp rx("^@(\\S+)$");
 		if(rx.indexIn(name) == 0)
 			name = name.mid(2, name.length() - 3);
 		Note *note = new Note(name);
 		if(!note)
 			return -1;
 		//note->setWindowLabel(_note.label.c_str());
 		note->setNote(QString(_note.text.c_str()));
 
 		// TODO
 		//cascade the notes
 		//int dx = 20;
 		//int dy = note->parentWidget()->frameGeometry().height() - note->height();
 		//note->parentWidget()->move(QPoint(visible_count*dx+xoffset*OBJECTXOFFSET, visible_count*dy));
 
 		p->addChildFast(note);
 
 //		visible_count++;
 	}
 //	if(visible_count > 0)
 //		xoffset++;
 	return 0;
 }
 
 int ImportOpj::importGraphs(const OriginFile &opj) {
 	for(unsigned int g = 0; g < opj.graphCount(); ++g) {
 		Origin::Graph graph = opj.graph(g);
 		Worksheet *worksheet = new Worksheet(0, graph.name.c_str());
 		if (!worksheet)
 			return -1;
 
 //		worksheet->hide();//!hack used in order to avoid resize and repaint events
 		worksheet->setComment(graph.label.c_str());
 		for (const auto& layer: graph.layers) {
 			CartesianPlot* plot = new CartesianPlot("");
 			if (!plot)
 				return -2;
 
 			if (!layer.legend.text.empty()) {
 				CartesianPlotLegend* legend = new CartesianPlotLegend(plot, "");
 				TextLabel* title = new TextLabel(legend->name(), TextLabel::PlotLegendTitle);
 				DEBUG("TEXT =" << layer.legend.text.c_str());
 				QDEBUG("PARSED TEXT =" << parseOriginText(QString::fromLocal8Bit(layer.legend.text.c_str())));
 				title->setText(parseOriginText(QString::fromLocal8Bit(layer.legend.text.c_str())));
 				//legend->title() = title;
 				legend->addChild(title);
 				plot->addChild(legend);
 			}
 
 			// TODO: we only support one legend
 			//add texts
-			for (const auto &s: layer.texts)
+/*			for (const auto &s: layer.texts) {
 				DEBUG("EXTRA TEXT =" << s.text.c_str());
-			//	plot->newLegend(parseOriginText(QString::fromLocal8Bit(layer.texts[i].text.c_str())));
-
+			//	plot->newLegend(parseOriginText(QString::fromLocal8Bit(s.text.c_str())));
+			}
+*/
 // 			int auto_color = 0;
 // 			int style = 0;
 			for (const auto& curve: layer.curves) {
 				QString data(curve.dataName.c_str());
 // 				int color = 0;
 
 				switch(curve.type) {
 				case Origin::GraphCurve::Line:
 //					style = Graph::Line;
 					break;
 				case Origin::GraphCurve::Scatter:
 //					style = Graph::Scatter;
 					break;
 				case Origin::GraphCurve::LineSymbol:
 //					style = Graph::LineSymbols;
 					break;
 				case Origin::GraphCurve::ErrorBar:
 				case Origin::GraphCurve::XErrorBar:
 //					style = Graph::ErrorBars;
 					break;
 				case Origin::GraphCurve::Column:
 //					style = Graph::VerticalBars;
 					break;
 				case Origin::GraphCurve::Bar:
 //					style = Graph::HorizontalBars;
 					break;
 				case Origin::GraphCurve::Histogram:
 //					style = Graph::Histogram;
 					break;
 				default:
 					continue;
 				}
 
 /*				QString tableName;
 				switch(data[0].toAscii()) {
 				case 'T':
 				case 'E': {
 					tableName = data.right(data.length() - 2);
 					Table* table = mw->table(tableName);
 					if (!table)
 						break;
 					if(style == Graph::ErrorBars) {
 						int flags=_curve.symbolType;
 						graph->addErrorBars(QString("%1_%2").arg(tableName, _curve.xColumnName.c_str()), table, QString("%1_%2").arg(tableName, _curve.yColumnName.c_str()),
 							((flags&0x10)==0x10?0:1), ceil(_curve.lineWidth), ceil(_curve.symbolSize), QColor(Qt::black),
 							(flags&0x40)==0x40, (flags&2)==2, (flags&1)==1);
 					} else if(style == Graph::Histogram) {
 						graph->insertCurve(table, QString("%1_%2").arg(tableName, _curve.yColumnName.c_str()), style);
 					} else {
 						graph->insertCurve(table, QString("%1_%2").arg(tableName, _curve.xColumnName.c_str()), QString("%1_%2").arg(tableName, _curve.yColumnName.c_str()), style);
 					}
 					break;
 				}
 				//TODO
 				}
 */
 
 /*				CurveLayout cl = graph->initCurveLayout(style, layer.curves.size());
 				cl.sSize = ceil(_curve.symbolSize*0.5);
 				cl.penWidth = _curve.symbolThickness;
 				color = _curve.symbolColor.regular;
 				if((style == Graph::Scatter || style == Graph::LineSymbols) && color == 0xF7) // 0xF7 -Automatic color
 					color = auto_color++;
 				cl.symCol = color;
 				switch(_curve.symbolType & 0xFF) {
 				case 0: //NoSymbol
 					cl.sType = 0;
 					break;
 				//TODO
 				}
 */
 
 				//TODO
 
 			}
 
 			worksheet->addChild(plot);
 		}
 
 		p->addChildFast(worksheet);
 	}
 
 	return 0;
 }
 
 QString ImportOpj::parseOriginText(const QString &str) {
 	QStringList lines = str.split("\n");
 	QString text = "";
 	for (int i = 0; i < lines.size(); ++i) {
 		if(i > 0)
 			text.append("\n");
 		text.append(parseOriginTags(lines[i]));
 	}
 
 	return text;
 }
 
 QString strreverse(const QString &str) {	//QString reversing
 	QByteArray ba = str.toLocal8Bit();
 	std::reverse(ba.begin(), ba.end());
 
 	return QString(ba);
 }
 
 // taken from SciDAVis
 QString ImportOpj::parseOriginTags(const QString &str) {
 	QString line = str;
 
 	//replace \l(...) and %(...) tags
 	QRegExp rxline("\\\\\\s*l\\s*\\(\\s*\\d+\\s*\\)");
 	QRegExp rxcol("\\%\\(\\d+\\)");
 	int pos = rxline.indexIn(line);
 	while (pos > -1) {
 		QString value = rxline.cap(0);
 		int len=value.length();
 		value.replace(QRegExp(" "),"");
 		value="\\c{"+value.mid(3,value.length()-4)+"}";
 		line.replace(pos, len, value);
 		pos = rxline.indexIn(line);
 	}
 	//Lookbehind conditions are not supported - so need to reverse string
 	QRegExp rx("\\)[^\\)\\(]*\\((?!\\s*[buig\\+\\-]\\s*\\\\)");
 	QRegExp rxfont("\\)[^\\)\\(]*\\((?![^\\:]*\\:f\\s*\\\\)");
 	QString linerev = strreverse(line);
 	QString lBracket=strreverse("&lbracket;");
 	QString rBracket=strreverse("&rbracket;");
 	QString ltagBracket=strreverse("&ltagbracket;");
 	QString rtagBracket=strreverse("&rtagbracket;");
 	int pos1 = rx.indexIn(linerev);
 	int pos2 = rxfont.indexIn(linerev);
 
 	while (pos1>-1 || pos2>-1) {
 		if(pos1==pos2) {
 			QString value = rx.cap(0);
 			int len=value.length();
 			value=rBracket+value.mid(1,len-2)+lBracket;
 			linerev.replace(pos1, len, value);
 		}
 		else if ((pos1>pos2&&pos2!=-1)||pos1==-1) {
 			QString value = rxfont.cap(0);
 			int len=value.length();
 			value=rtagBracket+value.mid(1,len-2)+ltagBracket;
 			linerev.replace(pos2, len, value);
 		}
 		else if ((pos2>pos1&&pos1!=-1)||pos2==-1) {
 			QString value = rx.cap(0);
 			int len=value.length();
 			value=rtagBracket+value.mid(1,len-2)+ltagBracket;
 			linerev.replace(pos1, len, value);
 		}
 
 		pos1=rx.indexIn(linerev);
 		pos2=rxfont.indexIn(linerev);
 	}
 	linerev.replace(ltagBracket, "(");
 	linerev.replace(rtagBracket, ")");
 
 	line = strreverse(linerev);
 
 
 	//replace \b(...), \i(...), \u(...), \g(...), \+(...), \-(...), \f:font(...) tags
 	const QString rxstr[] = { "\\\\\\s*b\\s*\\(", "\\\\\\s*i\\s*\\(", "\\\\\\s*u\\s*\\(", "\\\\\\s*g\\s*\\(", "\\\\\\s*\\+\\s*\\(", "\\\\\\s*\\-\\s*\\(", "\\\\\\s*f\\:[^\\(]*\\("};
 
 	int postag[]={0,0,0,0,0,0,0};
 	QString ltag[]={"<b>","<i>","<u>","<font face=Symbol>","<sup>","<sub>","<font face=%1>"};
 	QString rtag[]={"</b>","</i>","</u>","</font>","</sup>","</sub>","</font>"};
 	QRegExp rxtags[7];
 	for(int i=0; i<7; ++i)
 		rxtags[i].setPattern(rxstr[i]+"[^\\(\\)]*\\)");
 
 	bool flag=true;
 	while(flag) {
 		for(int i=0; i<7; ++i) {
 			postag[i] = rxtags[i].indexIn(line);
 			while (postag[i] > -1) {
 				QString value = rxtags[i].cap(0);
-				int len=value.length();
-				int pos2=value.indexOf("(");
+				int len = value.length();
+				pos2 = value.indexOf("(");
 				if(i<6)
 					value=ltag[i]+value.mid(pos2+1,len-pos2-2)+rtag[i];
 				else
 				{
 					int posfont=value.indexOf("f:");
 					value=ltag[i].arg(value.mid(posfont+2,pos2-posfont-2))+value.mid(pos2+1,len-pos2-2)+rtag[i];
 				}
 				line.replace(postag[i], len, value);
 				postag[i] = rxtags[i].indexIn(line);
 			}
 		}
 		flag=false;
 		for(int i=0; i<7; ++i) {
 			if(rxtags[i].indexIn(line)>-1) {
 				flag=true;
 				break;
 			}
 		}
 	}
 
 	//replace unclosed tags
 	for(int i=0; i<6; ++i)
 		line.replace(QRegExp(rxstr[i]), ltag[i]);
 	rxfont.setPattern(rxstr[6]);
 	pos = rxfont.indexIn(line);
 	while (pos > -1) {
 		QString value = rxfont.cap(0);
 		int len=value.length();
 		int posfont=value.indexOf("f:");
 		value=ltag[6].arg(value.mid(posfont+2,len-posfont-3));
 		line.replace(pos, len, value);
 		pos = rxfont.indexIn(line);
 	}
 
 	line.replace("&lbracket;", "(");
 	line.replace("&rbracket;", ")");
 
 	return line;
 }
diff --git a/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp b/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp
index edfc0254c..1d0bd6e14 100644
--- a/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp
@@ -1,712 +1,712 @@
 /***************************************************************************
     File             : XYDataReductionCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright        : (C) 2017 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of data reduction curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "XYDataReductionCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYDataReductionCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 #include <QStatusBar>
 #include <QProgressBar>
 #ifndef NDEBUG
 #include <QDebug>
 #endif
 
 /*!
   \class XYDataReductionCurveDock
  \brief  Provides a widget for editing the properties of the XYDataReductionCurves
 		(2D-curves defined by an data reduction) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYDataReductionCurveDock::XYDataReductionCurveDock(QWidget* parent, QStatusBar* sb) : XYCurveDock(parent),
 	statusBar(sb),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_dataReductionCurve(nullptr) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYDataReductionCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
 	QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 3);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 3);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 3);
 
 	for (int i=0; i < NSL_GEOM_LINESIM_TYPE_COUNT; ++i)
 		uiGeneralTab.cbType->addItem(i18n(nsl_geom_linesim_type_name[i]));
 	uiGeneralTab.cbType->setItemData(nsl_geom_linesim_type_visvalingam_whyatt, i18n("This method is much slower than any other"), Qt::ToolTipRole);
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	QHBoxLayout* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, SIGNAL(returnPressed()), this, SLOT(nameChanged()) );
 	connect( uiGeneralTab.leComment, SIGNAL(returnPressed()), this, SLOT(commentChanged()) );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged()) );
 	connect( uiGeneralTab.chkAuto, SIGNAL(clicked(bool)), this, SLOT(autoToleranceChanged()) );
 	connect( uiGeneralTab.sbTolerance, SIGNAL(valueChanged(double)), this, SLOT(toleranceChanged()) );
 	connect( uiGeneralTab.chkAuto2, SIGNAL(clicked(bool)), this, SLOT(autoTolerance2Changed()) );
 	connect( uiGeneralTab.sbTolerance2, SIGNAL(valueChanged(double)), this, SLOT(tolerance2Changed()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYDataReductionCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size() == 1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	} else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_dataReductionCurve = dynamic_cast<XYDataReductionCurve*>(m_curve);
 	Q_ASSERT(m_dataReductionCurve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_dataReductionCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_dataReductionCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_dataReductionCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_dataReductionCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_dataReductionData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_dataReductionData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_dataReductionData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbType->setCurrentIndex(m_dataReductionData.type);
 	this->typeChanged();
 	uiGeneralTab.chkAuto->setChecked(m_dataReductionData.autoTolerance);
 	this->autoToleranceChanged();
 	uiGeneralTab.sbTolerance->setValue(m_dataReductionData.tolerance);
 	this->toleranceChanged();
 	uiGeneralTab.chkAuto2->setChecked(m_dataReductionData.autoTolerance2);
 	this->autoTolerance2Changed();
 	uiGeneralTab.sbTolerance2->setValue(m_dataReductionData.tolerance2);
 	this->tolerance2Changed();
 
 	this->showDataReductionResult();
 
 	//enable the "recalculate"-button if the source data was changed since the last dataReduction
 	uiGeneralTab.pbRecalculate->setEnabled(m_dataReductionCurve->isSourceDataChangedSinceLastRecalc());
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_dataReductionCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_dataReductionCurve, SIGNAL(dataSourceTypeChanged(XYCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYCurve::DataSourceType)));
 	connect(m_dataReductionCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_dataReductionCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_dataReductionCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_dataReductionCurve, SIGNAL(dataReductionDataChanged(XYDataReductionCurve::DataReductionData)), this, SLOT(curveDataReductionDataChanged(XYDataReductionCurve::DataReductionData)));
 	connect(m_dataReductionCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYDataReductionCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for (auto* curve: m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 	    <<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYDataReductionCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_dataReductionCurve = dynamic_cast<XYDataReductionCurve*>(m_curve);
 	Q_ASSERT(m_dataReductionCurve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_dataReductionData = m_dataReductionCurve->dataReductionData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYDataReductionCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYDataReductionCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYDataReductionCurveDock::dataSourceTypeChanged(int index) {
 	XYCurve::DataSourceType type = (XYCurve::DataSourceType)index;
 	if (type == XYCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYDataReductionCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = 0;
 	if (aspect) {
 		dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 		Q_ASSERT(dataSourceCurve);
 	}
 
 // 	// disable deriv orders and accuracies that need more data points
 // 	this->updateSettings(dataSourceCurve->xColumn());
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYDataReductionCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setXDataColumn(column);
 
 	//TODO: this->updateSettings(column); ?
 	if (column != 0 && uiGeneralTab.cbAutoRange->isChecked()) {
 		uiGeneralTab.sbMin->setValue(column->minimum());
 		uiGeneralTab.sbMax->setValue(column->maximum());
 	}
 
 	updateTolerance();
 	updateTolerance2();
 }
 
 void XYDataReductionCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setYDataColumn(column);
 
 	updateTolerance();
 	updateTolerance2();
 }
 
 void XYDataReductionCurveDock::updateTolerance() {
 	const AbstractColumn* xDataColumn = nullptr;
 	const AbstractColumn* yDataColumn = nullptr;
 	if (m_dataReductionCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet) {
 		xDataColumn = m_dataReductionCurve->xDataColumn();
 		yDataColumn = m_dataReductionCurve->yDataColumn();
 	} else {
 		if (m_dataReductionCurve->dataSourceCurve()) {
 			xDataColumn = m_dataReductionCurve->dataSourceCurve()->xColumn();
 			yDataColumn = m_dataReductionCurve->dataSourceCurve()->yColumn();
 		}
 	}
 
 	if(xDataColumn == nullptr || yDataColumn == nullptr)
 		return;
 
 	//copy all valid data points for calculating tolerance to temporary vectors
 	QVector<double> xdataVector;
 	QVector<double> ydataVector;
 	const double xmin = m_dataReductionData.xRange.first();
 	const double xmax = m_dataReductionData.xRange.last();
 	for (int row=0; row<xDataColumn->rowCount(); ++row) {
 		//only copy those data where _all_ values (for x and y, if given) are valid
 		if (!std::isnan(xDataColumn->valueAt(row)) && !std::isnan(yDataColumn->valueAt(row))
 		        && !xDataColumn->isMasked(row) && !yDataColumn->isMasked(row)) {
 			// only when inside given range
 			if (xDataColumn->valueAt(row) >= xmin && xDataColumn->valueAt(row) <= xmax) {
 				xdataVector.append(xDataColumn->valueAt(row));
 				ydataVector.append(yDataColumn->valueAt(row));
 			}
 		}
 	}
 
 	if(xdataVector.size() > 1)
 		uiGeneralTab.cbType->setEnabled(true);
 	else {
 		uiGeneralTab.cbType->setEnabled(false);
 		return;
 	}
 #ifndef NDEBUG
 	qDebug()<<"automatic tolerance:";
-	qDebug()<<"clip_diag_perpoint ="<<nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
-	qDebug()<<"clip_area_perpoint ="<<nsl_geom_linesim_clip_area_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
-	qDebug()<<"avg_dist_perpoint ="<<nsl_geom_linesim_avg_dist_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
+	qDebug()<<"clip_diag_perpoint ="<<nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
+	qDebug()<<"clip_area_perpoint ="<<nsl_geom_linesim_clip_area_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
+	qDebug()<<"avg_dist_perpoint ="<<nsl_geom_linesim_avg_dist_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
 #endif
 
 	nsl_geom_linesim_type type = (nsl_geom_linesim_type)uiGeneralTab.cbType->currentIndex();
 	if (type == nsl_geom_linesim_type_raddist || type == nsl_geom_linesim_type_opheim)
-		m_dataReductionData.tolerance = 10.*nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
+		m_dataReductionData.tolerance = 10. * nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
 	else if (type == nsl_geom_linesim_type_visvalingam_whyatt)
-		m_dataReductionData.tolerance = 0.1*nsl_geom_linesim_clip_area_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
+		m_dataReductionData.tolerance = 0.1 * nsl_geom_linesim_clip_area_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
 	else if (type == nsl_geom_linesim_type_douglas_peucker_variant)
 		m_dataReductionData.tolerance = xdataVector.size()/10.;	// reduction to 10%
 	else
 		m_dataReductionData.tolerance = 2.*nsl_geom_linesim_avg_dist_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
 	//m_dataReductionData.tolerance = nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
 	uiGeneralTab.sbTolerance->setValue(m_dataReductionData.tolerance);
 }
 
 void XYDataReductionCurveDock::updateTolerance2() {
 	nsl_geom_linesim_type type = (nsl_geom_linesim_type)uiGeneralTab.cbType->currentIndex();
 
 	if (type == nsl_geom_linesim_type_perpdist)
 		uiGeneralTab.sbTolerance2->setValue(10);
 	else if (type == nsl_geom_linesim_type_opheim)
 		uiGeneralTab.sbTolerance2->setValue(5*uiGeneralTab.sbTolerance->value());
 	else if (type == nsl_geom_linesim_type_lang)
 		uiGeneralTab.sbTolerance2->setValue(10);
 }
 
 void XYDataReductionCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_dataReductionData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = 0;
 		if (m_dataReductionCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet)
 			xDataColumn = m_dataReductionCurve->xDataColumn();
 		else {
 			if (m_dataReductionCurve->dataSourceCurve())
 				xDataColumn = m_dataReductionCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYDataReductionCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_dataReductionData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_dataReductionData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::typeChanged() {
 	nsl_geom_linesim_type type = (nsl_geom_linesim_type)uiGeneralTab.cbType->currentIndex();
 	m_dataReductionData.type = type;
 
 	switch (type) {
 	case nsl_geom_linesim_type_douglas_peucker:
 	case nsl_geom_linesim_type_raddist:
 	case nsl_geom_linesim_type_interp:
 	case nsl_geom_linesim_type_reumann_witkam:
 		uiGeneralTab.lOption->setText(i18n("Tolerance (distance)"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		break;
 	case nsl_geom_linesim_type_douglas_peucker_variant:
 		uiGeneralTab.lOption->setText(i18n("Number of points"));
 		uiGeneralTab.sbTolerance->setDecimals(0);
 		uiGeneralTab.sbTolerance->setMinimum(2);
 		uiGeneralTab.sbTolerance->setSingleStep(1);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		break;
 	case nsl_geom_linesim_type_nthpoint:
 		uiGeneralTab.lOption->setText(i18n("Step size"));
 		uiGeneralTab.sbTolerance->setValue(10);
 		uiGeneralTab.sbTolerance->setDecimals(0);
 		uiGeneralTab.sbTolerance->setMinimum(1);
 		uiGeneralTab.sbTolerance->setSingleStep(1);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		break;
 	case nsl_geom_linesim_type_perpdist:	// repeat option
 		uiGeneralTab.lOption->setText(i18n("Tolerance (distance)"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.sbTolerance2->show();
 		uiGeneralTab.lOption2->show();
 		uiGeneralTab.chkAuto2->show();
 		uiGeneralTab.lOption2->setText(i18n("Repeats"));
 		uiGeneralTab.sbTolerance2->setDecimals(0);
 		uiGeneralTab.sbTolerance2->setMinimum(1);
 		uiGeneralTab.sbTolerance2->setSingleStep(1);
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		if (uiGeneralTab.chkAuto2->isChecked())
 			updateTolerance2();
 		break;
 	case nsl_geom_linesim_type_visvalingam_whyatt:
 		uiGeneralTab.lOption->setText(i18n("Tolerance (area)"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		break;
 	case nsl_geom_linesim_type_opheim:	// min/max tol options
 		uiGeneralTab.lOption->setText(i18n(" Min. Tolerance"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->setText(i18n("Max. Tolerance"));
 		uiGeneralTab.lOption2->show();
 		uiGeneralTab.chkAuto2->show();
 		uiGeneralTab.sbTolerance2->show();
 		uiGeneralTab.sbTolerance2->setDecimals(6);
 		uiGeneralTab.sbTolerance2->setMinimum(0);
 		uiGeneralTab.sbTolerance2->setSingleStep(0.01);
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		if (uiGeneralTab.chkAuto2->isChecked())
 			updateTolerance2();
 		break;
 	case nsl_geom_linesim_type_lang:	// distance/region
 		uiGeneralTab.lOption->setText(i18n("Tolerance (distance)"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->setText(i18n("Search region"));
 		uiGeneralTab.lOption2->show();
 		uiGeneralTab.chkAuto2->show();
 		uiGeneralTab.sbTolerance2->show();
 		uiGeneralTab.sbTolerance2->setDecimals(0);
 		uiGeneralTab.sbTolerance2->setMinimum(1);
 		uiGeneralTab.sbTolerance2->setSingleStep(1);
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		if (uiGeneralTab.chkAuto2->isChecked())
 			updateTolerance2();
 		break;
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::autoToleranceChanged() {
 	bool autoTolerance = (bool)uiGeneralTab.chkAuto->isChecked();
 	m_dataReductionData.autoTolerance = autoTolerance;
 
 	if (autoTolerance) {
 		uiGeneralTab.sbTolerance->setEnabled(false);
 		updateTolerance();
 	} else
 		uiGeneralTab.sbTolerance->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::toleranceChanged() {
 	m_dataReductionData.tolerance = uiGeneralTab.sbTolerance->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::autoTolerance2Changed() {
 	bool autoTolerance2 = (bool)uiGeneralTab.chkAuto2->isChecked();
 	m_dataReductionData.autoTolerance2 = autoTolerance2;
 
 	if (autoTolerance2) {
 		uiGeneralTab.sbTolerance2->setEnabled(false);
 		updateTolerance2();
 	} else
 		uiGeneralTab.sbTolerance2->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::tolerance2Changed() {
 	m_dataReductionData.tolerance2 = uiGeneralTab.sbTolerance2->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::recalculateClicked() {
 	//show a progress bar in the status bar
 	QProgressBar* progressBar = new QProgressBar();
 	progressBar->setMinimum(0);
 	progressBar->setMaximum(100);
 	connect(m_curve, SIGNAL(completed(int)), progressBar, SLOT(setValue(int)));
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setDataReductionData(m_dataReductionData);
 
 	QApplication::restoreOverrideCursor();
 	statusBar->removeWidget(progressBar);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Data reduction status: ") + m_dataReductionCurve->dataReductionResult().status);
 }
 
 void XYDataReductionCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no dataReductioning possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_dataReductionCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=0 && aspectY!=0);
 	} else {
 		 hasSourceData = (m_dataReductionCurve->dataSourceCurve() != NULL);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the dataReduction
  */
 void XYDataReductionCurveDock::showDataReductionResult() {
 	const XYDataReductionCurve::DataReductionResult& dataReductionResult = m_dataReductionCurve->dataReductionResult();
 	if (!dataReductionResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	QString str = i18n("status:") + ' ' + dataReductionResult.status + "<br>";
 
 	if (!dataReductionResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (dataReductionResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s").arg(QString::number(dataReductionResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms").arg(QString::number(dataReductionResult.elapsedTime)) + "<br>";
 
 	str += "<br>";
 
 	str += i18n("number of points: %1").arg(QString::number(dataReductionResult.npoints)) + "<br>";
 	str += i18n("positional squared error: %1").arg(QString::number(dataReductionResult.posError)) + "<br>";
 	str += i18n("area error: %1").arg(QString::number(dataReductionResult.areaError)) + "<br>";
 
 	uiGeneralTab.teResult->setText(str);
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYDataReductionCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveDataSourceTypeChanged(XYCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveDataReductionDataChanged(const XYDataReductionCurve::DataReductionData& data) {
 	m_initializing = true;
 	m_dataReductionData = data;
 	//uiGeneralTab.cbType->setCurrentIndex(m_dataReductionData.type);
 	//this->typeChanged();
 
 	this->showDataReductionResult();
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp b/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp
index a7ab6c0ec..aff74b487 100644
--- a/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp
@@ -1,1143 +1,1143 @@
 /***************************************************************************
     File             : XYFitCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2014-2017 Alexander Semke (alexander.semke@web.de)
     Copyright        : (C) 2016-2017 Stefan Gerlach (stefan.gerlach@uni.kn)
     Description      : widget for editing properties of fit curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "XYFitCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/lib/macros.h"
 #include "backend/gsl/ExpressionParser.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/widgets/ConstantsWidget.h"
 #include "kdefrontend/widgets/FunctionsWidget.h"
 #include "kdefrontend/widgets/FitOptionsWidget.h"
 #include "kdefrontend/widgets/FitParametersWidget.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 #include <QStandardPaths>
 #include <QClipboard>
 
 extern "C" {
 #include "backend/nsl/nsl_sf_stats.h"
 }
 
 /*!
   \class XYFitCurveDock
   \brief  Provides a widget for editing the properties of the XYFitCurves
 		(2D-curves defined by a fit model) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYFitCurveDock::XYFitCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(0), cbXDataColumn(0), cbYDataColumn(0), cbXErrorColumn(0),
 	cbYErrorColumn(0), m_fitCurve(0) {
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYFitCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 	QGridLayout* gridLayout = qobject_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2, 2, 2, 2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 6, 4, 1, 4);
 
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 7, 4, 1, 4);
 
 	cbXErrorColumn = new TreeViewComboBox(generalTab);
 	cbXErrorColumn->setEnabled(false);
 	uiGeneralTab.hlXError->addWidget(cbXErrorColumn);
 
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 8, 4, 1, 4);
 
 	cbYErrorColumn = new TreeViewComboBox(generalTab);
 	cbYErrorColumn->setEnabled(false);
 	uiGeneralTab.hlYWeight->addWidget(cbYErrorColumn);
 
 	//X-Error/Y-Weight
 	for(int i = 0; i < NSL_FIT_ERROR_TYPE_COUNT; i++)
 		uiGeneralTab.cbXError->addItem(nsl_fit_error_type_name[i]);
 	uiGeneralTab.cbXError->setCurrentIndex(nsl_fit_error_no);
 	for(int i = 0; i < NSL_FIT_WEIGHT_TYPE_COUNT; i++)
 		uiGeneralTab.cbYWeight->addItem(nsl_fit_weight_type_name[i]);
 	uiGeneralTab.cbYWeight->setCurrentIndex(nsl_fit_weight_no);
 
 	for(int i = 0; i < NSL_FIT_MODEL_CATEGORY_COUNT; i++)
 		uiGeneralTab.cbCategory->addItem(nsl_fit_model_category_name[i]);
 
 	//show the fit-model category for the currently selected default (first) fit-model category
 	categoryChanged(uiGeneralTab.cbCategory->currentIndex());
 
 	uiGeneralTab.teEquation->setMaximumHeight(uiGeneralTab.leName->sizeHint().height() * 2);
 
 	//use white background in the preview label
 	QPalette p;
 	p.setColor(QPalette::Window, Qt::white);
 	uiGeneralTab.lFuncPic->setAutoFillBackground(true);
 	uiGeneralTab.lFuncPic->setPalette(p);
 
 	uiGeneralTab.tbConstants->setIcon(QIcon::fromTheme("labplot-format-text-symbol"));
 	uiGeneralTab.tbFunctions->setIcon(QIcon::fromTheme("preferences-desktop-font"));
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	uiGeneralTab.twLog->setEditTriggers(QAbstractItemView::NoEditTriggers);
 	uiGeneralTab.twParameters->setEditTriggers(QAbstractItemView::NoEditTriggers);
 	uiGeneralTab.twGoodness->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
 	//don't allow word wrapping in the log-table for the multi-line iterations string
 	uiGeneralTab.twLog->setWordWrap(false);
 
 	// context menus
 	uiGeneralTab.twParameters->setContextMenuPolicy(Qt::CustomContextMenu);
 	uiGeneralTab.twGoodness->setContextMenuPolicy(Qt::CustomContextMenu);
 	uiGeneralTab.twLog->setContextMenuPolicy(Qt::CustomContextMenu);
 	connect(uiGeneralTab.twParameters, SIGNAL(customContextMenuRequested(const QPoint &)), this,
 			SLOT(resultParametersContextMenuRequest(const QPoint &)) );
 	connect(uiGeneralTab.twGoodness, SIGNAL(customContextMenuRequested(const QPoint &)), this,
 			SLOT(resultGoodnessContextMenuRequest(const QPoint &)) );
 	connect(uiGeneralTab.twLog, SIGNAL(customContextMenuRequested(const QPoint &)), this,
 			SLOT(resultLogContextMenuRequest(const QPoint &)) );
 
 	uiGeneralTab.twLog->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 	uiGeneralTab.twGoodness->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 	uiGeneralTab.twGoodness->item(0, 1)->setText(QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2"));
 	uiGeneralTab.twGoodness->item(1, 1)->setText(i18n("reduced") + " " + QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2")
 		+ " (" + QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2") + "/dof)");
 	uiGeneralTab.twGoodness->item(3, 1)->setText("R" + QString::fromUtf8("\u00b2"));
 	uiGeneralTab.twGoodness->item(4, 1)->setText("R" + QString::fromUtf8("\u0304") + QString::fromUtf8("\u00b2"));
 	uiGeneralTab.twGoodness->item(5, 0)->setText(QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2") + ' ' + i18n("test"));
 	uiGeneralTab.twGoodness->item(5, 1)->setText("P > " + QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2"));
 
 	QHBoxLayout* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect(uiGeneralTab.leName, SIGNAL(returnPressed()), this, SLOT(nameChanged()));
 	connect(uiGeneralTab.leComment, SIGNAL(returnPressed()), this, SLOT(commentChanged()));
 	connect(uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)));
 	connect(uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)));
 
 	connect(uiGeneralTab.cbXError, SIGNAL(currentIndexChanged(int)), this, SLOT(xErrorChanged(int)));
 	connect(uiGeneralTab.cbYWeight, SIGNAL(currentIndexChanged(int)), this, SLOT(yWeightChanged(int)));
 	connect(uiGeneralTab.cbCategory, SIGNAL(currentIndexChanged(int)), this, SLOT(categoryChanged(int)));
 	connect(uiGeneralTab.cbModel, SIGNAL(currentIndexChanged(int)), this, SLOT(modelTypeChanged(int)));
 	connect(uiGeneralTab.sbDegree, SIGNAL(valueChanged(int)), this, SLOT(updateModelEquation()));
 	connect(uiGeneralTab.teEquation, SIGNAL(expressionChanged()), this, SLOT(enableRecalculate()));
 	connect(uiGeneralTab.tbConstants, SIGNAL(clicked()), this, SLOT(showConstants()));
 	connect(uiGeneralTab.tbFunctions, SIGNAL(clicked()), this, SLOT(showFunctions()));
 	connect(uiGeneralTab.pbParameters, SIGNAL(clicked()), this, SLOT(showParameters()));
 	connect(uiGeneralTab.pbOptions, SIGNAL(clicked()), this, SLOT(showOptions()));
 	connect(uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()));
 
 	connect(cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)));
 	connect(cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)));
 	connect(cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)));
 	connect(cbXErrorColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xErrorColumnChanged(QModelIndex)));
 	connect(cbYErrorColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yErrorColumnChanged(QModelIndex)));
 }
 
 void XYFitCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size() == 1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	} else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_fitCurve = dynamic_cast<XYFitCurve*>(m_curve);
 	Q_ASSERT(m_fitCurve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_fitCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_fitCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_fitCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_fitCurve->yDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbXErrorColumn, m_fitCurve->xErrorColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYErrorColumn, m_fitCurve->yErrorColumn());
 
 	unsigned int tmpModelType = m_fitData.modelType;	// save type because it's reset when category changes
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		uiGeneralTab.cbCategory->setCurrentIndex(uiGeneralTab.cbCategory->count() - 1);
 	else
 		uiGeneralTab.cbCategory->setCurrentIndex(m_fitData.modelCategory);
 	m_fitData.modelType = tmpModelType;
 	if (m_fitData.modelCategory != nsl_fit_model_custom)
-		uiGeneralTab.cbModel->setCurrentIndex(m_fitData.modelType);
+		uiGeneralTab.cbModel->setCurrentIndex((int)m_fitData.modelType);
 
 	uiGeneralTab.cbXError->setCurrentIndex(m_fitData.xErrorsType);
 	uiGeneralTab.cbYWeight->setCurrentIndex(m_fitData.yWeightsType);
 	uiGeneralTab.sbDegree->setValue(m_fitData.degree);
 	updateModelEquation();
 	this->showFitResult();
 
 	uiGeneralTab.chkVisible->setChecked(m_curve->isVisible());
 
 	//Slots
 	connect(m_fitCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_fitCurve, SIGNAL(dataSourceTypeChanged(XYCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYCurve::DataSourceType)));
 	connect(m_fitCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_fitCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(xErrorColumnChanged(const AbstractColumn*)), this, SLOT(curveXErrorColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(yErrorColumnChanged(const AbstractColumn*)), this, SLOT(curveYErrorColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(fitDataChanged(XYFitCurve::FitData)), this, SLOT(curveFitDataChanged(XYFitCurve::FitData)));
 	connect(m_fitCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYFitCurveDock::setModel() {
 	QList<const char*>  list;
 	list << "Folder" << "Datapicker" << "Worksheet" << "CartesianPlot" << "XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for (auto* curve: m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list << "Folder" << "Workbook" << "Spreadsheet" << "FileDataSource" << "Column" << "CantorWorksheet" << "Datapicker";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 	cbXErrorColumn->setTopLevelClasses(list);
 	cbYErrorColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 	cbXErrorColumn->setModel(m_aspectTreeModel);
 	cbYErrorColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYFitCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing = true;
 	m_curvesList = list;
 	m_curve = list.first();
 
 	m_fitCurve = dynamic_cast<XYFitCurve*>(m_curve);
 	Q_ASSERT(m_fitCurve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_fitData = m_fitCurve->fitData();
 
 	initGeneralTab();
 	initTabs();
 
 	m_initializing = false;
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYFitCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYFitCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYFitCurveDock::dataSourceTypeChanged(int index) {
 	const XYCurve::DataSourceType type = (XYCurve::DataSourceType)index;
 	if (type == XYCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYFitCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = 0;
 	if (aspect) {
 		dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 		Q_ASSERT(dataSourceCurve);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYFitCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setXDataColumn(column);
 }
 
 void XYFitCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setYDataColumn(column);
 }
 
 void XYFitCurveDock::xErrorColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setXErrorColumn(column);
 }
 
 void XYFitCurveDock::yErrorColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setYErrorColumn(column);
 }
 
 void XYFitCurveDock::xErrorChanged(int index) {
 	DEBUG("xErrorChanged() error = " << nsl_fit_error_type_name[index]);
 
 	m_fitData.xErrorsType = (nsl_fit_error_type)index;
 
 	// enable/disable weight column
 	switch ((nsl_fit_error_type)index) {
 	case nsl_fit_error_no:
 		cbXErrorColumn->setEnabled(false);
 		uiGeneralTab.lXErrorCol->setEnabled(false);
 		break;
 	case nsl_fit_error_direct:
 	case nsl_fit_error_inverse:
 		cbXErrorColumn->setEnabled(true);
 		uiGeneralTab.lXErrorCol->setEnabled(true);
 		break;
 	}
 	enableRecalculate();
 }
 
 void XYFitCurveDock::yWeightChanged(int index) {
 	DEBUG("yWeightChanged() weight = " << nsl_fit_weight_type_name[index]);
 
 	m_fitData.yWeightsType = (nsl_fit_weight_type)index;
 
 	// enable/disable weight column
 	switch ((nsl_fit_weight_type)index) {
 	case nsl_fit_weight_no:
 	case nsl_fit_weight_statistical:
 	case nsl_fit_weight_statistical_fit:
 	case nsl_fit_weight_relative:
 	case nsl_fit_weight_relative_fit:
 		cbYErrorColumn->setEnabled(false);
 		uiGeneralTab.lYErrorCol->setEnabled(false);
 		break;
 	case nsl_fit_weight_instrumental:
 	case nsl_fit_weight_direct:
 	case nsl_fit_weight_inverse:
 		cbYErrorColumn->setEnabled(true);
 		uiGeneralTab.lYErrorCol->setEnabled(true);
 		break;
 	}
 	enableRecalculate();
 }
 
 /*!
  * called when the fit model category (basic functions, peak functions etc.) was changed.
  * In the combobox for the model type shows the model types for the current category \index and calls \c modelTypeChanged()
  * to update the model type dependent widgets in the general-tab.
  */
 void XYFitCurveDock::categoryChanged(int index) {
 	DEBUG("categoryChanged() category = \"" << nsl_fit_model_category_name[index] << "\"");
 
 	if (uiGeneralTab.cbCategory->currentIndex() == uiGeneralTab.cbCategory->count() - 1)
 		m_fitData.modelCategory = nsl_fit_model_custom;
 	else
 		m_fitData.modelCategory = (nsl_fit_model_category)index;
 
 	m_initializing = true;
 	uiGeneralTab.cbModel->clear();
 	uiGeneralTab.cbModel->show();
 	uiGeneralTab.lModel->show();
 
 	switch (m_fitData.modelCategory) {
 	case nsl_fit_model_basic:
 		for(int i = 0; i < NSL_FIT_MODEL_BASIC_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_fit_model_basic_name[i]);
 		break;
 	case nsl_fit_model_peak:
 		for(int i = 0; i < NSL_FIT_MODEL_PEAK_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_fit_model_peak_name[i]);
 		break;
 	case nsl_fit_model_growth:
 		for(int i = 0; i < NSL_FIT_MODEL_GROWTH_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_fit_model_growth_name[i]);
 		break;
 	case nsl_fit_model_distribution: {
 		for(int i = 0; i < NSL_SF_STATS_DISTRIBUTION_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_sf_stats_distribution_name[i]);
 
 		// not-used items are disabled here
 		const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbModel->model());
 
 		for(int i = 1; i < NSL_SF_STATS_DISTRIBUTION_COUNT; i++) {
 			// unused distributions
 			if (i == nsl_sf_stats_levy_alpha_stable || i == nsl_sf_stats_levy_skew_alpha_stable || i == nsl_sf_stats_bernoulli) {
 					QStandardItem* item = model->item(i);
 					item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 			}
 		}
 		break;
 	}
 	case nsl_fit_model_custom:
 		uiGeneralTab.cbModel->addItem(i18n("Custom"));
 		uiGeneralTab.cbModel->hide();
 		uiGeneralTab.lModel->hide();
 	}
 
 	//show the fit-model for the currently selected default (first) fit-model
 	m_fitData.modelType = 0;
 	uiGeneralTab.cbModel->setCurrentIndex(m_fitData.modelType);
 	modelTypeChanged(m_fitData.modelType);
 
 	m_initializing = false;
 	enableRecalculate();
 }
 
 /*!
  * called when the fit model type (polynomial, power, etc.) was changed.
  * Updates the model type dependent widgets in the general-tab and calls \c updateModelEquation() to update the preview pixmap.
  */
 void XYFitCurveDock::modelTypeChanged(int index) {
 	DEBUG("modelTypeChanged() type = " << index << ", initializing = " << m_initializing);
 	// leave if there is no selection
 	if(index == -1)
 		return;
 
 	unsigned int type = 0;
 	bool custom = false;
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		custom = true;
 	else
 		type = (unsigned int)index;
 	m_fitData.modelType = type;
 	uiGeneralTab.teEquation->setReadOnly(!custom);
 	uiGeneralTab.tbFunctions->setVisible(custom);
 	uiGeneralTab.tbConstants->setVisible(custom);
 
 	// default settings
 	uiGeneralTab.lDegree->setText(i18n("Degree"));
 
 	switch (m_fitData.modelCategory) {
 	case nsl_fit_model_basic:
 		switch (type) {
 		case nsl_fit_model_polynomial:
 		case nsl_fit_model_fourier:
 			uiGeneralTab.lDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setMaximum(10);
 			uiGeneralTab.sbDegree->setValue(1);
 			break;
 		case nsl_fit_model_power:
 			uiGeneralTab.lDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setMaximum(2);
 			uiGeneralTab.sbDegree->setValue(1);
 			break;
 		case nsl_fit_model_exponential:
 			uiGeneralTab.lDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setMaximum(10);
 			uiGeneralTab.sbDegree->setValue(1);
 			break;
 		default:
 			uiGeneralTab.lDegree->setVisible(false);
 			uiGeneralTab.sbDegree->setVisible(false);
 		}
 		break;
 	case nsl_fit_model_peak:	// all models support multiple peaks
 		uiGeneralTab.lDegree->setText(i18n("Number of peaks"));
 		uiGeneralTab.lDegree->setVisible(true);
 		uiGeneralTab.sbDegree->setVisible(true);
 		uiGeneralTab.sbDegree->setMaximum(9);
 		uiGeneralTab.sbDegree->setValue(1);
 		break;
 	case nsl_fit_model_growth:
 	case nsl_fit_model_distribution:
 	case nsl_fit_model_custom:
 		uiGeneralTab.lDegree->setVisible(false);
 		uiGeneralTab.sbDegree->setVisible(false);
 	}
 
 	this->updateModelEquation();
 }
 
 /*!
  * Show the preview pixmap of the fit model expression for the current model category and type.
  * Called when the model type or the degree of the model were changed.
  */
 void XYFitCurveDock::updateModelEquation() {
 	DEBUG("updateModelEquation() category = " << m_fitData.modelCategory << ", type = " << m_fitData.modelType);
 
 	//this function can also be called when the value for the degree was changed -> update the fit data structure
 	int degree = uiGeneralTab.sbDegree->value();
 	m_fitData.degree = degree;
 	XYFitCurve::initFitData(m_fitData);
 
 	// variables/parameter that are known
 	QStringList vars = {"x"};
 	vars << m_fitData.paramNames;
 	uiGeneralTab.teEquation->setVariables(vars);
 
 	// set formula picture
 	uiGeneralTab.lEquation->setText(QLatin1String("f(x) ="));
 	QString file;
 	switch (m_fitData.modelCategory) {
 	case nsl_fit_model_basic: {
 		// formula pic depends on degree
 		QString numSuffix = QString::number(degree);
 		if (degree > 4)
 			numSuffix = "4";
 		if ((nsl_fit_model_type_basic)m_fitData.modelType == nsl_fit_model_power && degree > 2)
 			numSuffix = "2";
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/fit_models/"
 			+ QString(nsl_fit_model_basic_pic_name[m_fitData.modelType]) + numSuffix + ".jpg");
 		break;
 	}
 	case nsl_fit_model_peak: {
 		// formula pic depends on number of peaks
 		QString numSuffix = QString::number(degree);
 		if (degree > 4)
 			numSuffix = "4";
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/fit_models/"
 			+ QString(nsl_fit_model_peak_pic_name[m_fitData.modelType]) + numSuffix + ".jpg");
 		break;
 	}
 	case nsl_fit_model_growth:
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/fit_models/"
 			+ QString(nsl_fit_model_growth_pic_name[m_fitData.modelType]) + ".jpg");
 		break;
 	case nsl_fit_model_distribution:
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/gsl_distributions/"
 			+ QString(nsl_sf_stats_distribution_pic_name[m_fitData.modelType]) + ".jpg");
 		// change label
 		if (m_fitData.modelType == nsl_sf_stats_poisson)
 			uiGeneralTab.lEquation->setText(QLatin1String("f(k)/A ="));
 		else
 			uiGeneralTab.lEquation->setText(QLatin1String("f(x)/A ="));
 		break;
 	case nsl_fit_model_custom:
 		uiGeneralTab.teEquation->show();
 		uiGeneralTab.teEquation->clear();
 		uiGeneralTab.teEquation->insertPlainText(m_fitData.model);
 		uiGeneralTab.lFuncPic->hide();
 	}
 
 	if (m_fitData.modelCategory != nsl_fit_model_custom) {
 		uiGeneralTab.lFuncPic->setPixmap(file);
 		uiGeneralTab.lFuncPic->show();
 		uiGeneralTab.teEquation->hide();
 	}
 }
 
 void XYFitCurveDock::showConstants() {
 	QMenu menu;
 	ConstantsWidget constants(&menu);
 
 	connect(&constants, SIGNAL(constantSelected(QString)), this, SLOT(insertConstant(QString)));
 	connect(&constants, SIGNAL(constantSelected(QString)), &menu, SLOT(close()));
 	connect(&constants, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&constants);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.tbConstants->width(), -menu.sizeHint().height());
 	menu.exec(uiGeneralTab.tbConstants->mapToGlobal(pos));
 }
 
 void XYFitCurveDock::showFunctions() {
 	QMenu menu;
 	FunctionsWidget functions(&menu);
 	connect(&functions, SIGNAL(functionSelected(QString)), this, SLOT(insertFunction(QString)));
 	connect(&functions, SIGNAL(functionSelected(QString)), &menu, SLOT(close()));
 	connect(&functions, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&functions);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.tbFunctions->width(), -menu.sizeHint().height());
 	menu.exec(uiGeneralTab.tbFunctions->mapToGlobal(pos));
 }
 
 void XYFitCurveDock::updateParameterList() {
 	// use current model function
 	m_fitData.model = uiGeneralTab.teEquation->toPlainText();
 
 	ExpressionParser* parser = ExpressionParser::getInstance();
 	QStringList vars; // variables that are known
 	vars << "x";	//TODO: others?
 	m_fitData.paramNames = m_fitData.paramNamesUtf8 = parser->getParameter(m_fitData.model, vars);
 
 	// if number of parameter changed
 	bool moreParameter = false;
 	if (m_fitData.paramNames.size() > m_fitData.paramStartValues.size())
 		moreParameter = true;
 	if (m_fitData.paramNames.size() != m_fitData.paramStartValues.size()) {
 		m_fitData.paramStartValues.resize(m_fitData.paramNames.size());
 		m_fitData.paramFixed.resize(m_fitData.paramNames.size());
 		m_fitData.paramLowerLimits.resize(m_fitData.paramNames.size());
 		m_fitData.paramUpperLimits.resize(m_fitData.paramNames.size());
 	}
 	if (moreParameter) {
 		for (int i = m_fitData.paramStartValues.size() - 1; i < m_fitData.paramNames.size(); ++i) {
 			m_fitData.paramStartValues[i] = 1.0;
 			m_fitData.paramFixed[i] = false;
 			m_fitData.paramLowerLimits[i] = -std::numeric_limits<double>::max();
 			m_fitData.paramUpperLimits[i] = std::numeric_limits<double>::max();
 		}
 	}
 	parametersChanged();
 }
 
 void XYFitCurveDock::showParameters() {
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		updateParameterList();
 
 	QMenu menu;
 	FitParametersWidget w(&menu, &m_fitData);
 	connect(&w, SIGNAL(finished()), &menu, SLOT(close()));
 	connect(&w, SIGNAL(parametersChanged()), this, SLOT(parametersChanged()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&w);
 	menu.addAction(widgetAction);
 	menu.setMinimumWidth(w.width());
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.pbParameters->width(), -menu.sizeHint().height());
 	menu.exec(uiGeneralTab.pbParameters->mapToGlobal(pos));
 }
 
 /*!
  * called when parameter names and/or start values for the custom model were changed
  */
 void XYFitCurveDock::parametersChanged() {
 	//parameter names were (probably) changed -> set the new names in EquationTextEdit
 	uiGeneralTab.teEquation->setVariables(m_fitData.paramNames);
 	enableRecalculate();
 }
 
 void XYFitCurveDock::showOptions() {
 	QMenu menu;
 	FitOptionsWidget w(&menu, &m_fitData, m_fitCurve);
 	connect(&w, SIGNAL(finished()), &menu, SLOT(close()));
 	connect(&w, SIGNAL(optionsChanged()), this, SLOT(enableRecalculate()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&w);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.pbParameters->width(), -menu.sizeHint().height());
 	menu.exec(uiGeneralTab.pbOptions->mapToGlobal(pos));
 }
 
 void XYFitCurveDock::insertFunction(const QString& str) const {
 	uiGeneralTab.teEquation->insertPlainText(str + "(x)");
 }
 
 void XYFitCurveDock::insertConstant(const QString& str) const {
 	uiGeneralTab.teEquation->insertPlainText(str);
 }
 
 void XYFitCurveDock::recalculateClicked() {
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 	m_fitData.degree = uiGeneralTab.sbDegree->value();
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		updateParameterList();
 
 	for (XYCurve* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setFitData(m_fitData);
 
 	this->showFitResult();
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Fit status: ") + m_fitCurve->fitResult().status);
 	QApplication::restoreOverrideCursor();
 }
 
 void XYFitCurveDock::enableRecalculate() const {
 	if (m_initializing || m_fitCurve == nullptr)
 		return;
 
 	//no fitting possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_fitCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX != 0 && aspectY != 0);
 	} else {
 		 hasSourceData = (m_fitCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 void XYFitCurveDock::resultCopySelection() {
 	QTableWidget* tw = nullptr;
 	int currentTab = uiGeneralTab.twResults->currentIndex();
 	DEBUG("current tab = " << currentTab);
 	if (currentTab == 0)
 		tw = uiGeneralTab.twParameters;
 	else if (currentTab == 1)
 		tw = uiGeneralTab.twGoodness;
 	else if (currentTab == 2)
 		tw = uiGeneralTab.twLog;
 	else
 		return;
 
 	QTableWidgetSelectionRange range = tw->selectedRanges().first();
 	QString str;
 	for (int i = 0; i < range.rowCount(); ++i) {
 		if (i > 0)
 			str += "\n";
 		for (int j = 0; j < range.columnCount(); ++j) {
 			if (j > 0)
 				str += "\t";
 			str += tw->item(range.topRow() + i, range.leftColumn() + j)->text();
 		}
 	}
 	str += "\n";
 	QApplication::clipboard()->setText(str);
 	DEBUG(QApplication::clipboard()->text().toStdString());
 }
 
 void XYFitCurveDock::resultCopyAll() {
 	const XYFitCurve::FitResult& fitResult = m_fitCurve->fitResult();
 	int currentTab = uiGeneralTab.twResults->currentIndex();
 	QString str;
 	if (currentTab == 0) {
 		str = i18n("Parameters:") + "\n";
 
 		const int np = fitResult.paramValues.size();
 		for (int i = 0; i < np; i++) {
 			if (m_fitData.paramFixed.at(i))
 				str += m_fitData.paramNamesUtf8.at(i) + QString(" = ") + QString::number(fitResult.paramValues.at(i)) + "\n";
 			else {
 				str += m_fitData.paramNamesUtf8.at(i) + QString(" = ") + QString::number(fitResult.paramValues.at(i))
 					+ QString::fromUtf8("\u00b1") + QString::number(fitResult.errorValues.at(i))
 					+ " (" + QString::number(100.*fitResult.errorValues.at(i)/std::abs(fitResult.paramValues.at(i)), 'g', 3) + " %)\n";
 
 				const double margin = fitResult.tdist_marginValues.at(i);
 				QString tdistValueString;
 				if (fitResult.tdist_tValues.at(i) < std::numeric_limits<double>::max())
 					tdistValueString = QString::number(fitResult.tdist_tValues.at(i), 'g', 3);
 				else
 					tdistValueString = QString::fromUtf8("\u221e");
 				str += " (" + i18n("t statistic:") + ' ' + tdistValueString + ", "
 					+ i18n("p value:") + ' ' + QString::number(fitResult.tdist_pValues.at(i), 'g', 3) + ", "
 					+ i18n("conf. interval:") + ' ';
 				if (std::abs(fitResult.tdist_tValues.at(i)) < 1.e6) {
 					str += QString::number(fitResult.paramValues.at(i) - margin) + " .. "
 						+ QString::number(fitResult.paramValues.at(i) + margin) + ")\n";
 				} else {
 					str += i18n("too small");
 				}
 			}
 		}
 	} else if (currentTab == 1) {
 		str = i18n("Goodness of fit:") + "\n";
 		str += i18n("sum of squared residuals") + " (" + QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2") + "): " + QString::number(fitResult.sse) + "\n";
 		if (fitResult.dof != 0) {
 			str += i18n("reduced") + ' ' + QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2") + ": " + QString::number(fitResult.rms) + '\n';
 			str += i18n("root mean square error") + " (RMSE): " + QString::number(fitResult.rsd) + "\n";
 			str += i18n("coefficient of determination") + " (R" + QString::fromUtf8("\u00b2") + "): " + QString::number(fitResult.rsquare, 'g', 15) + '\n';
 			str += i18n("adj. coefficient of determination")+ " (R" + QString::fromUtf8("\u0304") + QString::fromUtf8("\u00b2")
 				+ "): " + QString::number(fitResult.rsquareAdj, 'g', 15) + "\n\n";
 
 			str += i18n("P > ") + QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2") + ": " + QString::number(fitResult.chisq_p, 'g', 3) + '\n';
 			str += i18n("F statistic") + ": " + QString::number(fitResult.fdist_F, 'g', 3) + '\n';
 			str += i18n("P > F") + ": " + QString::number(fitResult.fdist_p, 'g', 3) + '\n';
 		}
 		str += i18n("mean absolute error:") + ' ' + QString::number(fitResult.mae) + '\n';
 		str += i18n("Akaike information criterion:") + ' ' + QString::number(fitResult.aic) + '\n';
 		str += i18n("Bayesian information criterion:") + ' ' + QString::number(fitResult.bic) + '\n';
 	} else if (currentTab == 2) {
 		str = i18n("status:") + ' ' + fitResult.status + '\n';
 		str += i18n("iterations:") + ' ' + QString::number(fitResult.iterations) + '\n';
 		str += i18n("tolerance:") + ' ' + QString::number(m_fitData.eps) + '\n';
 		if (fitResult.elapsedTime > 1000)
 			str += i18n("calculation time: %1 s", fitResult.elapsedTime/1000) + '\n';
 		else
 			str += i18n("calculation time: %1 ms", fitResult.elapsedTime) + '\n';
 		str += i18n("degrees of freedom:") + ' ' + QString::number(fitResult.dof) + '\n';
 		str += i18n("number of parameters:") + ' ' + QString::number(fitResult.paramValues.size()) + '\n';
 		str += i18n("X range:") + ' ' + QString::number(m_fitData.xRange.first()) + " .. " + QString::number(m_fitData.xRange.last()) + '\n';
 
 		str += i18n("Iterations:") + '\n';
 		for (const auto &s: m_fitData.paramNamesUtf8)
 			str += s + '\t';
 		str += QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2");
 
 		const QStringList iterations = fitResult.solverOutput.split(';');
 		for (const auto &s: iterations)
 			if (!s.isEmpty())
 				str += '\n' + s;
 	}
 
 	QApplication::clipboard()->setText(str);
 	DEBUG(QApplication::clipboard()->text().toStdString());
 }
 
 void XYFitCurveDock::resultParametersContextMenuRequest(const QPoint &pos) {
 	QMenu *contextMenu = new QMenu;
 	contextMenu->addAction("Copy selection", this, SLOT(resultCopySelection()));
 	contextMenu->addAction("Copy all", this, SLOT(resultCopyAll()));
 	contextMenu->exec(uiGeneralTab.twParameters->mapToGlobal(pos));
 }
 void XYFitCurveDock::resultGoodnessContextMenuRequest(const QPoint &pos) {
 	QMenu *contextMenu = new QMenu;
 	contextMenu->addAction("Copy selection", this, SLOT(resultCopySelection()));
 	contextMenu->addAction("Copy all", this, SLOT(resultCopyAll()));
 	contextMenu->exec(uiGeneralTab.twGoodness->mapToGlobal(pos));
 }
 void XYFitCurveDock::resultLogContextMenuRequest(const QPoint &pos) {
 	QMenu *contextMenu = new QMenu;
 	contextMenu->addAction("Copy selection", this, SLOT(resultCopySelection()));
 	contextMenu->addAction("Copy all", this, SLOT(resultCopyAll()));
 	contextMenu->exec(uiGeneralTab.twLog->mapToGlobal(pos));
 }
 
 			 /*!
  * show the result and details of fit
  */
 void XYFitCurveDock::showFitResult() {
 	DEBUG("XYFitCurveDock::showFitResult()");
 
 	//clear the previous result
 	uiGeneralTab.twParameters->setRowCount(0);
 	for (int row = 0; row < uiGeneralTab.twGoodness->rowCount(); ++row)
 		uiGeneralTab.twGoodness->item(row, 2)->setText("");
 	for (int row = 0; row < uiGeneralTab.twLog->rowCount(); ++row)
 		uiGeneralTab.twLog->item(row, 1)->setText("");
 
 	const XYFitCurve::FitResult& fitResult = m_fitCurve->fitResult();
 
 	if (!fitResult.available) {
 		DEBUG("fit result not available");
 		return;
 	}
 
 	// Log
 	uiGeneralTab.twLog->item(0, 1)->setText(fitResult.status);
 
 	if (!fitResult.valid) {
 		DEBUG("fit result not valid");
 		return;
 	}
 
 	uiGeneralTab.twLog->item(1, 1)->setText(QString::number(fitResult.iterations));
 	uiGeneralTab.twLog->item(2, 1)->setText(QString::number(m_fitData.eps));
 	if (fitResult.elapsedTime > 1000)
 		uiGeneralTab.twLog->item(3, 1)->setText(QString::number(fitResult.elapsedTime/1000) + " s");
 	else
 		uiGeneralTab.twLog->item(3, 1)->setText(QString::number(fitResult.elapsedTime) + " ms");
 
 	uiGeneralTab.twLog->item(4, 1)->setText(QString::number(fitResult.dof));
 	uiGeneralTab.twLog->item(5, 1)->setText(QString::number(fitResult.paramValues.size()));
 	uiGeneralTab.twLog->item(6, 1)->setText(QString::number(m_fitData.xRange.first()) + " .. " + QString::number(m_fitData.xRange.last()) );
 
 	// show all iterations
 	QString str;
 	for (const auto &s: m_fitData.paramNamesUtf8)
 		str += s + '\t';
 	str += QString::fromUtf8("\u03c7") + QString::fromUtf8("\u00b2");
 
 	const QStringList iterations = fitResult.solverOutput.split(';');
 	for (const auto &s: iterations)
 		if (!s.isEmpty())
 			str += '\n' + s;
 	uiGeneralTab.twLog->item(7, 1)->setText(str);
 	uiGeneralTab.twLog->resizeRowsToContents();
 
 	// Parameters
 	const int np = m_fitData.paramNames.size();
 	uiGeneralTab.twParameters->setRowCount(np);
 	QStringList headerLabels;
 	headerLabels << i18n("Name") << i18n("Value") << i18n("Error") << i18n("Error, %") << i18n("t statistic") << QLatin1String("P > |t|") << i18n("Conf. Interval");
 	uiGeneralTab.twParameters->setHorizontalHeaderLabels(headerLabels);
 
 	for (int i = 0; i < np; i++) {
 		const double paramValue = fitResult.paramValues.at(i);
 		const double errorValue = fitResult.errorValues.at(i);
 
 		QTableWidgetItem* item = new QTableWidgetItem(m_fitData.paramNamesUtf8.at(i));
 		item->setBackground(QApplication::palette().color(QPalette::Window));
 		uiGeneralTab.twParameters->setItem(i, 0, item);
 		item = new QTableWidgetItem(QString::number(paramValue));
 		uiGeneralTab.twParameters->setItem(i, 1, item);
 
 		if (!m_fitData.paramFixed.at(i)) {
 			if (!std::isnan(errorValue)) {
 				item = new QTableWidgetItem(QString::number(errorValue, 'g', 6));
 				uiGeneralTab.twParameters->setItem(i, 2, item);
 				item = new QTableWidgetItem(QString::number(100.*errorValue/std::abs(paramValue), 'g', 3));
 				uiGeneralTab.twParameters->setItem(i, 3, item);
 			} else {
 				item = new QTableWidgetItem(QString::fromUtf8("\u221e"));
 				uiGeneralTab.twParameters->setItem(i, 2, item);
 				item = new QTableWidgetItem(QString::fromUtf8("\u221e"));
 				uiGeneralTab.twParameters->setItem(i, 3, item);
 			}
 
 			// t values
 			QString tdistValueString;
 			if (fitResult.tdist_tValues.at(i) < std::numeric_limits<double>::max())
 				tdistValueString = QString::number(fitResult.tdist_tValues.at(i), 'g', 3);
 			else
 				tdistValueString = QString::fromUtf8("\u221e");
 			item = new QTableWidgetItem(tdistValueString);
 			uiGeneralTab.twParameters->setItem(i, 4, item);
 
 			// p values
 			const double p = fitResult.tdist_pValues.at(i);
 			item = new QTableWidgetItem(QString::number(p, 'g', 3));
 			// color p values depending on value
 			if (p > 0.05)
 				item->setTextColor(QApplication::palette().color(QPalette::LinkVisited));
 			else if (p > 0.01)
 				item->setTextColor(Qt::darkGreen);
 			else if (p > 0.001)
 				item->setTextColor(Qt::darkCyan);
 			else if (p > 0.0001)
 				item->setTextColor(QApplication::palette().color(QPalette::Link));
 			else
 				item->setTextColor(QApplication::palette().color(QPalette::Highlight));
 			uiGeneralTab.twParameters->setItem(i, 5, item);
 
 			// Conf. interval
 			if (!std::isnan(errorValue)) {
 				const double margin = fitResult.tdist_marginValues.at(i);
 				if (fitResult.tdist_tValues.at(i) < 1.e6)
 					item = new QTableWidgetItem(QString::number(paramValue - margin) + QLatin1String(" .. ") + QString::number(paramValue + margin));
 				else
 					item = new QTableWidgetItem(i18n("too small"));
 				uiGeneralTab.twParameters->setItem(i, 6, item);
 			}
 		}
 	}
 
 	// Goodness of fit
 	uiGeneralTab.twGoodness->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
 	uiGeneralTab.twGoodness->item(0, 2)->setText(QString::number(fitResult.sse));
 
 	if (fitResult.dof != 0) {
 		uiGeneralTab.twGoodness->item(1, 2)->setText(QString::number(fitResult.rms));
 		uiGeneralTab.twGoodness->item(2, 2)->setText(QString::number(fitResult.rsd));
 
 		uiGeneralTab.twGoodness->item(3, 2)->setText(QString::number(fitResult.rsquare, 'g', 15));
 		uiGeneralTab.twGoodness->item(4, 2)->setText(QString::number(fitResult.rsquareAdj, 'g', 15));
 
 		// chi^2 and F test p-values
 		uiGeneralTab.twGoodness->item(5, 2)->setText(QString::number(fitResult.chisq_p, 'g', 3));
 		uiGeneralTab.twGoodness->item(6, 2)->setText(QString::number(fitResult.fdist_F, 'g', 3));
 		uiGeneralTab.twGoodness->item(7, 2)->setText(QString::number(fitResult.fdist_p, 'g', 3));
 		uiGeneralTab.twGoodness->item(9, 2)->setText(QString::number(fitResult.aic, 'g', 3));
 		uiGeneralTab.twGoodness->item(10, 2)->setText(QString::number(fitResult.bic, 'g', 3));
 	}
 
 	uiGeneralTab.twGoodness->item(8, 2)->setText(QString::number(fitResult.mae));
 
 	//resize the table headers to fit the new content
 	uiGeneralTab.twLog->resizeColumnsToContents();
 	uiGeneralTab.twParameters->resizeColumnsToContents();
 	//twGoodness doesn't have any header -> resize sections
 	uiGeneralTab.twGoodness->resizeColumnToContents(0);
 	uiGeneralTab.twGoodness->resizeColumnToContents(1);
 	uiGeneralTab.twGoodness->resizeColumnToContents(2);
 
 	//enable the "recalculate"-button if the source data was changed since the last fit
 	uiGeneralTab.pbRecalculate->setEnabled(m_fitCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYFitCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text()) {
 		uiGeneralTab.leName->setText(aspect->name());
 	} else if (aspect->comment() != uiGeneralTab.leComment->text()) {
 		uiGeneralTab.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveDataSourceTypeChanged(XYCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveXErrorColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXErrorColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveYErrorColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYErrorColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveFitDataChanged(const XYFitCurve::FitData& data) {
 	m_initializing = true;
 	m_fitData = data;
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		uiGeneralTab.teEquation->setPlainText(m_fitData.model);
 	else
 		uiGeneralTab.cbModel->setCurrentIndex(m_fitData.modelType);
 
 	uiGeneralTab.sbDegree->setValue(m_fitData.degree);
 	this->showFitResult();
 	m_initializing = false;
 }
 
 void XYFitCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYFourierFilterCurveDock.cpp b/src/kdefrontend/dockwidgets/XYFourierFilterCurveDock.cpp
index fd8e6da6a..d6c72500c 100644
--- a/src/kdefrontend/dockwidgets/XYFourierFilterCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYFourierFilterCurveDock.cpp
@@ -1,715 +1,715 @@
 /***************************************************************************
     File             : XYFourierFilterCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Description      : widget for editing properties of Fourier filter curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "XYFourierFilterCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYFourierFilterCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <KMessageBox>
 #ifndef NDEBUG
 #include <QDebug>
 #endif
 
 /*!
   \class XYFourierFilterCurveDock
  \brief  Provides a widget for editing the properties of the XYFourierFilterCurves
 		(2D-curves defined by a Fourier filter) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYFourierFilterCurveDock::XYFourierFilterCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_filterCurve(nullptr) {
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYFourierFilterCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
 	QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 3);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 2);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 2);
 
 	for(int i=0; i < NSL_FILTER_TYPE_COUNT; i++)
 		uiGeneralTab.cbType->addItem(i18n(nsl_filter_type_name[i]));
 
 	for(int i=0; i < NSL_FILTER_FORM_COUNT; i++)
 		uiGeneralTab.cbForm->addItem(i18n(nsl_filter_form_name[i]));
 
 	for(int i=0; i < NSL_FILTER_CUTOFF_UNIT_COUNT; i++) {
 		uiGeneralTab.cbUnit->addItem(i18n(nsl_filter_cutoff_unit_name[i]));
 		uiGeneralTab.cbUnit2->addItem(i18n(nsl_filter_cutoff_unit_name[i]));
 	}
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	QHBoxLayout* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, SIGNAL(returnPressed()), this, SLOT(nameChanged()) );
 	connect( uiGeneralTab.leComment, SIGNAL(returnPressed()), this, SLOT(commentChanged()) );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged()) );
 	connect( uiGeneralTab.cbForm, SIGNAL(currentIndexChanged(int)), this, SLOT(formChanged()) );
 	connect( uiGeneralTab.sbOrder, SIGNAL(valueChanged(int)), this, SLOT(orderChanged()) );
 	connect( uiGeneralTab.sbCutoff, SIGNAL(valueChanged(double)), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.sbCutoff2, SIGNAL(valueChanged(double)), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.cbUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(unitChanged()) );
 	connect( uiGeneralTab.cbUnit2, SIGNAL(currentIndexChanged(int)), this, SLOT(unit2Changed()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYFourierFilterCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1){
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_filterCurve = dynamic_cast<XYFourierFilterCurve*>(m_curve);
 	Q_ASSERT(m_filterCurve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_filterCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_filterCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_filterCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_filterCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_filterData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_filterData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_filterData.xRange.last());
 	this->autoRangeChanged();
 
 	uiGeneralTab.cbType->setCurrentIndex(m_filterData.type);
 	this->typeChanged();
 	uiGeneralTab.cbForm->setCurrentIndex(m_filterData.form);
 	this->formChanged();
 	uiGeneralTab.sbOrder->setValue(m_filterData.order);
 	uiGeneralTab.cbUnit->setCurrentIndex(m_filterData.unit);
 	this->unitChanged();
 	// after unit has set
 	uiGeneralTab.sbCutoff->setValue(m_filterData.cutoff);
 	uiGeneralTab.cbUnit2->setCurrentIndex(m_filterData.unit2);
 	this->unit2Changed();
 	// after unit has set
 	uiGeneralTab.sbCutoff2->setValue(m_filterData.cutoff2);
 	this->showFilterResult();
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_filterCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_filterCurve, SIGNAL(dataSourceTypeChanged(XYCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYCurve::DataSourceType)));
 	connect(m_filterCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_filterCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_filterCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_filterCurve, SIGNAL(filterDataChanged(XYFourierFilterCurve::FilterData)), this, SLOT(curveFilterDataChanged(XYFourierFilterCurve::FilterData)));
 	connect(m_filterCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYFourierFilterCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	foreach (XYCurve* curve, m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 		<<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYFourierFilterCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_filterCurve = dynamic_cast<XYFourierFilterCurve*>(m_curve);
 	Q_ASSERT(m_filterCurve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_filterData = m_filterCurve->filterData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYFourierFilterCurveDock::nameChanged(){
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYFourierFilterCurveDock::commentChanged(){
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYFourierFilterCurveDock::dataSourceTypeChanged(int index) {
 	XYCurve::DataSourceType type = (XYCurve::DataSourceType)index;
 	if (type == XYCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	foreach(XYCurve* curve, m_curvesList)
 		curve->setDataSourceType(type);
 }
 
 void XYFourierFilterCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = 0;
 	if (aspect) {
 		dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 		Q_ASSERT(dataSourceCurve);
 	}
 
 	// update range of cutoff spin boxes (like a unit change)
 	unitChanged();
 	unit2Changed();
 
 	if (m_initializing)
 		return;
 
 	foreach(XYCurve* curve, m_curvesList)
 		curve->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYFourierFilterCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	foreach(XYCurve* curve, m_curvesList)
 		dynamic_cast<XYFourierFilterCurve*>(curve)->setXDataColumn(column);
 
 	// update range of cutoff spin boxes (like a unit change)
 	unitChanged();
 	unit2Changed();
 
 	if (column != 0) {
 		if (uiGeneralTab.cbAutoRange->isChecked()) {
 			uiGeneralTab.sbMin->setValue(column->minimum());
 			uiGeneralTab.sbMax->setValue(column->maximum());
 		}
 	}
 }
 
 void XYFourierFilterCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	foreach(XYCurve* curve, m_curvesList)
 		dynamic_cast<XYFourierFilterCurve*>(curve)->setYDataColumn(column);
 }
 
 void XYFourierFilterCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_filterData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = 0;
 		if (m_filterCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet)
 			xDataColumn = m_filterCurve->xDataColumn();
 		else {
 			if (m_filterCurve->dataSourceCurve())
 				xDataColumn = m_filterCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYFourierFilterCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_filterData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYFourierFilterCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_filterData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYFourierFilterCurveDock::typeChanged() {
 	nsl_filter_type type = (nsl_filter_type)uiGeneralTab.cbType->currentIndex();
 	m_filterData.type = type;
 
 	switch (type) {
 	case nsl_filter_type_low_pass:
 	case nsl_filter_type_high_pass:
 		uiGeneralTab.lCutoff->setText(i18n("Cutoff"));
 		uiGeneralTab.lCutoff2->setVisible(false);
 		uiGeneralTab.sbCutoff2->setVisible(false);
 		uiGeneralTab.cbUnit2->setVisible(false);
 		break;
 	case nsl_filter_type_band_pass:
 	case nsl_filter_type_band_reject:
 		uiGeneralTab.lCutoff2->setVisible(true);
 		uiGeneralTab.lCutoff->setText(i18n("Lower Cutoff"));
 		uiGeneralTab.lCutoff2->setText(i18n("Upper Cutoff"));
 		uiGeneralTab.sbCutoff2->setVisible(true);
 		uiGeneralTab.cbUnit2->setVisible(true);
 		break;
 //TODO
 /*	case nsl_filter_type_threshold:
 		uiGeneralTab.lCutoff->setText(i18n("Value"));
 		uiGeneralTab.lCutoff2->setVisible(false);
 		uiGeneralTab.sbCutoff2->setVisible(false);
 		uiGeneralTab.cbUnit2->setVisible(false);
 */
 	}
 
 	enableRecalculate();
 }
 
 void XYFourierFilterCurveDock::formChanged() {
 	nsl_filter_form form = (nsl_filter_form)uiGeneralTab.cbForm->currentIndex();
 	m_filterData.form = form;
 
 	switch (form) {
 	case nsl_filter_form_ideal:
 		uiGeneralTab.sbOrder->setVisible(false);
 		uiGeneralTab.lOrder->setVisible(false);
 		break;
 	case nsl_filter_form_butterworth:
 	case nsl_filter_form_chebyshev_i:
 	case nsl_filter_form_chebyshev_ii:
 	case nsl_filter_form_legendre:
 	case nsl_filter_form_bessel:
 		uiGeneralTab.sbOrder->setVisible(true);
 		uiGeneralTab.lOrder->setVisible(true);
 		break;
 	}
 
 	enableRecalculate();
 }
 
 void XYFourierFilterCurveDock::orderChanged() {
-	m_filterData.order = uiGeneralTab.sbOrder->value();
+	m_filterData.order = (unsigned int)uiGeneralTab.sbOrder->value();
 
 	enableRecalculate();
 }
 
 void XYFourierFilterCurveDock::unitChanged() {
 	nsl_filter_cutoff_unit unit = (nsl_filter_cutoff_unit)uiGeneralTab.cbUnit->currentIndex();
 	nsl_filter_cutoff_unit oldUnit = m_filterData.unit;
 	double oldValue = uiGeneralTab.sbCutoff->value();
 	m_filterData.unit = unit;
 
 	int n = 100;
 	double f = 1.0; // sample frequency
 	const AbstractColumn* xDataColumn = nullptr;
 	if (m_filterCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet)
 		xDataColumn = m_filterCurve->xDataColumn();
 	else {
 		if (m_filterCurve->dataSourceCurve())
 			xDataColumn = m_filterCurve->dataSourceCurve()->xColumn();
 	}
 
 	if (xDataColumn != nullptr) {
 		n = xDataColumn->rowCount();
 		double range = xDataColumn->maximum() - xDataColumn->minimum();
 		f = (n-1)/range/2.;
 #ifndef NDEBUG
 		qDebug()<<" n ="<<n<<" sample frequency ="<<f;
 #endif
 	}
 
 	switch (unit) {
 	case nsl_filter_cutoff_unit_frequency:
 		uiGeneralTab.sbCutoff->setDecimals(6);
 		uiGeneralTab.sbCutoff->setMaximum(f);
 		uiGeneralTab.sbCutoff->setSingleStep(0.01*f);
 		uiGeneralTab.sbCutoff->setSuffix(" Hz");
 		switch (oldUnit) {
 		case nsl_filter_cutoff_unit_frequency:
 			break;
 		case nsl_filter_cutoff_unit_fraction:
 			uiGeneralTab.sbCutoff->setValue(oldValue*f);
 			break;
 		case nsl_filter_cutoff_unit_index:
 			uiGeneralTab.sbCutoff->setValue(oldValue*f/n);
 			break;
 		}
 		break;
 	case nsl_filter_cutoff_unit_fraction:
 		uiGeneralTab.sbCutoff->setDecimals(6);
 		uiGeneralTab.sbCutoff->setMaximum(1.0);
 		uiGeneralTab.sbCutoff->setSingleStep(0.01);
 		uiGeneralTab.sbCutoff->setSuffix("");
 		switch (oldUnit) {
 		case nsl_filter_cutoff_unit_frequency:
 			uiGeneralTab.sbCutoff->setValue(oldValue/f);
 			break;
 		case nsl_filter_cutoff_unit_fraction:
 			break;
 		case nsl_filter_cutoff_unit_index:
 			uiGeneralTab.sbCutoff->setValue(oldValue/n);
 			break;
 		}
 		break;
 	case nsl_filter_cutoff_unit_index:
 		uiGeneralTab.sbCutoff->setDecimals(0);
 		uiGeneralTab.sbCutoff->setSingleStep(1);
 		uiGeneralTab.sbCutoff->setMaximum(n);
 		uiGeneralTab.sbCutoff->setSuffix("");
 		switch (oldUnit) {
 		case nsl_filter_cutoff_unit_frequency:
 			uiGeneralTab.sbCutoff->setValue(oldValue*n/f);
 			break;
 		case nsl_filter_cutoff_unit_fraction:
 			uiGeneralTab.sbCutoff->setValue(oldValue*n);
 			break;
 		case nsl_filter_cutoff_unit_index:
 			break;
 		}
 		break;
 	}
 
 	enableRecalculate();
 }
 
 void XYFourierFilterCurveDock::unit2Changed() {
 	nsl_filter_cutoff_unit unit = (nsl_filter_cutoff_unit)uiGeneralTab.cbUnit2->currentIndex();
 	nsl_filter_cutoff_unit oldUnit = m_filterData.unit2;
 	double oldValue = uiGeneralTab.sbCutoff2->value();
 	m_filterData.unit2 = unit;
 
 	int n = 100;
 	double f = 1.0; // sample frequency
 	const AbstractColumn* xDataColumn = nullptr;
 	if (m_filterCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet)
 		xDataColumn = m_filterCurve->xDataColumn();
 	else {
 		if (m_filterCurve->dataSourceCurve())
 			xDataColumn = m_filterCurve->dataSourceCurve()->xColumn();
 	}
 
 	if (xDataColumn != nullptr) {
 		n = xDataColumn->rowCount();
 		double range = xDataColumn->maximum() - xDataColumn->minimum();
 		f = (n-1)/range/2.;
 #ifndef NDEBUG
 		qDebug()<<" n ="<<n<<" sample frequency ="<<f;
 #endif
 	}
 
 	switch (unit) {
 	case nsl_filter_cutoff_unit_frequency:
 		uiGeneralTab.sbCutoff2->setDecimals(6);
 		uiGeneralTab.sbCutoff2->setMaximum(f);
 		uiGeneralTab.sbCutoff2->setSingleStep(0.01*f);
 		uiGeneralTab.sbCutoff2->setSuffix(" Hz");
 		switch (oldUnit) {
 		case nsl_filter_cutoff_unit_frequency:
 			break;
 		case nsl_filter_cutoff_unit_fraction:
 			uiGeneralTab.sbCutoff2->setValue(oldValue*f);
 			break;
 		case nsl_filter_cutoff_unit_index:
 			uiGeneralTab.sbCutoff2->setValue(oldValue*f/n);
 			break;
 		}
 		break;
 	case nsl_filter_cutoff_unit_fraction:
 		uiGeneralTab.sbCutoff2->setDecimals(6);
 		uiGeneralTab.sbCutoff2->setMaximum(1.0);
 		uiGeneralTab.sbCutoff2->setSingleStep(0.01);
 		uiGeneralTab.sbCutoff2->setSuffix("");
 		switch (oldUnit) {
 		case nsl_filter_cutoff_unit_frequency:
 			uiGeneralTab.sbCutoff2->setValue(oldValue/f);
 			break;
 		case nsl_filter_cutoff_unit_fraction:
 			break;
 		case nsl_filter_cutoff_unit_index:
 			uiGeneralTab.sbCutoff2->setValue(oldValue/n);
 			break;
 		}
 		break;
 	case nsl_filter_cutoff_unit_index:
 		uiGeneralTab.sbCutoff2->setDecimals(0);
 		uiGeneralTab.sbCutoff2->setSingleStep(1);
 		uiGeneralTab.sbCutoff2->setMaximum(n);
 		uiGeneralTab.sbCutoff2->setSuffix("");
 		switch (oldUnit) {
 		case nsl_filter_cutoff_unit_frequency:
 			uiGeneralTab.sbCutoff2->setValue(oldValue*n/f);
 			break;
 		case nsl_filter_cutoff_unit_fraction:
 			uiGeneralTab.sbCutoff2->setValue(oldValue*n);
 			break;
 		case nsl_filter_cutoff_unit_index:
 			break;
 		}
 		break;
 	}
 
 	enableRecalculate();
 }
 
 void XYFourierFilterCurveDock::recalculateClicked() {
 	m_filterData.cutoff = uiGeneralTab.sbCutoff->value();
 	m_filterData.cutoff2 = uiGeneralTab.sbCutoff2->value();
 
 	if ((m_filterData.type == nsl_filter_type_band_pass || m_filterData.type == nsl_filter_type_band_reject)
 			&& m_filterData.cutoff2 <= m_filterData.cutoff) {
 		KMessageBox::sorry(this, i18n("The band width is <= 0 since lower cutoff value is not smaller than upper cutoff value. Please fix this."),
 			                   i18n("band width <= 0") );
 		return;
 	}
 
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 	foreach(XYCurve* curve, m_curvesList)
 		dynamic_cast<XYFourierFilterCurve*>(curve)->setFilterData(m_filterData);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Fourier-Filter status: ") + m_filterCurve->filterResult().status);
 	QApplication::restoreOverrideCursor();
 }
 
 void XYFourierFilterCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no filtering possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_filterCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=0 && aspectY!=0);
 	} else {
 		 hasSourceData = (m_filterCurve->dataSourceCurve() != NULL);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the filter
  */
 void XYFourierFilterCurveDock::showFilterResult() {
 	const XYFourierFilterCurve::FilterResult& filterResult = m_filterCurve->filterResult();
 	if (!filterResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	QString str = i18n("status:") + ' ' + filterResult.status + "<br>";
 
 	if (!filterResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (filterResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s").arg(QString::number(filterResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms").arg(QString::number(filterResult.elapsedTime)) + "<br>";
 
  	str += "<br><br>";
 
 	uiGeneralTab.teResult->setText(str);
 
 	//enable the "recalculate"-button if the source data was changed since the last filter
 	uiGeneralTab.pbRecalculate->setEnabled(m_filterCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYFourierFilterCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text()) {
 		uiGeneralTab.leName->setText(aspect->name());
 	} else if (aspect->comment() != uiGeneralTab.leComment->text()) {
 		uiGeneralTab.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void XYFourierFilterCurveDock::curveDataSourceTypeChanged(XYCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYFourierFilterCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYFourierFilterCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYFourierFilterCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYFourierFilterCurveDock::curveFilterDataChanged(const XYFourierFilterCurve::FilterData& data) {
 	m_initializing = true;
 	m_filterData = data;
 	uiGeneralTab.cbType->setCurrentIndex(m_filterData.type);
 	this->typeChanged();
 
 	this->showFilterResult();
 	m_initializing = false;
 }
 
 void XYFourierFilterCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp b/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp
index 76a615407..ec9733d2c 100644
--- a/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp
@@ -1,612 +1,612 @@
 /***************************************************************************
     File             : XYSmoothCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright        : (C) 2017 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of smooth curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "XYSmoothCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYSmoothCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 
 /*!
   \class XYSmoothCurveDock
  \brief  Provides a widget for editing the properties of the XYSmoothCurves
 		(2D-curves defined by an smooth) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYSmoothCurveDock::XYSmoothCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_smoothCurve(nullptr) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYSmoothCurveDock::setupGeneral() {
 #ifndef NDEBUG
 	qDebug()<<"XYSmoothCurveDock::setupGeneral()";
 #endif
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
 	QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 2);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 2);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 2);
 
 	for (int i=0; i < NSL_SMOOTH_TYPE_COUNT; i++)
 		uiGeneralTab.cbType->addItem(i18n(nsl_smooth_type_name[i]));
 
 	for (int i=0; i < NSL_SMOOTH_WEIGHT_TYPE_COUNT; i++)
 		uiGeneralTab.cbWeight->addItem(i18n(nsl_smooth_weight_type_name[i]));
 
 	for (int i=0; i < NSL_SMOOTH_PAD_MODE_COUNT; i++)
 		uiGeneralTab.cbMode->addItem(i18n(nsl_smooth_pad_mode_name[i]));
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	QHBoxLayout* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, SIGNAL(returnPressed()), this, SLOT(nameChanged()) );
 	connect( uiGeneralTab.leComment, SIGNAL(returnPressed()), this, SLOT(commentChanged()) );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged()) );
 	connect( uiGeneralTab.sbPoints, SIGNAL(valueChanged(int)), this, SLOT(pointsChanged()) );
 	connect( uiGeneralTab.cbWeight, SIGNAL(currentIndexChanged(int)), this, SLOT(weightChanged()) );
 	connect( uiGeneralTab.sbPercentile, SIGNAL(valueChanged(double)), this, SLOT(percentileChanged()) );
 	connect( uiGeneralTab.sbOrder, SIGNAL(valueChanged(int)), this, SLOT(orderChanged()) );
 	connect( uiGeneralTab.cbMode, SIGNAL(currentIndexChanged(int)), this, SLOT(modeChanged()) );
 	connect( uiGeneralTab.sbLeftValue, SIGNAL(valueChanged(double)), this, SLOT(valueChanged()) );
 	connect( uiGeneralTab.sbRightValue, SIGNAL(valueChanged(double)), this, SLOT(valueChanged()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYSmoothCurveDock::initGeneralTab() {
 #ifndef NDEBUG
 	qDebug()<<"XYSmoothCurveDock::initGeneralTab()";
 #endif
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_smoothCurve = dynamic_cast<XYSmoothCurve*>(m_curve);
 	Q_ASSERT(m_smoothCurve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_smoothCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_smoothCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_smoothCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_smoothCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_smoothData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_smoothData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_smoothData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbType->setCurrentIndex(m_smoothData.type);
 	typeChanged();	// needed, when type does not change
 #ifndef NDEBUG
 	qDebug()<<"	curve ="<<m_smoothCurve->name();
 	qDebug()<<"	m_smoothData.points ="<<m_smoothData.points;
 #endif
 	uiGeneralTab.sbPoints->setValue(m_smoothData.points);
 	uiGeneralTab.cbWeight->setCurrentIndex(m_smoothData.weight);
 	uiGeneralTab.sbPercentile->setValue(m_smoothData.percentile);
 	uiGeneralTab.sbOrder->setValue(m_smoothData.order);
 	uiGeneralTab.cbMode->setCurrentIndex(m_smoothData.mode);
 	modeChanged();	// needed, when mode does not change
 	uiGeneralTab.sbLeftValue->setValue(m_smoothData.lvalue);
 	uiGeneralTab.sbRightValue->setValue(m_smoothData.rvalue);
 	valueChanged();
 	this->showSmoothResult();
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_smoothCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_smoothCurve, SIGNAL(dataSourceTypeChanged(XYCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYCurve::DataSourceType)));
 	connect(m_smoothCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_smoothCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_smoothCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_smoothCurve, SIGNAL(smoothDataChanged(XYSmoothCurve::SmoothData)), this, SLOT(curveSmoothDataChanged(XYSmoothCurve::SmoothData)));
 	connect(m_smoothCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYSmoothCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for(XYCurve* curve: m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 		<<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve"<<"CantorWorksheet";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYSmoothCurveDock::setCurves(QList<XYCurve*> list) {
 #ifndef NDEBUG
 	qDebug()<<"XYSmoothCurveDock::setCurves()";
 #endif
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_smoothCurve = dynamic_cast<XYSmoothCurve*>(m_curve);
 	Q_ASSERT(m_smoothCurve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_smoothData = m_smoothCurve->smoothData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYSmoothCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYSmoothCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYSmoothCurveDock::dataSourceTypeChanged(int index) {
 	XYCurve::DataSourceType type = (XYCurve::DataSourceType)index;
 	if (type == XYCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYSmoothCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = 0;
 	if (aspect) {
 		dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 		Q_ASSERT(dataSourceCurve);
 	}
 
 	if (m_initializing)
 		return;
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYSmoothCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setXDataColumn(column);
 
 	// disable types that need more data points
 	if (column != 0) {
 		if (uiGeneralTab.cbAutoRange->isChecked()) {
 			uiGeneralTab.sbMin->setValue(column->minimum());
 			uiGeneralTab.sbMax->setValue(column->maximum());
 		}
 
-		unsigned int n=0;
-		for (int row=0; row < column->rowCount(); row++)
+		unsigned int n = 0;
+		for (int row = 0; row < column->rowCount(); row++)
 			if (!std::isnan(column->valueAt(row)) && !column->isMasked(row))
 				n++;
 
 		// set maximum of sbPoints to number of columns
-		uiGeneralTab.sbPoints->setMaximum(n);
+		uiGeneralTab.sbPoints->setMaximum((int)n);
 	}
 
 }
 
 void XYSmoothCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = 0;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setYDataColumn(column);
 }
 
 void XYSmoothCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_smoothData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = 0;
 		if (m_smoothCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet)
 			xDataColumn = m_smoothCurve->xDataColumn();
 		else {
 			if (m_smoothCurve->dataSourceCurve())
 				xDataColumn = m_smoothCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYSmoothCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_smoothData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYSmoothCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_smoothData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYSmoothCurveDock::typeChanged() {
 	nsl_smooth_type type = (nsl_smooth_type)uiGeneralTab.cbType->currentIndex();
 	m_smoothData.type = type;
 
 	const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbMode->model());
 	QStandardItem* pad_interp_item = model->item(nsl_smooth_pad_interp);
 	if (type == nsl_smooth_type_moving_average || type == nsl_smooth_type_moving_average_lagged) {
 		uiGeneralTab.lWeight->show();
 		uiGeneralTab.cbWeight->show();
 		// disable interp pad model for MA and MAL
 		pad_interp_item->setFlags(pad_interp_item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 	} else {
 		uiGeneralTab.lWeight->hide();
 		uiGeneralTab.cbWeight->hide();
 		pad_interp_item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 	}
 
 	if (type == nsl_smooth_type_moving_average_lagged) {
 		uiGeneralTab.sbPoints->setSingleStep(1);
 		uiGeneralTab.sbPoints->setMinimum(2);
 		uiGeneralTab.lRightValue->hide();
 		uiGeneralTab.sbRightValue->hide();
 	} else {
 		uiGeneralTab.sbPoints->setSingleStep(2);
 		uiGeneralTab.sbPoints->setMinimum(3);
 		if (m_smoothData.mode == nsl_smooth_pad_constant) {
 			uiGeneralTab.lRightValue->show();
 			uiGeneralTab.sbRightValue->show();
 		}
 	}
 
 	if (type == nsl_smooth_type_percentile) {
 		uiGeneralTab.lPercentile->show();
 		uiGeneralTab.sbPercentile->show();
 		// disable interp pad model for MA and MAL
 		pad_interp_item->setFlags(pad_interp_item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 	} else {
 		uiGeneralTab.lPercentile->hide();
 		uiGeneralTab.sbPercentile->hide();
 	}
 
 	if (type == nsl_smooth_type_savitzky_golay) {
 		uiGeneralTab.lOrder->show();
 		uiGeneralTab.sbOrder->show();
 	} else {
 		uiGeneralTab.lOrder->hide();
 		uiGeneralTab.sbOrder->hide();
 	}
 
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::pointsChanged() {
 	m_smoothData.points = uiGeneralTab.sbPoints->value();
 
 	// set maximum order
 	uiGeneralTab.sbOrder->setMaximum(m_smoothData.points-1);
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::weightChanged() {
 	m_smoothData.weight = (nsl_smooth_weight_type)uiGeneralTab.cbWeight->currentIndex();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::percentileChanged() {
 	m_smoothData.percentile = uiGeneralTab.sbPercentile->value();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::orderChanged() {
 	m_smoothData.order = uiGeneralTab.sbOrder->value();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::modeChanged() {
 	m_smoothData.mode = (nsl_smooth_pad_mode)(uiGeneralTab.cbMode->currentIndex());
 
 	if (m_smoothData.mode == nsl_smooth_pad_constant) {
 		uiGeneralTab.lLeftValue->show();
 		uiGeneralTab.sbLeftValue->show();
 		if (m_smoothData.type == nsl_smooth_type_moving_average_lagged) {
 			uiGeneralTab.lRightValue->hide();
 			uiGeneralTab.sbRightValue->hide();
 		} else {
 			uiGeneralTab.lRightValue->show();
 			uiGeneralTab.sbRightValue->show();
 		}
 	} else {
 		uiGeneralTab.lLeftValue->hide();
 		uiGeneralTab.sbLeftValue->hide();
 		uiGeneralTab.lRightValue->hide();
 		uiGeneralTab.sbRightValue->hide();
 	}
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::valueChanged() {
 	m_smoothData.lvalue = uiGeneralTab.sbLeftValue->value();
 	m_smoothData.rvalue = uiGeneralTab.sbRightValue->value();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::recalculateClicked() {
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setSmoothData(m_smoothData);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Smoothing status: ") +  m_smoothCurve->smoothResult().status);
 	QApplication::restoreOverrideCursor();
 }
 
 void XYSmoothCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no smoothing possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_smoothCurve->dataSourceType() == XYCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=0 && aspectY!=0);
 	} else {
 		 hasSourceData = (m_smoothCurve->dataSourceCurve() != NULL);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the smooth
  */
 void XYSmoothCurveDock::showSmoothResult() {
 	const XYSmoothCurve::SmoothResult& smoothResult = m_smoothCurve->smoothResult();
 	if (!smoothResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	//const XYSmoothCurve::SmoothData& smoothData = m_smoothCurve->smoothData();
 	QString str = i18n("status:") + ' ' + smoothResult.status + "<br>";
 
 	if (!smoothResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (smoothResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s").arg(QString::number(smoothResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms").arg(QString::number(smoothResult.elapsedTime)) + "<br>";
 
  	str += "<br><br>";
 
 	uiGeneralTab.teResult->setText(str);
 
 	//enable the "recalculate"-button if the source data was changed since the last smooth
 	uiGeneralTab.pbRecalculate->setEnabled(m_smoothCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYSmoothCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text()) {
 		uiGeneralTab.leName->setText(aspect->name());
 	} else if (aspect->comment() != uiGeneralTab.leComment->text()) {
 		uiGeneralTab.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveDataSourceTypeChanged(XYCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveSmoothDataChanged(const XYSmoothCurve::SmoothData& data) {
 	m_initializing = true;
 	m_smoothData = data;
 	uiGeneralTab.cbType->setCurrentIndex(m_smoothData.type);
 
 	this->showSmoothResult();
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp b/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp
index a320b307d..2e8b18013 100644
--- a/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp
+++ b/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp
@@ -1,355 +1,355 @@
 /***************************************************************************
     File                 : FunctionValuesDialog.cpp
     Project              : LabPlot
     Description          : Dialog for generating values from a mathematical function
     --------------------------------------------------------------------
     Copyright            : (C) 2014-2015 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or 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.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 #include "FunctionValuesDialog.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/Project.h"
 #include "backend/gsl/ExpressionParser.h"
 #include "backend/lib/macros.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/widgets/ConstantsWidget.h"
 #include "kdefrontend/widgets/FunctionsWidget.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 #include <cmath>
 
 /*!
 	\class FunctionValuesDialog
 	\brief Dialog for generating values from a mathematical function.
 
 	\ingroup kdefrontend
  */
 
 FunctionValuesDialog::FunctionValuesDialog(Spreadsheet* s, QWidget* parent, Qt::WFlags fl) : QDialog(parent, fl), m_spreadsheet(s) {
 	Q_ASSERT(s);
 	setWindowTitle(i18n("Function values"));
 
 	ui.setupUi(this);
     setAttribute(Qt::WA_DeleteOnClose);
 	ui.tbConstants->setIcon( QIcon::fromTheme("labplot-format-text-symbol") );
 
 	ui.tbConstants->setIcon( QIcon::fromTheme("format-text-symbol") );
 	ui.tbFunctions->setIcon( QIcon::fromTheme("preferences-desktop-font") );
 
 	ui.teEquation->setMaximumHeight(QLineEdit().sizeHint().height()*2);
 	ui.teEquation->setFocus();
 
 	m_topLevelClasses<<"Folder"<<"Workbook"<<"Spreadsheet"<<"FileDataSource"<<"Column";
 	m_selectableClasses<<"Column";
 
 #if __cplusplus < 201103L
 	m_aspectTreeModel = std::auto_ptr<AspectTreeModel>(new AspectTreeModel(m_spreadsheet->project()));
 #else
 	m_aspectTreeModel = std::unique_ptr<AspectTreeModel>(new AspectTreeModel(m_spreadsheet->project()));
 #endif
 	m_aspectTreeModel->setSelectableAspects(m_selectableClasses);
 
 	ui.bAddVariable->setIcon(QIcon::fromTheme("list-add"));
 	ui.bAddVariable->setToolTip(i18n("Add new variable"));
 
 	QDialogButtonBox* btnBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
 	ui.verticalLayout->addWidget(btnBox);
 	m_okButton = btnBox->button(QDialogButtonBox::Ok);
 
 	connect(btnBox, &QDialogButtonBox::accepted, this, &FunctionValuesDialog::accept);
 	connect(btnBox, &QDialogButtonBox::rejected, this, &FunctionValuesDialog::reject);
 	m_okButton->setText(i18n("&Generate"));
 	m_okButton->setToolTip(i18n("Generate function values"));
 
 	connect( ui.bAddVariable, SIGNAL(pressed()), this, SLOT(addVariable()) );
 	connect( ui.teEquation, SIGNAL(expressionChanged()), this, SLOT(checkValues()) );
 	connect( ui.tbConstants, SIGNAL(clicked()), this, SLOT(showConstants()) );
 	connect( ui.tbFunctions, SIGNAL(clicked()), this, SLOT(showFunctions()) );
 	connect(m_okButton, &QPushButton::clicked, this, &FunctionValuesDialog::generate);
 
 	//restore saved settings if available
 	KConfigGroup conf(KSharedConfig::openConfig(), "FunctionValuesDialog");
 	if (conf.exists())
 		KWindowConfig::restoreWindowSize(windowHandle(), conf);
 	else
 		resize(QSize(300, 0).expandedTo(minimumSize()));
 }
 
 FunctionValuesDialog::~FunctionValuesDialog() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "FunctionValuesDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void FunctionValuesDialog::setColumns(QVector<Column*> columns) {
 	m_columns = columns;
 	ui.teEquation->setPlainText(m_columns.first()->formula());
 
 	const QStringList& variableNames = m_columns.first()->formulaVariableNames();
 	if (!variableNames.size()) {
 		//no formular was used for this column -> add the first variable "x"
 		addVariable();
 		m_variableNames[0]->setText("x");
 	} else {
 		//formula and variables are available
 		const QStringList& columnPathes = m_columns.first()->formulaVariableColumnPathes();
 
 		//add all available variables and select the corresponding columns
-		const QVector<AbstractAspect*> columns = m_spreadsheet->project()->children("Column", AbstractAspect::Recursive);
+		const QVector<AbstractAspect*> cols = m_spreadsheet->project()->children("Column", AbstractAspect::Recursive);
 		for (int i = 0; i < variableNames.size(); ++i) {
 			addVariable();
 			m_variableNames[i]->setText(variableNames.at(i));
 
-			foreach (const AbstractAspect* aspect, columns) {
+			foreach (const AbstractAspect* aspect, cols) {
 				if (aspect->path() == columnPathes.at(i)) {
 					const AbstractColumn* column = dynamic_cast<const AbstractColumn*>(aspect);
 					if (column)
 						m_variableDataColumns[i]->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(column));
 					else
 						m_variableDataColumns[i]->setCurrentModelIndex(QModelIndex());
 
 					break;
 				}
 			}
 		}
 	}
 }
 
 /*!
 	check the user input and enables/disables the Ok-button depending on the correctness of the input
  */
 void FunctionValuesDialog::checkValues() {
 	//check whether the formulr syntax is correct
 	if (!ui.teEquation->isValid()) {
 		m_okButton->setEnabled(false);
 		return;
 	}
 
 	//check whether for the variables where a name was provided also a column was selected.
 	for (int i = 0; i < m_variableDataColumns.size(); ++i) {
 		if (m_variableNames.at(i)->text().simplified().isEmpty())
 			continue;
 
 		TreeViewComboBox* cb = m_variableDataColumns.at(i);
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cb->currentModelIndex().internalPointer());
 		if (!aspect) {
 			m_okButton->setEnabled(false);
 			return;
 		}
 	}
 
 	m_okButton->setEnabled(true);
 }
 
 void FunctionValuesDialog::showConstants() {
 	QMenu menu;
 	ConstantsWidget constants(&menu);
 	connect(&constants, SIGNAL(constantSelected(QString)), this, SLOT(insertConstant(QString)));
 	connect(&constants, SIGNAL(constantSelected(QString)), &menu, SLOT(close()));
 	connect(&constants, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&constants);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width()+ui.tbConstants->width(),-menu.sizeHint().height());
 	menu.exec(ui.tbConstants->mapToGlobal(pos));
 }
 
 void FunctionValuesDialog::showFunctions() {
 	QMenu menu;
 	FunctionsWidget functions(&menu);
 	connect(&functions, SIGNAL(functionSelected(QString)), this, SLOT(insertFunction(QString)));
 	connect(&functions, SIGNAL(functionSelected(QString)), &menu, SLOT(close()));
 	connect(&functions, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&functions);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width()+ui.tbFunctions->width(),-menu.sizeHint().height());
 	menu.exec(ui.tbFunctions->mapToGlobal(pos));
 }
 
 void FunctionValuesDialog::insertFunction(const QString& str) {
 	ui.teEquation->insertPlainText(str + "(x)");
 }
 
 void FunctionValuesDialog::insertConstant(const QString& str) {
 	ui.teEquation->insertPlainText(str);
 }
 
 void FunctionValuesDialog::addVariable() {
 	QGridLayout* layout = dynamic_cast<QGridLayout*>(ui.frameVariables->layout());
 	int row = m_variableNames.size();
 
 	//text field for the variable name
 	QLineEdit* le = new QLineEdit();
 	le->setMaximumWidth(30);
 	connect(le, SIGNAL(textChanged(QString)), this, SLOT(variableNameChanged()));
 	layout->addWidget(le, row, 0, 1, 1);
 	m_variableNames<<le;
 
 	//label for the "="-sign
 	QLabel* l = new QLabel("=");
 	layout->addWidget(l, row, 1, 1, 1);
 	m_variableLabels<<l;
 
 	//combo box for the data column
 	TreeViewComboBox* cb = new TreeViewComboBox();
 	cb->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
 	connect( cb, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(checkValues()) );
 	layout->addWidget(cb, row, 2, 1, 1);
 	m_variableDataColumns<<cb;
 
 	cb->setTopLevelClasses(m_topLevelClasses);
 	cb->setModel(m_aspectTreeModel.get());
 	cb->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(m_spreadsheet->column(0)));
 
 	//move the add-button to the next row
 	layout->removeWidget(ui.bAddVariable);
 	layout->addWidget(ui.bAddVariable, row+1,3, 1, 1);
 
 	//add delete-button for the just added variable
 	if (row != 0) {
 		QToolButton* b = new QToolButton();
 		b->setIcon(QIcon::fromTheme("list-remove"));
 		b->setToolTip(i18n("Delete variable"));
 		layout->addWidget(b, row, 3, 1, 1);
 		m_variableDeleteButtons<<b;
 		connect(b, SIGNAL(pressed()), this, SLOT(deleteVariable()));
 	}
 
 	ui.lVariable->setText(i18n("Variables:"));
 
 	//TODO: adjust the tab-ordering after new widgets were added
 }
 
 void FunctionValuesDialog::deleteVariable() {
 	QObject* ob = QObject::sender();
 	int index = m_variableDeleteButtons.indexOf(qobject_cast<QToolButton*>(ob)) ;
 
 	delete m_variableNames.takeAt(index+1);
 	delete m_variableLabels.takeAt(index+1);
 	delete m_variableDataColumns.takeAt(index+1);
 	delete m_variableDeleteButtons.takeAt(index);
 
 	variableNameChanged();
 	checkValues();
 
 	//adjust the layout
 	resize( QSize(width(),0).expandedTo(minimumSize()) );
 
 	m_variableNames.size()>1 ? ui.lVariable->setText(i18n("Variables:")) : ui.lVariable->setText(i18n("Variable:"));
 
 	//TODO: adjust the tab-ordering after some widgets were deleted
 }
 
 void FunctionValuesDialog::variableNameChanged() {
 	QStringList vars;
 	QString text;
 	for (int i = 0; i < m_variableNames.size(); ++i) {
 		QString name = m_variableNames.at(i)->text().simplified();
 		if (!name.isEmpty()) {
 			vars<<name;
 
 			if (text.isEmpty()) {
 				text += name;
 			} else {
 				text += ", " + name;
 			}
 		}
 	}
 
 	if (!text.isEmpty())
 		text = "f(" + text + ") = ";
 	else
 		text = "f = ";
 
 	ui.lFunction->setText(text);
 	ui.teEquation->setVariables(vars);
 }
 
 void FunctionValuesDialog::generate() {
 	Q_ASSERT(m_spreadsheet);
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18np("%1: fill column with function values",
 					"%1: fill columns with function values",
 					m_spreadsheet->name(), m_columns.size()));
 
 	//determine variable names and the data vectors of the specified columns
 	QStringList variableNames;
 	QStringList columnPathes;
 	QVector<QVector<double>*> xVectors;
 	QVector<Column*> xColumns;
 	int maxRowCount = m_spreadsheet->rowCount();
 	for (int i=0; i<m_variableNames.size(); ++i) {
 		variableNames << m_variableNames.at(i)->text().simplified();
 
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(m_variableDataColumns.at(i)->currentModelIndex().internalPointer());
 		Q_ASSERT(aspect);
 		Column* column = dynamic_cast<Column*>(aspect);
 		Q_ASSERT(column);
 		columnPathes << column->path();
 		xColumns << column;
 		xVectors << static_cast<QVector<double>* >(column->data());
 
 		if (column->rowCount()>maxRowCount)
 			maxRowCount = column->rowCount();
 	}
 
 	//resize the spreadsheet if one of the data vectors from other spreadsheet(s) has more elements then the current spreadsheet.
 	if (m_spreadsheet->rowCount()<maxRowCount)
 		m_spreadsheet->setRowCount(maxRowCount);
 
 	//create new vector for storing the calculated values
 	//the vectors with the variable data can be smaller then the result vector. So, not all values in the result vector might get initialized.
 	//->"clean" the result vector first
 	QVector<double> new_data(maxRowCount);
 	for (int i=0; i<new_data.size(); ++i)
 		new_data[i] = NAN;
 
 	//evaluate the expression for f(x_1, x_2, ...) and write the calculated values into a new vector.
 	ExpressionParser* parser = ExpressionParser::getInstance();
 	const QString& expression = ui.teEquation->toPlainText();
 	parser->evaluateCartesian(expression, variableNames, xVectors, &new_data);
 
 	//set the new values and store the expression, variable names and the used data columns
 	foreach(Column* col, m_columns) {
 		col->setFormula(expression, variableNames, columnPathes);
 		col->replaceValues(0, new_data);
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }