TDE
/
basket
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/basket
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '928b97c5a9'
${ noResults }
basket/src/note.cpp

2895 lines
88 KiB
Raw Blame History Escape

/***************************************************************************
* Copyright (C) 2003 by S<>astien Laot *
* slaout@linux62.org *
* *
* 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. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <tqpainter.h>
#include <tdeglobalsettings.h>
#include <tqstyle.h>
#include <tdeapplication.h>
#include <tdestyle.h>
#include <tqcursor.h>
#include <kiconloader.h>
#include <kpixmapeffect.h>
#include <kpixmap.h>
#include <tdeglobal.h>
#include <tdelocale.h>
#include <kurifilter.h>
#include <tqfile.h>
#include <stdlib.h> // rand() function
#include <math.h> // sqrt() and pow() functions
#include <iostream>
#ifdef None
#undef None
#endif
#include "basket.h"
#include "tag.h"
#include "note.h"
#include "tools.h"
#include "settings.h"
#include "notefactory.h" // For NoteFactory::filteredURL()
/** class Note: */
#define FOR_EACH_CHILD(childVar) \
for (Note *childVar = firstChild(); childVar; childVar = childVar->next())
// TODO:
#define FOR_EACH_VISIBLE_CHILD(childVar) \
for (...)
int Note::NOTE_MARGIN = 2;
int Note::INSERTION_HEIGHT = 5;
int Note::EXPANDER_WIDTH = 9;
int Note::EXPANDER_HEIGHT = 9;
int Note::GROUP_WIDTH = 2*NOTE_MARGIN + EXPANDER_WIDTH;
int Note::HANDLE_WIDTH = GROUP_WIDTH;
int Note::RESIZER_WIDTH = GROUP_WIDTH;
int Note::TAG_ARROW_WIDTH = 5;
int Note::EMBLEM_SIZE = 16;
int Note::MIN_HEIGHT = 2*NOTE_MARGIN + EMBLEM_SIZE;
Note::Note(Basket *parent)
: m_prev(0), m_next(0),
m_x(0), m_y(-1), m_width(-1), m_height(-1),
m_groupWidth(250),
m_isFolded(false), m_firstChild(0L), m_parentNote(0),
m_basket(parent), m_content(0), m_addedDate(TQDateTime::currentDateTime()), m_lastModificationDate(TQDateTime::currentDateTime()),
m_computedAreas(false), m_onTop(false),
m_deltaX(0), m_deltaY(0), m_deltaHeight(0), m_collapseFinished(true), m_expandingFinished(true),
m_hovered(false), m_hoveredZone(Note::None), m_focused(false), m_selected(false), m_wasInLastSelectionRect(false),
m_computedState(), m_emblemsCount(0), m_haveInvisibleTags(false),
m_matching(true)
{
}
Note::~Note()
{
delete m_content;
deleteChilds();
}
TQString Note::addedStringDate()
{
return TDEGlobal::locale()->formatDateTime(m_addedDate);
}
TQString Note::lastModificationStringDate()
{
return TDEGlobal::locale()->formatDateTime(m_lastModificationDate);
}
TQString Note::toText(const TQString &cuttedFullPath)
{
if (content()) {
// Convert note to text:
TQString text = content()->toText(cuttedFullPath);
// If we should not export tags with the text, return immediatly:
if (!Settings::exportTextTags())
return text;
// Compute the text equivalent of the tag states:
TQString firstLine;
TQString otherLines;
for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it) {
if (!(*it)->textEquivalent().isEmpty()) {
firstLine += (*it)->textEquivalent() + " ";
if ((*it)->onAllTextLines())
otherLines += (*it)->textEquivalent() + " ";
}
}
// Merge the texts:
if (firstLine.isEmpty())
return text;
if (otherLines.isEmpty())
return firstLine + text;
TQStringList lines = TQStringList::split('\n', text, /*allowEmptyEntries=*/true);
TQString result = firstLine + lines[0] + (lines.count() > 1 ? "\n" : "");
for (uint i = 1/*Skip the first line*/; i < lines.count(); ++i)
result += otherLines + lines[i] + (i < lines.count() - 1 ? "\n" : "");
return result;
} else
return "";
}
bool Note::computeMatching(const FilterData &data)
{
// Groups are always matching:
if (!content())
return true;
// If we were editing this note and there is a save operation in the middle, then do not hide it suddently:
if (basket()->editedNote() == this)
return true;
bool matching;
// First match tags (they are fast to compute):
switch (data.tagFilterType) {
default:
case FilterData::DontCareTagsFilter: matching = true; break;
case FilterData::NotTaggedFilter: matching = m_states.count() <= 0; break;
case FilterData::TaggedFilter: matching = m_states.count() > 0; break;
case FilterData::TagFilter: matching = hasTag(data.tag); break;
case FilterData::StateFilter: matching = hasState(data.state); break;
}
// Don't try to match the content text if we are not matching now (the filter is of 'AND' type) or if we shouldn't try to match the string:
if (matching && !data.string.isEmpty())
matching = content()->match(data);
return matching;
}
int Note::newFilter(const FilterData &data)
{
bool wasMatching = matching();
m_matching = computeMatching(data);
setOnTop(wasMatching && matching());
if (!matching())
setSelected(false);
int countMatches = (content() && matching() ? 1 : 0);
FOR_EACH_CHILD (child)
countMatches += child->newFilter(data);
return countMatches;
}
void Note::deleteSelectedNotes(bool deleteFilesToo)
{
if (content() && isSelected()) {
basket()->unplugNote(this);
if (deleteFilesToo && content() && content()->useFile())
Tools::deleteRecursively(fullPath());//basket()->deleteFiles(fullPath()); // Also delete the folder if it's a folder
//delete this;
return;
}
Note *child = firstChild();
Note *next;
while (child) {
next = child->next(); // If we delete 'child' on the next line, child->next() will be 0!
child->deleteSelectedNotes(deleteFilesToo);
child = next;
}
}
int Note::count()
{
if (content())
return 1;
int count = 0;
FOR_EACH_CHILD (child)
count += child->count();
return count;
}
int Note::countDirectChilds()
{
int count = 0;
FOR_EACH_CHILD (child)
++count;
return count;
}
TQString Note::fullPath()
{
if (content())
return basket()->fullPath() + content()->fileName();
else
return "";
}
void Note::update()
{
basket()->updateNote(this);
}
void Note::setFocused(bool focused)
{
if (m_focused == focused)
return;
m_focused = focused;
unbufferize();
update(); // FIXME: ???
}
void Note::setSelected(bool selected)
{
if (isGroup())
selected = false; // A group cannot be selected!
if (m_selected == selected)
return;
if (!selected && basket()->editedNote() == this) {
basket()->closeEditor();
return; // To avoid a bug that would count 2 less selected notes instead of 1 less! Because m_selected is modified only below.
}
if (selected)
basket()->addSelectedNote();
else
basket()->removeSelectedNote();
m_selected = selected;
unbufferize();
update(); // FIXME: ???
}
void Note::resetWasInLastSelectionRect()
{
m_wasInLastSelectionRect = false;
FOR_EACH_CHILD (child)
child->resetWasInLastSelectionRect();
}
void Note::finishLazyLoad()
{
if (content())
content()->finishLazyLoad();
FOR_EACH_CHILD (child)
child->finishLazyLoad();
}
void Note::selectIn(const TQRect &rect, bool invertSelection, bool unselectOthers /*= true*/)
{
// TQRect myRect(x(), y(), width(), height());
// bool intersects = myRect.intersects(rect);
// Only intersects with visible areas.
// If the note is not visible, the user don't think it will be selected while selecting the note(s) that hide this, so act like the user think:
bool intersects = false;
for (TQValueList<TQRect>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
TQRect &r = *it;
if (r.intersects(rect)) {
intersects = true;
break;
}
}
bool toSelect = intersects || (!unselectOthers && isSelected());
if (invertSelection) {
if (m_wasInLastSelectionRect == intersects)
toSelect = isSelected();
else if (intersects xor m_wasInLastSelectionRect)
toSelect = !isSelected();// xor intersects;
}
setSelected(toSelect);
m_wasInLastSelectionRect = intersects;
Note *child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
child->selectIn(rect, invertSelection, unselectOthers);
else
child->setSelectedRecursivly(false);
child = child->next();
first = false;
}
}
bool Note::allSelected()
{
if (isGroup()) {
Note *child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
if (!child->allSelected())
return false;;
child = child->next();
first = false;
}
return true;
} else
return isSelected();
}
void Note::setSelectedRecursivly(bool selected)
{
setSelected(selected && matching());
FOR_EACH_CHILD (child)
child->setSelectedRecursivly(selected);
}
void Note::invertSelectionRecursivly()
{
if (content())
setSelected(!isSelected() && matching());
FOR_EACH_CHILD (child)
child->invertSelectionRecursivly();
}
void Note::unselectAllBut(Note *toSelect)
{
if (this == toSelect)
setSelectedRecursivly(true);
else {
setSelected(false);
Note *child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
child->unselectAllBut(toSelect);
else
child->setSelectedRecursivly(false);
child = child->next();
first = false;
}
}
}
void Note::invertSelectionOf(Note *toSelect)
{
if (this == toSelect)
setSelectedRecursivly(!isSelected());
else {
Note *child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
child->invertSelectionOf(toSelect);
child = child->next();
first = false;
}
}
}
Note* Note::theSelectedNote()
{
if (!isGroup() && isSelected())
return this;
Note *selectedOne;
Note *child = firstChild();
while (child) {
selectedOne = child->theSelectedNote();
if (selectedOne)
return selectedOne;
child = child->next();
}
return 0;
}
NoteSelection* Note::selectedNotes()
{
if (content())
if (isSelected())
return new NoteSelection(this);
else
return 0;
NoteSelection *selection = new NoteSelection(this);
FOR_EACH_CHILD (child)
selection->append(child->selectedNotes());
if (selection->firstChild) {
if (selection->firstChild->next)
return selection;
else {
// If 'selection' is a groupe with only one content, return directly that content:
NoteSelection *reducedSelection = selection->firstChild;
// delete selection; // TODO: Cut all connexions of 'selection' before deleting it!
for (NoteSelection *node = reducedSelection; node; node = node->next)
node->parent = 0;
return reducedSelection;
}
} else {
delete selection;
return 0;
}
}
bool Note::isAfter(Note *note)
{
if (this == 0 || note == 0)
return true;
Note *next = this;
while (next) {
if (next == note)
return false;
next = next->nextInStack();
}
return true;
}
bool Note::contains(Note *note)
{
// if (this == note)
// return true;
while (note)
if (note == this)
return true;
else
note = note->parentNote();
// FOR_EACH_CHILD (child)
// if (child->contains(note))
// return true;
return false;
}
Note* Note::firstRealChild()
{
Note *child = m_firstChild;
while (child) {
if ( !child->isGroup() /*&& child->matching()*/ )
return child;
child = child->firstChild();
}
// Empty group:
return 0;
}
Note* Note::lastRealChild()
{
Note *child = lastChild();
while (child) {
if (child->content())
return child;
Note *possibleChild = child->lastRealChild();
if (possibleChild && possibleChild->content())
return possibleChild;
child = child->prev();
}
return 0;
}
Note* Note::lastChild()
{
Note *child = m_firstChild;
while (child && child->next())
child = child->next();
return child;
}
Note* Note::lastSibling()
{
Note *last = this;
while (last && last->next())
last = last->next();
return last;
}
int Note::yExpander()
{
Note *child = firstRealChild();
if (child && !child->isShown())
child = child->nextShownInStack(); // FIXME: Restrict scope to 'this'
if (child)
return (child->height() - EXPANDER_HEIGHT) / 2 + !(child->height()%2);
else // Groups always have at least 2 notes, except for columns which can have no child (but should exists anyway):
return 0;
}
bool Note::isFree()
{
return parentNote() == 0 && basket()->isFreeLayout();
}
bool Note::isColumn()
{
return parentNote() == 0 && basket()->isColumnsLayout();
}
bool Note::hasResizer()
{
// "isFree" || "isColmun but not the last"
return parentNote() == 0 && (basket()->isFreeLayout() || m_next != 0L);
}
int Note::resizerHeight()
{
return (isColumn() ? basket()->contentsHeight() : height());
}
void Note::setHoveredZone(Zone zone) // TODO: Remove setHovered(bool) and assume it is hovered if zone != None !!!!!!!
{
if (m_hoveredZone != zone) {
if (content())
content()->setHoveredZone(m_hoveredZone, zone);
m_hoveredZone = zone;
unbufferize();
}
}
Note::Zone Note::zoneAt(const TQPoint &pos, bool toAdd)
{
// Keep the resizer highlighted when resizong, even if the cursor is over another note:
if (basket()->resizingNote() == this)
return Resizer;
// When dropping/pasting something on a column resizer, add it at the bottom of the column, and don't group it whith the whole column:
if (toAdd && isColumn() && hasResizer()) {
int right = rightLimit() - x();
if ((pos.x() >= right) && (pos.x() < right + RESIZER_WIDTH) && (pos.y() >= 0) && (pos.y() < resizerHeight())) // Code copied from below
return BottomColumn;
}
// Below a column:
if (isColumn()) {
if (pos.y() >= height() && pos.x() < rightLimit() - x())
return BottomColumn;
}
// If toAdd, return only TopInsert, TopGroup, BottomInsert or BottomGroup
// (by spanning those areas in 4 equal rectangles in the note):
if (toAdd) {
if (!isFree() && !Settings::groupOnInsertionLine())
return (pos.y() < height() / 2 ? TopInsert : BottomInsert);
if (isColumn() && pos.y() >= height())
return BottomGroup;
if (pos.y() < height() / 2)
if (pos.x() < width() / 2 && !isFree())
return TopInsert;
else
return TopGroup;
else
if (pos.x() < width() / 2 && !isFree())
return BottomInsert;
else
return BottomGroup;
}
// If in the resizer:
if (hasResizer()) {
int right = rightLimit() - x();
if ((pos.x() >= right) && (pos.x() < right + RESIZER_WIDTH) && (pos.y() >= 0) && (pos.y() < resizerHeight()))
return Resizer;
}
// If isGroup, return only Group, GroupExpander, TopInsert or BottomInsert:
if (isGroup()) {
if (pos.y() < INSERTION_HEIGHT)
return (isFree() ? TopGroup : TopInsert);
if (pos.y() >= height() - INSERTION_HEIGHT)
return (isFree() ? BottomGroup : BottomInsert);
if (pos.x() >= NOTE_MARGIN && pos.x() < NOTE_MARGIN + EXPANDER_WIDTH) {
int yExp = yExpander();
if (pos.y() >= yExp && pos.y() < yExp + EXPANDER_HEIGHT)
return GroupExpander;
}
if (pos.x() < width())
return Group;
else
return Note::None;
}
// Else, it's a normal note:
if (pos.x() < HANDLE_WIDTH)
return Handle;
if (pos.y() < INSERTION_HEIGHT)
if ((!isFree() && !Settings::groupOnInsertionLine()) || pos.x() < width() / 2 && !isFree())
return TopInsert;
else
return TopGroup;
if (pos.y() >= height() - INSERTION_HEIGHT)
if ((!isFree() && !Settings::groupOnInsertionLine()) || pos.x() < width() / 2 && !isFree())
return BottomInsert;
else
return BottomGroup;
for (int i =0; i < m_emblemsCount; i++) {
if ( pos.x() >= HANDLE_WIDTH + (NOTE_MARGIN+EMBLEM_SIZE)*i &&
pos.x() < HANDLE_WIDTH + (NOTE_MARGIN+EMBLEM_SIZE)*i + NOTE_MARGIN+EMBLEM_SIZE )
return (Zone)(Emblem0 + i);
}
if (pos.x() < HANDLE_WIDTH + (NOTE_MARGIN+EMBLEM_SIZE)*m_emblemsCount + NOTE_MARGIN + TAG_ARROW_WIDTH + NOTE_MARGIN)
return TagsArrow;
if (!linkAt(pos).isEmpty())
return Link;
int customZone = content()->zoneAt(pos - TQPoint(contentX(), NOTE_MARGIN));
if (customZone)
return (Note::Zone)customZone;
return Content;
}
TQString Note::linkAt(const TQPoint &pos)
{
TQString link = m_content->linkAt(pos - TQPoint(contentX(), NOTE_MARGIN));
if (link.isEmpty())
return link;
else
return NoteFactory::filteredURL(KURL(link)).prettyURL();//KURIFilter::self()->filteredURI(link);
}
int Note::contentX()
{
return HANDLE_WIDTH + NOTE_MARGIN + (EMBLEM_SIZE+NOTE_MARGIN)*m_emblemsCount + TAG_ARROW_WIDTH + NOTE_MARGIN;
}
TQRect Note::zoneRect(Note::Zone zone, const TQPoint &pos)
{
if (zone >= Emblem0)
return TQRect(HANDLE_WIDTH + (NOTE_MARGIN+EMBLEM_SIZE)*(zone-Emblem0),
INSERTION_HEIGHT,
NOTE_MARGIN + EMBLEM_SIZE,
height() - 2*INSERTION_HEIGHT);
int yExp;
int right;
int xGroup = (isFree() ? (isGroup() ? 0 : GROUP_WIDTH) : width() / 2);
TQRect rect;
int insertSplit = (Settings::groupOnInsertionLine() ? 2 : 1);
switch (zone) {
case Note::Handle: return TQRect(0, 0, HANDLE_WIDTH, height());
case Note::Group:
yExp = yExpander();
if (pos.y() < yExp) return TQRect(0, INSERTION_HEIGHT, width(), yExp - INSERTION_HEIGHT);
if (pos.y() > yExp + EXPANDER_HEIGHT) return TQRect(0, yExp + EXPANDER_HEIGHT, width(), height() - yExp - EXPANDER_HEIGHT - INSERTION_HEIGHT);
if (pos.x() < NOTE_MARGIN) return TQRect(0, 0, NOTE_MARGIN, height());
else return TQRect(width() - NOTE_MARGIN, 0, NOTE_MARGIN, height());
case Note::TagsArrow: return TQRect(HANDLE_WIDTH + (NOTE_MARGIN+EMBLEM_SIZE)*m_emblemsCount,
INSERTION_HEIGHT,
NOTE_MARGIN + TAG_ARROW_WIDTH + NOTE_MARGIN,
height() - 2*INSERTION_HEIGHT);
case Note::Custom0:
case Note::Content: rect = content()->zoneRect(zone, pos - TQPoint(contentX(), NOTE_MARGIN));
rect.moveBy(contentX(), NOTE_MARGIN);
return rect.intersect( TQRect(contentX(), INSERTION_HEIGHT, width() - contentX(), height() - 2*INSERTION_HEIGHT) ); // Only IN contentRect
case Note::GroupExpander: return TQRect(NOTE_MARGIN, yExpander(), EXPANDER_WIDTH, EXPANDER_HEIGHT);
case Note::Resizer: right = rightLimit();
return TQRect(right - x(), 0, RESIZER_WIDTH, resizerHeight());
case Note::Link:
case Note::TopInsert: if (isGroup()) return TQRect(0, 0, width(), INSERTION_HEIGHT);
else return TQRect(HANDLE_WIDTH, 0, width() / insertSplit - HANDLE_WIDTH, INSERTION_HEIGHT);
case Note::TopGroup: return TQRect(xGroup, 0, width() - xGroup, INSERTION_HEIGHT);
case Note::BottomInsert: if (isGroup()) return TQRect(0, height() - INSERTION_HEIGHT, width(), INSERTION_HEIGHT);
else return TQRect(HANDLE_WIDTH, height() - INSERTION_HEIGHT, width() / insertSplit - HANDLE_WIDTH, INSERTION_HEIGHT);
case Note::BottomGroup: return TQRect(xGroup, height() - INSERTION_HEIGHT, width() - xGroup, INSERTION_HEIGHT);
case Note::BottomColumn: return TQRect(0, height(), rightLimit() - x(), basket()->contentsHeight() - height());
case Note::None: return TQRect(/*0, 0, -1, -1*/);
default: return TQRect(/*0, 0, -1, -1*/);
}
}
void Note::setCursor(Zone zone)
{
switch (zone) {
case Note::Handle:
case Note::Group: basket()->viewport()->setCursor(TQt::SizeAllCursor); break;
case Note::Resizer: if (isColumn())
basket()->viewport()->setCursor(TQt::SplitHCursor);
else
basket()->viewport()->setCursor(TQt::SizeHorCursor); break;
case Note::Custom0: content()->setCursor(basket()->viewport(), zone); break;
case Note::Link:
case Note::TagsArrow:
case Note::GroupExpander: basket()->viewport()->setCursor(TQt::PointingHandCursor); break;
case Note::Content: basket()->viewport()->setCursor(TQt::IbeamCursor); break;
case Note::TopInsert:
case Note::TopGroup:
case Note::BottomInsert:
case Note::BottomGroup:
case Note::BottomColumn: basket()->viewport()->setCursor(TQt::CrossCursor); break;
case Note::None: basket()->viewport()->unsetCursor(); break;
default:
State *state = stateForEmblemNumber(zone - Emblem0);
if (state && state->parentTag()->states().count() > 1)
basket()->viewport()->setCursor(TQt::PointingHandCursor);
else
basket()->viewport()->unsetCursor();
}
}
void Note::addAnimation(int deltaX, int deltaY, int deltaHeight)
{
// Don't process animation that make the note stay in place!
if (deltaX == 0 && deltaY == 0 && deltaHeight == 0)
return;
// If it was not animated previsouly, make it animated:
if (m_deltaX == 0 && m_deltaY == 0 && m_deltaHeight == 0)
basket()->addAnimatedNote(this);
// Configure the animation:
m_deltaX += deltaX;
m_deltaY += deltaY;
m_deltaHeight += deltaHeight;
}
void Note::setFinalPosition(int x, int y)
{
addAnimation(x - finalX(), y - finalY());
}
void Note::initAnimationLoad()
{
int x, y;
switch (rand() % 4) {
case 0: // Put it on top:
x = basket()->contentsX() + rand() % basket()->contentsWidth();
y = -height();
break;
case 1: // Put it on bottom:
x = basket()->contentsX() + rand() % basket()->contentsWidth();
y = basket()->contentsY() + basket()->visibleHeight();
break;
case 2: // Put it on left:
x = -width() - (hasResizer() ? Note::RESIZER_WIDTH : 0);
y = basket()->contentsY() + rand() % basket()->visibleHeight();
break;
case 3: // Put it on right:
default: // In the case of...
x = basket()->contentsX() + basket()->visibleWidth();
y = basket()->contentsY() + rand() % basket()->visibleHeight();
break;
}
cancelAnimation();
addAnimation(finalX() - x, finalY() - y);
setX(x);
setY(y);
if (isGroup()) {
const int viewHeight = basket()->contentsY() + basket()->visibleHeight();
Note *child = firstChild();
bool first = true;
while (child) {
if (child->finalY() < viewHeight) {
if ((showSubNotes() || first) && child->matching())
child->initAnimationLoad();
} else
break; // 'child' are not a free notes (because child of at least one note, 'this'), so 'child' is ordered vertically.
child = child->next();
first = false;
}
}
}
bool Note::advance()
{
// Animate X:
if (m_deltaX != 0) {
int deltaX = m_deltaX / 3;
if (deltaX == 0)
deltaX = (m_deltaX > 0 ? 1 : -1);
setX(m_x + deltaX);
m_deltaX -= deltaX;
}
// Animate Y:
if (m_deltaY != 0) {
int deltaY = m_deltaY / 3;
if (deltaY == 0)
deltaY = (m_deltaY > 0 ? 1 : -1);
setY(m_y + deltaY);
m_deltaY -= deltaY;
}
// Animate Height:
if (m_deltaHeight != 0) {
int deltaHeight = m_deltaHeight / 3;
if (deltaHeight == 0)
deltaHeight = (m_deltaHeight > 0 ? 1 : -1);
m_height += deltaHeight;
unbufferize();
m_deltaHeight -= deltaHeight;
}
if (m_deltaHeight == 0) {
m_collapseFinished = true;
m_expandingFinished = true;
}
// Return true if the animation is finished:
return (m_deltaX == 0 && m_deltaY == 0 && m_deltaHeight == 0);
}
void Note::unsetWidth()
{
m_width = 0;
unbufferize();
FOR_EACH_CHILD (child)
child->unsetWidth();
}
void Note::requestRelayout()
{
m_width = 0;
unbufferize();
basket()->relayoutNotes(true); // TODO: A signal that will relayout ONCE and DELAYED if called several times
}
void Note::setWidth(int width) // TODO: inline ?
{
if (m_width != width)
setWidthForceRelayout(width);
}
void Note::setWidthForceRelayout(int width)
{
unbufferize();
m_width = (width < minWidth() ? minWidth() : width);
int contentWidth = width - contentX() - NOTE_MARGIN;
if (m_content) { ///// FIXME: is this OK?
if (contentWidth < 1)
contentWidth = 1;
if (contentWidth < m_content->minWidth())
contentWidth = m_content->minWidth();
m_height = m_content->setWidthAndGetHeight(contentWidth/* < 1 ? 1 : contentWidth*/) + 2 * NOTE_MARGIN;
if (m_height < 3 * INSERTION_HEIGHT) // Assure a minimal size...
m_height = 3 * INSERTION_HEIGHT;
}
}
int Note::minWidth()
{
if (m_content)
return contentX() + m_content->minWidth() + NOTE_MARGIN;
else
return GROUP_WIDTH; ///// FIXME: is this OK?
}
int Note::minRight()
{
if (isGroup()) {
int right = finalX() + width();
Note* child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
right = TQMAX(right, child->minRight());
child = child->next();
first = false;
}
if (isColumn()) {
int minColumnRight = finalX() + 2*HANDLE_WIDTH;
if (right < minColumnRight)
return minColumnRight;
}
return right;
} else
return finalX() + minWidth();
}
void Note::setX(int x)
{
if (m_x == x)
return;
if (isBufferized() && basket()->hasBackgroundImage()) {
// Unbufferize only if the background change:
if (basket()->isTiledBackground())
unbufferize();
else {
int bgw = basket()->backgroundPixmap()->width();
if (m_x >= bgw && x < bgw) // Was not in the background image and is now inside it:
unbufferize();
else if (m_x < bgw) // Was in the background image and is now at another position of the background image or is now outside:
unbufferize();
}
}
m_x = x;
}
void Note::setY(int y)
{
if (m_y == y)
return;
if (isBufferized() && basket()->hasBackgroundImage()) {
// Unbufferize only if the background change:
if (basket()->isTiledBackground())
unbufferize();
else {
int bgh = basket()->backgroundPixmap()->height();
if (m_y >= bgh && y < bgh) // Was not in the background image and is now inside it:
unbufferize();
else if (m_y < bgh) // Was in the background image and is now at another position of the background image or is now outside:
unbufferize();
}
}
m_y = y;
}
void Note::toggleFolded(bool animate)
{
// Close the editor if it was editing a note that we are about to hide after collapsing:
if (!m_isFolded && basket() && basket()->isDuringEdit()) {
if (contains(basket()->editedNote()) && firstRealChild() != basket()->editedNote())
basket()->closeEditor();
}
// Important to close the editor FIRST, because else, the last edited note would not show during folding animation (don't ask me why ;-) ):
m_isFolded = ! m_isFolded;
unbufferize();
if (animate) {
// We animate collapsing (so sub-notes fluidly go under the first note)
// We don't animate expanding: we place sub-notes directly under the first note (and the next relayout will animate the expanding)
// But if user quickly collapsed and then expand (while the collapsing animation isn't finished), we animate anyway
bool animateSetUnder = (m_isFolded || !m_collapseFinished);
// std::cout << "fold:" << m_isFolded << " collapseFinished:" << m_collapseFinished << " animateSetUnder:" << animateSetUnder << std::endl;
if (m_isFolded)
m_collapseFinished = false;
else
m_expandingFinished = false;
Note* note = firstChild();
if (note) {
note->setOnTop(true);
while ( (note = note->next()) ) { // Don't process the first child: it is OK
note->setRecursivelyUnder(/*firstRealChild*/firstChild(), animateSetUnder);
note->setOnTop(false);
}
}
}
//if (basket()->focusedNote() && !basket()->focusedNote()->isShown()) {
if (basket()->isLoaded()) {
basket()->setFocusedNote(firstRealChild());
basket()->m_startOfShiftSelectionNote = firstRealChild();
}
if (basket()->isLoaded() && !m_isFolded) {
//basket()->setFocusedNote(this);
basket()->relayoutNotes(true);
basket()->ensureNoteVisible(this);
}
basket()->save(); // FIXME: SHOULD WE ALWAYS SAVE ????????
}
void Note::setRecursivelyUnder(Note *under, bool animate)
{
int y = /*finalHeight() > under->finalHeight() ? under->finalY() :*/ under->finalBottom() - finalHeight() + 1;
if (animate)
setFinalPosition(finalX(), y);
else {
setY(y);
cancelAnimation();
}
if (isGroup())
FOR_EACH_CHILD (child)
child->setRecursivelyUnder(under, animate);
}
Note* Note::noteAt(int x, int y)
{
if (matching() && hasResizer()) {
int right = rightLimit();
// TODO: This code is dupliacted 3 times: !!!!
if ((x >= right) && (x < right + RESIZER_WIDTH) && (y >= m_y) && (y < m_y + resizerHeight())) {
if ( ! m_computedAreas )
recomputeAreas();
for (TQValueList<TQRect>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
TQRect &rect = *it;
if (rect.contains(x, y))
return this;
}
}
}
if (isGroup()) {
if ((x >= m_x) && (x < m_x + width()) && (y >= m_y) && (y < m_y + m_height)) {
if ( ! m_computedAreas )
recomputeAreas();
for (TQValueList<TQRect>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
TQRect &rect = *it;
if (rect.contains(x, y))
return this;
}
return NULL;
}
Note *child = firstChild();
Note *found;
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching()) {
found = child->noteAt(x, y);
if (found)
return found;
}
child = child->next();
first = false;
}
} else if (matching() && y >= m_y && y < m_y + m_height && x >= m_x && x < m_x + m_width) {
if ( ! m_computedAreas )
recomputeAreas();
for (TQValueList<TQRect>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
TQRect &rect = *it;
if (rect.contains(x, y))
return this;
}
return NULL;
}
return NULL;
}
TQRect Note::rect()
{
return TQRect(x(), y(), width(), height());
}
TQRect Note::resizerRect()
{
return TQRect(rightLimit(), y(), RESIZER_WIDTH, resizerHeight());
}
bool Note::showSubNotes()
{
return !m_isFolded || !m_collapseFinished || basket()->isFiltering();
}
void Note::relayoutAt(int x, int y, bool animate)
{
if (!matching())
return;
m_computedAreas = false;
m_areas.clear();
// Don't relayout free notes one under the other, because by definition they are freely positionned!
if (isFree()) {
x = finalX();
y = finalY();
// If it's a column, it always have the same "fixed" position (no animation):
} else if (isColumn()) {
x = (prev() ? prev()->rightLimit() + RESIZER_WIDTH : 0);
y = 0;
cancelAnimation();
setX(x);
setY(y);
// But relayout others vertically if they are inside such primary groups or if it is a "normal" basket:
} else {
if (animate)
setFinalPosition(x, y);
else {
cancelAnimation();
setX(x);
setY(y);
}
}
// Then, relayout sub-notes (only the first, if the group is folded) and so, assign an height to the group:
if (isGroup()) {
int h = 0;
Note *child = firstChild();
bool first = true;
while (child) {
if (child->matching() && (!m_isFolded || first || basket()->isFiltering())) { // Don't use showSubNotes() but use !m_isFolded because we don't want a relayout for the animated collapsing notes
child->relayoutAt(x + width(), y+h, animate);
h += child->finalHeight();
} else // In case the user collapse a group, then move it and then expand it:
child->setXRecursivly(x + width()); // notes SHOULD have a good X coordonate, and not the old one!
// For future animation when re-match, but on bottom of already matched notes!
// Find parent primary note and set the Y to THAT y:
if (!child->matching())
child->setY(parentPrimaryNote()->y());
child = child->next();
first = false;
}
if (finalHeight() != h || m_height != h) {
unbufferize();
if (animate)
addAnimation(0, 0, h - finalHeight());
else {
m_height = h;
unbufferize();
}
}
} else {
setWidth(finalRightLimit() - x);
// If rightLimit is excedded, set the top-level right limit!!!
// and NEED RELAYOUT
}
// Set the basket area limits (but not for child notes: no need, because they will look for theire parent note):
if (!parentNote()) {
if (basket()->tmpWidth < finalRightLimit() + (hasResizer() ? RESIZER_WIDTH : 0))
basket()->tmpWidth = finalRightLimit() + (hasResizer() ? RESIZER_WIDTH : 0);
if (basket()->tmpHeight < finalY() + finalHeight())
basket()->tmpHeight = finalY() + finalHeight();
// However, if the note exceed the allowed size, let it! :
} else if (!isGroup()) {
if (basket()->tmpWidth < finalX() + width())
basket()->tmpWidth = finalX() + width();
if (basket()->tmpHeight < finalY() + finalHeight())
basket()->tmpHeight = finalY() + finalHeight();
}
}
void Note::setXRecursivly(int x)
{
m_deltaX = 0;
setX(x);
FOR_EACH_CHILD (child)
child->setXRecursivly(x + width());
}
void Note::setYRecursivly(int y)
{
m_deltaY = 0;
setY(y);
FOR_EACH_CHILD (child)
child->setYRecursivly(y);
}
void Note::setGroupWidth(int width)
{
m_groupWidth = width;
}
int Note::groupWidth()
{
if (hasResizer())
return m_groupWidth;
else
return rightLimit() - x();
}
int Note::rightLimit()
{
if (isColumn() && m_next == 0L) // The last column
return TQMAX(x() + minWidth(), basket()->visibleWidth());
else if (parentNote())
return parentNote()->rightLimit();
else
return m_x + m_groupWidth;
}
int Note::finalRightLimit()
{
if (isColumn() && m_next == 0L) // The last column
return TQMAX(finalX() + minWidth(), basket()->visibleWidth());
else if (parentNote())
return parentNote()->finalRightLimit();
else
return finalX() + m_groupWidth;
}
/*
* This code is derivated from drawMetalGradient() from the TQt documentation:
*/
void drawGradient( TQPainter *p, const TQColor &colorTop, const TQColor & colorBottom,
int x, int y, int w, int h,
bool sunken, bool horz, bool flat ) /*const*/
{
TQColor highlight(colorBottom);
TQColor subh1(colorTop);
TQColor subh2(colorTop);
TQColor topgrad(colorTop);
TQColor botgrad(colorBottom);
if ( flat && !sunken )
p->fillRect(x, y, w, h, colorTop);
else {
int i = 0;
int x1 = x;
int y1 = y;
int x2 = x + w - 1;
int y2 = y + h - 1;
if ( horz )
x2 = x2;
else
y2 = y2;
#define DRAWLINE if (horz) \
p->drawLine( x1, y1+i, x2, y1+i ); \
else \
p->drawLine( x1+i, y1, x1+i, y2 ); \
i++;
// Gradient:
int ng = (horz ? h : w); // how many lines for the gradient?
int h1, h2, s1, s2, v1, v2;
if ( !sunken ) {
topgrad.hsv( &h1, &s1, &v1 );
botgrad.hsv( &h2, &s2, &v2 );
} else {
botgrad.hsv( &h1, &s1, &v1 );
topgrad.hsv( &h2, &s2, &v2 );
}
if ( ng > 1 ) {
for ( int j =0; j < ng; j++ ) {
p->setPen( TQColor( h1 + ((h2-h1)*j)/(ng-1),
s1 + ((s2-s1)*j)/(ng-1),
v1 + ((v2-v1)*j)/(ng-1), TQColor::Hsv ) );
DRAWLINE;
}
} else if ( ng == 1 ) {
p->setPen( TQColor((h1+h2)/2, (s1+s2)/2, (v1+v2)/2, TQColor::Hsv) );
DRAWLINE;
}
}
}
void Note::drawExpander(TQPainter *painter, int x, int y, const TQColor &background, bool expand, Basket *basket)
{
// If the current style is a TDEStyle, use it to draw the expander (plus or minus):
if (dynamic_cast<TDEStyle*>(&(kapp->style())) != NULL) {
// Set the 4 rounded corners background to background color:
TQColorGroup cg(basket->colorGroup());
cg.setColor(TQColorGroup::Base, background);
// Fill the inside of the expander in white, typically:
TQBrush brush(TDEGlobalSettings::baseColor());
painter->fillRect(x, y, 9, 9, brush);
// Draw it:
((TDEStyle&)(kapp->style())).drawTDEStylePrimitive( TDEStyle::KPE_ListViewExpander,
painter,
basket->viewport(),
TQRect(x, y, 9, 9),
cg,
(expand ? TQStyle::Style_On : TQStyle::Style_Off) );
// Else, TQStyle does not provide easy way to do so (if it's doable at all...)
// So, I'm drawing it myself my immitating Plastik (pretty style)...
// After all, the note/group handles are all non-TQStyle aware so that doesn't matter if the expander is a custom one too.
} else {
int width = EXPANDER_WIDTH;
int height = EXPANDER_HEIGHT;
const TQColorGroup &cg = basket->colorGroup();
// Fill white area:
painter->fillRect(x + 1, y + 1, width - 2, height - 2, cg.base());
// Draw contour lines:
painter->setPen(cg.dark());
painter->drawLine(x + 2, y, x + width - 3, y);
painter->drawLine(x + 2, y + height - 1, x + width - 3, y + height - 1);
painter->drawLine(x, y + 2, x, y + height - 3);
painter->drawLine(x + width - 1, y + 2, x + width - 1, y + height - 3);
// Draw edge points:
painter->drawPoint(x + 1, y + 1);
painter->drawPoint(x + width - 2, y + 1);
painter->drawPoint(x + 1, y + height - 2);
painter->drawPoint(x + width - 2, y + height - 2);
// Draw anti-aliased points:
painter->setPen(Tools::mixColor(cg.dark(), background));
painter->drawPoint(x + 1, y);
painter->drawPoint(x + width - 2, y);
painter->drawPoint(x, y + 1);
painter->drawPoint(x + width - 1, y + 1);
painter->drawPoint(x, y + height - 2);
painter->drawPoint(x + width - 1, y + height - 2);
painter->drawPoint(x + 1, y + height - 1);
painter->drawPoint(x + width - 2, y + height - 1);
// Draw plus / minus:
painter->setPen(cg.text());
painter->drawLine(x + 2, y + height / 2, x + width - 3, y + height / 2);
if (expand)
painter->drawLine(x + width / 2, y + 2, x + width / 2, y + height - 3);
}
}
TQColor expanderBackground(int height, int y, const TQColor &foreground)
{
// We will divide height per two, substract one and use that below a division bar:
// To avoid division by zero error, height should be bigger than 3.
// And to avoid y errors or if y is on the borders, we return the border color: the background color.
if (height <= 3 || y <= 0 || y >= height - 1)
return foreground;
TQColor dark = foreground.dark(110); // 1/1.1 of brightness
TQColor light = foreground.light(150); // 50% brighter
int h1, h2, s1, s2, v1, v2;
int ng;
if (y <= (height-2)/2) {
light.hsv( &h1, &s1, &v1 );
dark.hsv( &h2, &s2, &v2 );
ng = (height-2)/2;
y -= 1;
} else {
dark.hsv( &h1, &s1, &v1 );
foreground.hsv( &h2, &s2, &v2 );
ng = (height-2)-(height-2)/2;
y -= 1 + (height-2)/2;
}
return TQColor( h1 + ((h2-h1)*y)/(ng-1),
s1 + ((s2-s1)*y)/(ng-1),
v1 + ((v2-v1)*y)/(ng-1), TQColor::Hsv );
}
void Note::drawHandle(TQPainter *painter, int x, int y, int width, int height, const TQColor &background, const TQColor &foreground)
{
TQPen backgroundPen(background);
TQPen foregroundPen(foreground);
TQColor dark = foreground.dark(110); // 1/1.1 of brightness
TQColor light = foreground.light(150); // 50% brighter
// Draw the surrounding rectangle:
painter->setPen(foregroundPen);
painter->drawLine(0, 0, width - 1, 0);
painter->drawLine(0, 0, 0, height - 1);
painter->drawLine(width - 1, 0, width - 1, height - 1);
painter->drawLine(0, height - 1, width - 1, height - 1);
// Draw the gradients:
drawGradient( painter, light, dark, 1 + x, 1 + y, width-2, (height-2)/2, /*sunken=*/false, /*horz=*/true, /*flat=*/false );
drawGradient( painter, dark, foreground, 1 + x, 1 + y + (height-2)/2, width-2, (height-2)-(height-2)/2, /*sunken=*/false, /*horz=*/true, /*flat=*/false );
// Round the top corner with background color:
painter->setPen(backgroundPen);
painter->drawLine(0, 0, 0, 3);
painter->drawLine(1, 0, 3, 0);
painter->drawPoint(1, 1);
// Round the bottom corner with background color:
painter->drawLine(0, height-1, 0, height-4);
painter->drawLine(1, height-1, 3, height-1);
painter->drawPoint(1, height-2);
// Surrounding line of the rounded top-left corner:
painter->setPen(foregroundPen);
painter->drawLine(1, 2, 1, 3);
painter->drawLine(2, 1, 3, 1);
// Anti-aliased rounded top corner (1/2):
painter->setPen(Tools::mixColor(foreground, background));
painter->drawPoint(0, 3);
painter->drawPoint(3, 0);
// Anti-aliased rounded bottom corner:
painter->drawPoint(0, height - 4);
painter->drawPoint(3, height - 1);
// Anti-aliased rounded top corner (2/2):
painter->setPen(Tools::mixColor(foreground, light));
painter->drawPoint(2, 2);
// Draw the grips:
int xGrips = 4;
int marginedHeight = (height * 80 / 100); // 10% empty on top, and 10% empty on bottom, so 20% of the height should be empty of any grip, and 80% should be in the grips
int nbGrips = (marginedHeight - 3) / 6;
if (nbGrips < 2)
nbGrips = 2;
int yGrips = (height + 1 - nbGrips * 6 - 3) / 2; // +1 to avoid rounding errors, -nbGrips*6-3 the size of the grips
TQColor darker = foreground.dark(130);
TQColor lighter = foreground.light(130);
for (int i = 0; i < nbGrips; ++i) {
/// Dark color:
painter->setPen(darker);
// Top-left point:
painter->drawPoint(xGrips, yGrips);
painter->drawPoint(xGrips + 1, yGrips);
painter->drawPoint(xGrips, yGrips + 1);
// Bottom-right point:
painter->drawPoint(xGrips + 4, yGrips + 3);
painter->drawPoint(xGrips + 5, yGrips + 3);
painter->drawPoint(xGrips + 4, yGrips + 4);
/// Light color:
painter->setPen(lighter);
// Top-left point:
painter->drawPoint(xGrips + 1, yGrips + 1);
// Bottom-right point:
painter->drawPoint(xGrips + 5, yGrips + 4);
yGrips += 6;
}
// The remaining point:
painter->setPen(darker);
painter->drawPoint(xGrips, yGrips);
painter->drawPoint(xGrips + 1, yGrips);
painter->drawPoint(xGrips, yGrips + 1);
painter->setPen(lighter);
painter->drawPoint(xGrips + 1, yGrips + 1);
}
void Note::drawResizer(TQPainter *painter, int x, int y, int width, int height, const TQColor &background, const TQColor &foreground, bool rounded)
{
TQPen backgroundPen(background);
TQPen foregroundPen(foreground);
TQColor dark = foreground.dark(110); // 1/1.1 of brightness
TQColor light = foreground.light(150); // 50% brighter
TQColor midLight = foreground.light(105); // 5% brighter
// Draw the surrounding rectangle:
painter->setPen(foregroundPen);
painter->drawRect(0, 0, width, height);
// Draw the gradients:
drawGradient( painter, light, dark, 1 + x, 1 + y, width-2, (height-2)/2, /*sunken=*/false, /*horz=*/true, /*flat=*/false );
drawGradient( painter, dark, foreground, 1 + x, 1 + y + (height-2)/2, width-2, (height-2)-(height-2)/2, /*sunken=*/false, /*horz=*/true, /*flat=*/false );
if (rounded) {
// Round the top corner with background color:
painter->setPen(backgroundPen);
painter->drawLine(width - 1, 0, width - 3, 0);
painter->drawLine(width - 1, 1, width - 1, 2);
painter->drawPoint(width - 2, 1);
// Round the bottom corner with background color:
painter->drawLine(width - 1, height - 1, width - 1, height - 4);
painter->drawLine(width - 2, height - 1, width - 4, height - 1);
painter->drawPoint(width - 2, height-2);
// Surrounding line of the rounded top-left corner:
painter->setPen(foregroundPen);
painter->drawLine(width-2, 2, width-2, 3);
painter->drawLine(width-3, 1, width-4, 1);
// Anti-aliased rounded top corner (1/2):
painter->setPen(Tools::mixColor(foreground, background));
painter->drawPoint(width - 1, 3);
painter->drawPoint(width - 4, 0);
// Anti-aliased rounded bottom corner:
painter->drawPoint(width - 1, height - 4);
painter->drawPoint(width - 4, height - 1);
// Anti-aliased rounded top corner (2/2):
painter->setPen(Tools::mixColor(foreground, light));
painter->drawPoint(width - 3, 2);
}
// Draw the arows:
int xArrow = 2;
int hMargin = 9;
int countArrows = (height >= hMargin*4 + 6*3 ? 3 : (height >= hMargin*3 + 6*2 ? 2 : 1));
TQColor darker = foreground.dark(130);
TQColor lighter = foreground.light(130);
for (int i = 0; i < countArrows; ++i) {
int yArrow;
switch (countArrows) {
default:
case 1: yArrow = (height-6) / 2; break;
case 2: yArrow = (i == 1 ? hMargin : height - hMargin - 6); break;
case 3: yArrow = (i == 1 ? hMargin : (i == 2 ? (height-6) / 2 : height - hMargin - 6)); break;
}
/// Dark color:
painter->setPen(darker);
// Left arrow:
painter->drawLine(xArrow, yArrow + 2, xArrow + 2, yArrow);
painter->drawLine(xArrow, yArrow + 2, xArrow + 2, yArrow + 4);
// Right arrow:
painter->drawLine(width - 1 - xArrow, yArrow + 2, width - 1 - xArrow - 2, yArrow);
painter->drawLine(width - 1 - xArrow, yArrow + 2, width - 1 - xArrow - 2, yArrow + 4);
/// Light color:
painter->setPen(lighter);
// Left arrow:
painter->drawLine(xArrow, yArrow + 2 + 1, xArrow + 2, yArrow + 1);
painter->drawLine(xArrow, yArrow + 2 + 1, xArrow + 2, yArrow + 4 + 1);
// Right arrow:
painter->drawLine(width - 1 - xArrow, yArrow + 2 + 1, width - 1 - xArrow - 2, yArrow + 1);
painter->drawLine(width - 1 - xArrow, yArrow + 2 + 1, width - 1 - xArrow - 2, yArrow + 4 + 1);
}
}
void Note::drawInactiveResizer(TQPainter *painter, int x, int y, int height, const TQColor &background, bool column)
{
// If background color is too dark, we compute a lighter color instead of a darker:
TQColor darkBgColor = (Tools::tooDark(background) ? background.light(120) : background.dark(105));
if (column) {
int halfWidth = RESIZER_WIDTH / 2;
drawGradient(painter, darkBgColor, background, x, y, halfWidth, height, /*sunken=*/false, /*horz=*/false, /*flat=*/false);
drawGradient(painter, background, darkBgColor, halfWidth, y, RESIZER_WIDTH - halfWidth, height, /*sunken=*/false, /*horz=*/false, /*flat=*/false);
} else
drawGradient(painter, darkBgColor, background, x, y, RESIZER_WIDTH, height, /*sunken=*/false, /*horz=*/false, /*flat=*/false );
}
#include <tqimage.h>
#include <kimageeffect.h>
/* type: 1: topLeft
* 2: bottomLeft
* 3: topRight
* 4: bottomRight
* 5: fourCorners
* 6: noteInsideAndOutsideCorners
* (x,y) relate to the painter origin
* (width,height) only used for 5:fourCorners type
*/
void Note::drawRoundings(TQPainter *painter, int x, int y, int type, int width, int height)
{
int right;
switch (type) {
case 1:
x += this->x();
y += this->y();
basket()->blendBackground(*painter, TQRect(x, y, 4, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y + 1, 2, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y + 2, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y + 3, 1, 1), this->x(), this->y());
break;
case 2:
x += this->x();
y += this->y();
basket()->blendBackground(*painter, TQRect(x, y - 1, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y + 1, 2, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y + 2, 4, 1), this->x(), this->y());
break;
case 3:
right = rightLimit();
x += right;
y += this->y();
basket()->blendBackground(*painter, TQRect(x - 1, y, 4, 1), right, this->y());
basket()->blendBackground(*painter, TQRect(x + 1, y + 1, 2, 1), right, this->y());
basket()->blendBackground(*painter, TQRect(x + 2, y + 2, 1, 1), right, this->y());
basket()->blendBackground(*painter, TQRect(x + 2, y + 3, 1, 1), right, this->y());
break;
case 4:
right = rightLimit();
x += right;
y += this->y();
basket()->blendBackground(*painter, TQRect(x + 2, y - 1, 1, 1), right, this->y());
basket()->blendBackground(*painter, TQRect(x + 2, y, 1, 1), right, this->y());
basket()->blendBackground(*painter, TQRect(x + 1, y + 1, 2, 1), right, this->y());
basket()->blendBackground(*painter, TQRect(x - 1, y + 2, 4, 1), right, this->y());
break;
case 5:
// First make sure the corners are white (depending on the widget style):
painter->setPen(basket()->backgroundColor());
painter->drawPoint(x, y);
painter->drawPoint(x + width - 1, y);
painter->drawPoint(x + width - 1, y + height - 1);
painter->drawPoint(x, y + height - 1);
// And then blend corners:
x += this->x();
y += this->y();
basket()->blendBackground(*painter, TQRect(x, y, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + width - 1, y, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + width - 1, y + height - 1, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x, y + height - 1, 1, 1), this->x(), this->y());
break;
case 6:
x += this->x();
y += this->y();
//if (!isSelected()) {
// Inside left corners:
basket()->blendBackground(*painter, TQRect(x + HANDLE_WIDTH + 1, y + 1, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + HANDLE_WIDTH, y + 2, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + HANDLE_WIDTH + 1, y + height - 2, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + HANDLE_WIDTH, y + height - 3, 1, 1), this->x(), this->y());
// Inside right corners:
basket()->blendBackground(*painter, TQRect(x + width - 4, y + 1, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + width - 3, y + 2, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + width - 4, y + height - 2, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + width - 3, y + height - 3, 1, 1), this->x(), this->y());
//}
// Outside right corners:
basket()->blendBackground(*painter, TQRect(x + width - 1, y, 1, 1), this->x(), this->y());
basket()->blendBackground(*painter, TQRect(x + width - 1, y + height - 1, 1, 1), this->x(), this->y());
break;
}
}
/// Blank Spaces Drawing:
void Note::setOnTop(bool onTop)
{
m_onTop = onTop;
Note *note = firstChild();
while (note) {
note->setOnTop(onTop);
note = note->next();
}
}
void substractRectOnAreas(const TQRect &rectToSubstract, TQValueList<TQRect> &areas, bool andRemove)
{
for (TQValueList<TQRect>::iterator it = areas.begin(); it != areas.end(); ) {
TQRect &rect = *it;
// Split the rectangle if it intersects with rectToSubstract:
if (rect.intersects(rectToSubstract)) {
// Create the top rectangle:
if (rectToSubstract.top() > rect.top()) {
areas.insert(it, TQRect(rect.left(), rect.top(), rect.width(), rectToSubstract.top() - rect.top()));
rect.setTop(rectToSubstract.top());
}
// Create the bottom rectangle:
if (rectToSubstract.bottom() < rect.bottom()) {
areas.insert(it, TQRect(rect.left(), rectToSubstract.bottom() + 1, rect.width(), rect.bottom() - rectToSubstract.bottom()));
rect.setBottom(rectToSubstract.bottom());
}
// Create the left rectangle:
if (rectToSubstract.left() > rect.left()) {
areas.insert(it, TQRect(rect.left(), rect.top(), rectToSubstract.left() - rect.left(), rect.height()));
rect.setLeft(rectToSubstract.left());
}
// Create the right rectangle:
if (rectToSubstract.right() < rect.right()) {
areas.insert(it, TQRect(rectToSubstract.right() + 1, rect.top(), rect.right() - rectToSubstract.right(), rect.height()));
rect.setRight(rectToSubstract.right());
}
// Remove the rectangle if it's entirely contained:
if (andRemove && rectToSubstract.contains(rect))
it = areas.remove(it);
else
++it;
} else
++it;
}
}
void Note::recomputeAreas()
{
// Initialize the areas with the note rectangle(s):
m_areas.clear();
m_areas.append(visibleRect());
if (hasResizer())
m_areas.append(resizerRect());
// Cut the areas where other notes are on top of this note:
Note *note = basket()->firstNote();
bool noteIsAfterThis = false;
while (note) {
noteIsAfterThis = recomputeAreas(note, noteIsAfterThis);
note = note->next();
}
}
bool Note::recomputeAreas(Note *note, bool noteIsAfterThis)
{
if (note == this)
noteIsAfterThis = true;
// Only compute overlapping of notes AFTER this, or ON TOP this:
//else if ( note->matching() && noteIsAfterThis && (!isOnTop() || (isOnTop() && note->isOnTop())) || (!isOnTop() && note->isOnTop()) ) {
else if ( note->matching() && noteIsAfterThis && (!(isOnTop() || isEditing()) || ((isOnTop() || isEditing()) && (note->isOnTop() || note->isEditing()))) ||
(!(isOnTop() || isEditing()) && (note->isOnTop() || note->isEditing())) ) {
//if (!(isSelected() && !note->isSelected())) { // FIXME: FIXME: FIXME: FIXME: This last condition was added LATE, so we should look if it's ALWAYS good:
substractRectOnAreas(note->visibleRect(), m_areas, true);
if (note->hasResizer())
substractRectOnAreas(note->resizerRect(), m_areas, true);
//}
}
if (note->isGroup()) {
Note *child = note->firstChild();
bool first = true;
while (child) {
if ((note->showSubNotes() || first) && note->matching())
noteIsAfterThis = recomputeAreas(child, noteIsAfterThis);
child = child->next();
first = false;
}
}
return noteIsAfterThis;
}
bool Note::isEditing()
{
return basket()->editedNote() == this;
}
void Note::getGradientColors(const TQColor &originalBackground, TQColor *colorTop, TQColor *colorBottom)
{
bool wasTooDark = Tools::tooDark(originalBackground);
if (wasTooDark) {
*colorTop = originalBackground;
*colorBottom = originalBackground.light(120);
} else {
*colorTop = originalBackground.dark(105);
*colorBottom = originalBackground;
}
}
/* Drawing policy:
* ==============
* - Draw the note on a pixmap and then draw the pixmap on screen is faster and flicker-free, rather than drawing directly on screen
* - The next time the pixmap can be directly redrawn on screen without (relatively low, for small texts) time-consuming text-drawing
* - To keep memory footprint low, we can destruct the bufferPixmap because redrawing it offscreen and applying it onscreen is nearly as fast as just drawing the pixmap onscreen
* - But as drawing the pixmap offscreen is little time consuming we can keep last visible notes buffered and then the redraw of the entire window is INSTANTANEOUS
* - We keep bufferized note/group draws BUT NOT the resizer: such objects are small and fast to draw, so we don't complexify code for that
*/
void Note::draw(TQPainter *painter, const TQRect &clipRect)
{
if (!matching())
return;
/** Paint childs: */
if (isGroup()) {
Note *child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
child->draw(painter, clipRect);
child = child->next();
first = false;
}
}
TQRect myRect(x(), y(), width(), height());
/** Paint the resizer if needed: */
if (hasResizer()) {
int right = rightLimit();
TQRect resizerRect(right, y(), RESIZER_WIDTH, resizerHeight());
if (resizerRect.intersects(clipRect)) {
// Prepare to draw the resizer:
TQPixmap pixmap(RESIZER_WIDTH, resizerHeight());
TQPainter painter2(&pixmap);
// Draw gradient or resizer:
if (m_hovered && m_hoveredZone == Resizer) {
TQColor baseColor(basket()->backgroundColor());
TQColor highColor(TDEGlobalSettings::highlightColor());
drawResizer(&painter2, 0, 0, RESIZER_WIDTH, resizerHeight(), baseColor, highColor, /*rounded=*/!isColumn());
if (!isColumn()) {
drawRoundings(&painter2, RESIZER_WIDTH - 3, 0, /*type=*/3);
drawRoundings(&painter2, RESIZER_WIDTH - 3, resizerHeight() - 3, /*type=*/4);
}
} else {
drawInactiveResizer(&painter2, /*x=*/0, /*y=*/0, /*height=*/resizerHeight(), basket()->backgroundColor(), isColumn());
basket()->blendBackground(painter2, resizerRect);
}
// Draw inserter:
if (basket()->inserterShown() && resizerRect.intersects(basket()->inserterRect()))
basket()->drawInserter(painter2, right, y());
// Draw selection rect:
if (basket()->isSelecting() && resizerRect.intersects(basket()->selectionRect())) {
TQRect selectionRect = basket()->selectionRect();
selectionRect.moveBy(-right, -y());
TQRect selectionRectInside(selectionRect.x() + 1, selectionRect.y() + 1, selectionRect.width() - 2, selectionRect.height() - 2);
if (selectionRectInside.width() > 0 && selectionRectInside.height() > 0) {
TQColor insideColor = basket()->selectionRectInsideColor();
TQColor darkInsideColor(insideColor.dark(105));
painter2.setClipRect(selectionRectInside);
if (isColumn()) {
int halfWidth = RESIZER_WIDTH / 2;
drawGradient(&painter2, darkInsideColor, insideColor, 0, 0, halfWidth, resizerHeight(), /*sunken=*/false, /*horz=*/false, /*flat=*/false );
drawGradient(&painter2, insideColor, darkInsideColor, halfWidth, 0, RESIZER_WIDTH-halfWidth, resizerHeight(), /*sunken=*/false, /*horz=*/false, /*flat=*/false );
} else
drawGradient( &painter2, darkInsideColor, insideColor, 0, 0, RESIZER_WIDTH, resizerHeight(), /*sunken=*/false, /*horz=*/false, /*flat=*/false );
painter2.setClipping(false);
selectionRectInside.moveBy(right, y());
basket()->blendBackground(painter2, selectionRectInside, right, y(), false);
}
painter2.setPen(TDEGlobalSettings::highlightColor().dark());
painter2.drawRect(selectionRect);
painter2.setPen(Tools::mixColor(TDEGlobalSettings::highlightColor().dark(), basket()->backgroundColor()));
painter2.drawPoint(selectionRect.topLeft());
painter2.drawPoint(selectionRect.topRight());
painter2.drawPoint(selectionRect.bottomLeft());
painter2.drawPoint(selectionRect.bottomRight());
}
// Draw on screen:
painter2.end();
/** Compute visible areas: */
if ( ! m_computedAreas )
recomputeAreas();
if (m_areas.isEmpty())
return;
for (TQValueList<TQRect>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
TQRect &rect = *it;
painter->drawPixmap(rect.x(), rect.y(), pixmap, rect.x() - right, rect.y() - y(), rect.width(), rect.height());
}
}
}
/** Then, draw the note/group ONLY if needed: */
if ( ! myRect.intersects(clipRect) )
return;
/** Compute visible areas: */
if ( ! m_computedAreas )
recomputeAreas();
if (m_areas.isEmpty())
return;
/** Directly draw pixmap on screen if it is already buffered: */
if (isBufferized()) {
drawBufferOnScreen(painter, m_bufferedPixmap);
return;
}
/** Initialise buffer painter: */
m_bufferedPixmap.resize(width(), height());
TQPainter painter2(&m_bufferedPixmap);
/** Initialise colors: */
TQColor baseColor(basket()->backgroundColor());
TQColor highColor(TDEGlobalSettings::highlightColor());
TQColor midColor = Tools::mixColor(baseColor, highColor);
/** Initialise brushs and pens: */
TQBrush baseBrush(baseColor);
TQBrush highBrush(highColor);
TQPen basePen(baseColor);
TQPen highPen(highColor);
TQPen midPen(midColor);
/** Figure out the state of the note: */
bool hovered = m_hovered && m_hoveredZone != TopInsert && m_hoveredZone != BottomInsert && m_hoveredZone != Resizer;
/** And then draw the group: */
if (isGroup()) {
// Draw background or handle:
if (hovered) {
drawHandle(&painter2, 0, 0, width(), height(), baseColor, highColor);
drawRoundings(&painter2, 0, 0, /*type=*/1);
drawRoundings(&painter2, 0, height() - 3, /*type=*/2);
} else {
painter2.fillRect(0, 0, width(), height(), baseBrush);
basket()->blendBackground(painter2, myRect, -1, -1, /*opaque=*/true);
}
// Draw expander:
int yExp = yExpander();
drawExpander(&painter2, NOTE_MARGIN, yExp, (hovered ? expanderBackground(height(), yExp+EXPANDER_HEIGHT/2, highColor) : baseColor), m_isFolded, basket());
// Draw expander rounded edges:
if (hovered) {
TQColor color1 = expanderBackground(height(), yExp, highColor);
TQColor color2 = expanderBackground(height(), yExp + EXPANDER_HEIGHT - 1, highColor);
painter2.setPen(color1);
painter2.drawPoint(NOTE_MARGIN, yExp);
painter2.drawPoint(NOTE_MARGIN + 9 - 1, yExp);
painter2.setPen(color2);
painter2.drawPoint(NOTE_MARGIN, yExp + 9 - 1);
painter2.drawPoint(NOTE_MARGIN + 9 - 1, yExp + 9 - 1);
} else
drawRoundings(&painter2, NOTE_MARGIN, yExp, /*type=*/5, 9, 9);
// Draw on screen:
painter2.end();
drawBufferOnScreen(painter, m_bufferedPixmap);
return;
}
/** Or draw the note: */
// What are the background colors:
TQColor background = basket()->backgroundColor();
if (isSelected())
if (m_computedState.backgroundColor().isValid())
background = Tools::mixColor(Tools::mixColor(m_computedState.backgroundColor(), TDEGlobalSettings::highlightColor()), TDEGlobalSettings::highlightColor());
else
background = TDEGlobalSettings::highlightColor();
else if (m_computedState.backgroundColor().isValid())
background = m_computedState.backgroundColor();
TQColor bgColor;
TQColor darkBgColor;
getGradientColors(background, &darkBgColor, &bgColor);
// Draw background (color, gradient and pixmap):
drawGradient( &painter2, bgColor, darkBgColor, 0, 0, width(), height(), /*sunken=*/!hovered, /*horz=*/true, /*flat=*/false );
if (!hovered) {
painter2.setPen(Tools::mixColor(bgColor, darkBgColor));
painter2.drawLine(0, height() - 1, width(), height() - 1);
}
basket()->blendBackground(painter2, myRect);
if (hovered) {
// Top/Bottom lines:
painter2.setPen(highPen);
painter2.drawLine(0, height() - 1, width(), height() - 1);
painter2.drawLine(0, 0, width(), 0);
// The handle:
drawHandle(&painter2, 0, 0, HANDLE_WIDTH, height(), baseColor, highColor);
drawRoundings(&painter2, 0, 0, /*type=*/1);
drawRoundings(&painter2, 0, height() - 3, /*type=*/2);
// Round handle-right-side border:
painter2.setPen(highPen);
painter2.drawPoint(HANDLE_WIDTH, 1);
painter2.drawPoint(HANDLE_WIDTH, height() - 2);
// Light handle top-right round corner:
painter2.setPen(TQPen(highColor.light(150)));
painter2.drawPoint(HANDLE_WIDTH - 1, 1);
// Handle anti-aliased rounded handle-right-side corners:
TQColor insideMidColor = Tools::mixColor(bgColor, highColor);
painter2.setPen(insideMidColor);
// Left inside round corners:
painter2.drawPoint(HANDLE_WIDTH + 1, 1);
painter2.drawPoint(HANDLE_WIDTH, 2);
painter2.drawPoint(HANDLE_WIDTH + 1, height() - 2);
painter2.drawPoint(HANDLE_WIDTH, height() - 3);
// Right inside round corners:
painter2.drawPoint(width() - 4, 1);
painter2.drawPoint(width() - 3, 2);
painter2.drawPoint(width() - 4, height() - 2);
painter2.drawPoint(width() - 3, height() - 3);
// Right rounded edge:
painter2.setPen(highPen);
painter2.fillRect(width() - 2, 0, 2, height(), highBrush);
painter2.drawPoint(width() - 3, 1);
painter2.drawPoint(width() - 3, height() - 2);
// Right anti-aliased rounded edge:
painter2.setPen(midPen);
painter2.drawPoint(width() - 1, 0);
painter2.drawPoint(width() - 1, height() - 1);
// Blend background pixmap:
drawRoundings(&painter2, 0, 0, /*type=*/6, width(), height());
}
if (isFocused()) {
TQRect focusRect(HANDLE_WIDTH, NOTE_MARGIN - 1, width() - HANDLE_WIDTH - 2, height() - 2*NOTE_MARGIN + 2);
painter2.drawWinFocusRect(focusRect);
}
// Draw the Emblems:
int yIcon = (height() - EMBLEM_SIZE) / 2;
int xIcon = HANDLE_WIDTH + NOTE_MARGIN;
for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it) {
if (!(*it)->emblem().isEmpty()) {
TQPixmap stateEmblem = kapp->iconLoader()->loadIcon((*it)->emblem(), TDEIcon::NoGroup, 16, TDEIcon::DefaultState, 0L, false);
painter2.drawPixmap(xIcon, yIcon, stateEmblem);
xIcon += NOTE_MARGIN + EMBLEM_SIZE;
}
}
// Determine the colors (for the richText drawing) and the text color (for the tags arrow too):
TQColorGroup cg(basket()->colorGroup());
cg.setColor(TQColorGroup::Text, (m_computedState.textColor().isValid() ? m_computedState.textColor() : basket()->textColor()) );
cg.setColor(TQColorGroup::Background, bgColor);
if (isSelected())
cg.setColor(TQColorGroup::Text, TDEGlobalSettings::highlightedTextColor());
// Draw the Tags Arrow:
if (hovered) {
TQColor textColor = cg.color(TQColorGroup::Text);
TQColor light = Tools::mixColor(textColor, bgColor);
TQColor mid = Tools::mixColor(textColor, light);
painter2.setPen(light);//TQPen(basket()->colorGroup().dark().light(150)));
painter2.drawLine(xIcon, yIcon + 6, xIcon + 4, yIcon + 6);
painter2.setPen(mid);//TQPen(basket()->colorGroup().dark()));
painter2.drawLine(xIcon + 1, yIcon + 7, xIcon + 3, yIcon + 7);
painter2.setPen(textColor);//TQPen(basket()->colorGroup().foreground()));
painter2.drawPoint(xIcon + 2, yIcon + 8);
} else if (m_haveInvisibleTags) {
painter2.setPen(cg.color(TQColorGroup::Text)/*TQPen(basket()->colorGroup().foreground())*/);
painter2.drawPoint(xIcon, yIcon + 7);
painter2.drawPoint(xIcon + 2, yIcon + 7);
painter2.drawPoint(xIcon + 4, yIcon + 7);
}
// Draw content:
// Optimization: do not draw text notes because it is time consuming and should be done nearly at each tetx modification.
if (basket()->editedNote() != this || basket()->editedNote()->content()->type() != NoteType::Html) {
painter2.translate(contentX(), NOTE_MARGIN);
painter2.setFont( m_computedState.font(painter2.font()) );
m_content->paint(&painter2, width() - contentX() - NOTE_MARGIN, height() - 2*NOTE_MARGIN, cg, !m_computedState.textColor().isValid(), isSelected(), hovered);
}
// Draw on screen:
painter2.end();
drawBufferOnScreen(painter, m_bufferedPixmap);
}
void Note::drawBufferOnScreen(TQPainter *painter, const TQPixmap &contentPixmap)
{
for (TQValueList<TQRect>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
TQRect &rect = *it;
if (rect.x() >= x() + width()) // It's a rect of the resizer, don't draw it!
continue;
// If the inserter is above the note, draw it, BUT NOT in the buffer pixmap,
// we copy the rectangle in a new pixmap, apply the inserter and then draw this new pixmap on screen:
if ( (basket()->inserterShown() && rect.intersects(basket()->inserterRect())) ||
(basket()->isSelecting() && rect.intersects(basket()->selectionRect())) ) {
TQPixmap pixmap3(rect.width(), rect.height());
TQPainter painter3(&pixmap3);
painter3.drawPixmap(0, 0, contentPixmap, rect.x() - x(), rect.y() - y(), rect.width(), rect.height());
// Draw inserter:
if (basket()->inserterShown() && rect.intersects(basket()->inserterRect()))
basket()->drawInserter(painter3, rect.x(), rect.y());
// Draw selection rect:
if (basket()->isSelecting() && rect.intersects(basket()->selectionRect())) {
TQRect selectionRect = basket()->selectionRect();
selectionRect.moveBy(-rect.x(), -rect.y());
TQRect selectionRectInside(selectionRect.x() + 1, selectionRect.y() + 1, selectionRect.width() - 2, selectionRect.height() - 2);
if (selectionRectInside.width() > 0 && selectionRectInside.height() > 0) {
bufferizeSelectionPixmap();
selectionRectInside.moveBy(rect.x(), rect.y());
TQRect rectToPaint = rect.intersect(selectionRectInside);
rectToPaint.moveBy(-x(), -y());
painter3.drawPixmap(rectToPaint.topLeft() + TQPoint(x(), y()) - rect.topLeft(), m_bufferedSelectionPixmap, rectToPaint);
//blendBackground(painter2, selectionRectInside, rect.x(), rect.y(), true, &m_selectedBackgroundPixmap);
}
painter3.setPen(TDEGlobalSettings::highlightColor().dark());
painter3.drawRect(selectionRect);
if (isGroup())
painter3.setPen(Tools::mixColor(TDEGlobalSettings::highlightColor().dark(), basket()->backgroundColor()));
else {
// What are the background colors:
TQColor bgColor = basket()->backgroundColor();
if (isSelected())
bgColor = (m_computedState.backgroundColor().isValid() ? Tools::mixColor(Tools::mixColor(m_computedState.backgroundColor(), TDEGlobalSettings::highlightColor()), TDEGlobalSettings::highlightColor()) : TDEGlobalSettings::highlightColor());
else if (m_computedState.backgroundColor().isValid())
bgColor = m_computedState.backgroundColor();
painter3.setPen(Tools::mixColor(TDEGlobalSettings::highlightColor().dark(), bgColor));
}
painter3.drawPoint(selectionRect.topLeft());
painter3.drawPoint(selectionRect.topRight());
painter3.drawPoint(selectionRect.bottomLeft());
painter3.drawPoint(selectionRect.bottomRight());
}
painter3.end();
painter->drawPixmap(rect.x(), rect.y(), pixmap3);
// Else, draw the rect pixmap directly on screen:
} else
painter->drawPixmap(rect.x(), rect.y(), contentPixmap, rect.x() - x(), rect.y() - y(), rect.width(), rect.height());
}
}
void Note::setContent(NoteContent *content)
{
m_content = content;
}
/*const */State::List& Note::states() const
{
return (State::List&)m_states;
}
void Note::addState(State *state, bool orReplace)
{
if (!content())
return;
Tag *tag = state->parentTag();
State::List::iterator itStates = m_states.begin();
// Browse all tags, see if the note has it, increment itSates if yes, and then insert the state at this position...
// For each existing tags:
for (Tag::List::iterator it = Tag::all.begin(); it != Tag::all.end(); ++it) {
// If the current tag isn't the one to assign or the current one on the note, go to the next tag:
if (*it != tag && itStates != m_states.end() && *it != (*itStates)->parentTag())
continue;
// We found the tag to insert:
if (*it == tag) {
// And the note already have the tag:
if (itStates != m_states.end() && *it == (*itStates)->parentTag()) {
// We replace the state if wanted:
if (orReplace) {
itStates = m_states.insert(itStates, state);
++itStates;
m_states.remove(itStates);
recomputeStyle();
}
} else {
m_states.insert(itStates, state);
recomputeStyle();
}
return;
}
// The note has this tag:
if (itStates != m_states.end() && *it == (*itStates)->parentTag())
++itStates;
}
}
TQFont Note::font()
{
return m_computedState.font( basket()->TQScrollView::font() );
}
TQColor Note::backgroundColor()
{
if (m_computedState.backgroundColor().isValid())
return m_computedState.backgroundColor();
else
return basket()->backgroundColor();
}
TQColor Note::textColor()
{
if (m_computedState.textColor().isValid())
return m_computedState.textColor();
else
return basket()->textColor();
}
void Note::recomputeStyle()
{
State::merge(m_states, &m_computedState, &m_emblemsCount, &m_haveInvisibleTags, basket()->backgroundColor());
// unsetWidth();
if (content())
content()->fontChanged();
// requestRelayout(); // TODO!
}
void Note::recomputeAllStyles()
{
if (content()) // We do the merge ourself, without calling recomputeStyle(), so there is no infinite recursion:
//State::merge(m_states, &m_computedState, &m_emblemsCount, &m_haveInvisibleTags, basket()->backgroundColor());
recomputeStyle();
else if (isGroup())
FOR_EACH_CHILD (child)
child->recomputeAllStyles();
}
bool Note::removedStates(const TQValueList<State*> &deletedStates)
{
bool modifiedBasket = false;
if (!states().isEmpty()) {
for (TQValueList<State*>::const_iterator it = deletedStates.begin(); it != deletedStates.end(); ++it)
if (hasState(*it)) {
removeState(*it);
modifiedBasket = true;
}
}
FOR_EACH_CHILD (child)
if (child->removedStates(deletedStates))
modifiedBasket = true;
return modifiedBasket;
}
void Note::addTag(Tag *tag)
{
addState(tag->states().first(), /*but do not replace:*/false);
}
void Note::removeState(State *state)
{
for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
if (*it == state) {
m_states.remove(it);
recomputeStyle();
return;
}
}
void Note::removeTag(Tag *tag)
{
for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
if ((*it)->parentTag() == tag) {
m_states.remove(it);
recomputeStyle();
return;
}
}
void Note::removeAllTags()
{
m_states.clear();
recomputeStyle();
}
void Note::addTagToSelectedNotes(Tag *tag)
{
if (content() && isSelected())
addTag(tag);
FOR_EACH_CHILD (child)
child->addTagToSelectedNotes(tag);
}
void Note::removeTagFromSelectedNotes(Tag *tag)
{
if (content() && isSelected()) {
if (hasTag(tag))
setWidth(0);
removeTag(tag);
}
FOR_EACH_CHILD (child)
child->removeTagFromSelectedNotes(tag);
}
void Note::removeAllTagsFromSelectedNotes()
{
if (content() && isSelected()) {
if (m_states.count() > 0)
setWidth(0);
removeAllTags();
}
FOR_EACH_CHILD (child)
child->removeAllTagsFromSelectedNotes();
}
void Note::addStateToSelectedNotes(State *state, bool orReplace)
{
if (content() && isSelected())
addState(state, orReplace);
FOR_EACH_CHILD (child)
child->addStateToSelectedNotes(state, orReplace); // TODO: Basket::addStateToSelectedNotes() does not have orReplace
}
void Note::changeStateOfSelectedNotes(State *state)
{
if (content() && isSelected() && hasTag(state->parentTag()))
addState(state);
FOR_EACH_CHILD (child)
child->changeStateOfSelectedNotes(state);
}
bool Note::selectedNotesHaveTags()
{
if (content() && isSelected() && m_states.count() > 0)
return true;
FOR_EACH_CHILD (child)
if (child->selectedNotesHaveTags())
return true;
return false;
}
bool Note::hasState(State *state)
{
for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
if (*it == state)
return true;
return false;
}
bool Note::hasTag(Tag *tag)
{
for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
if ((*it)->parentTag() == tag)
return true;
return false;
}
State* Note::stateOfTag(Tag *tag)
{
for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
if ((*it)->parentTag() == tag)
return *it;
return 0;
}
State* Note::stateForEmblemNumber(int number)
{
int i = -1;
for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it)
if (!(*it)->emblem().isEmpty()) {
++i;
if (i == number)
return *it;
}
return 0;
}
bool Note::stateForTagFromSelectedNotes(Tag *tag, State **state)
{
if (content() && isSelected()) {
// What state is the tag on this note?
State* stateOfTag = this->stateOfTag(tag);
// This tag is not assigned to this note, the action will assign it, then:
if (stateOfTag == 0)
*state = 0;
else {
// Take the LOWEST state of all the selected notes:
// Say the two selected notes have the state "Done" and "To Do".
// The first note set *state to "Done".
// When reaching the second note, we should recognize "To Do" is first in the tag states, then take it
// Because pressing the tag shortcut key should first change state before removing the tag!
if (*state == 0)
*state = stateOfTag;
else {
bool stateIsFirst = true;
for (State *nextState = stateOfTag->nextState(); nextState; nextState = nextState->nextState(/*cycle=*/false))
if (nextState == *state)
stateIsFirst = false;
if (!stateIsFirst)
*state = stateOfTag;
}
}
return true; // We encountered a selected note
}
bool encounteredSelectedNote = false;
FOR_EACH_CHILD (child) {
bool encountered = child->stateForTagFromSelectedNotes(tag, state);
if (encountered && *state == 0)
return true;
if (encountered)
encounteredSelectedNote = true;
}
return encounteredSelectedNote;
}
void Note::inheritTagsOf(Note *note)
{
if (!note || !content())
return;
for (State::List::iterator it = note->states().begin(); it != note->states().end(); ++it)
if ((*it)->parentTag() && (*it)->parentTag()->inheritedBySiblings())
addTag((*it)->parentTag());
}
void Note::unbufferizeAll()
{
unbufferize();
if (isGroup()) {
Note *child = firstChild();
while (child) {
child->unbufferizeAll();
child = child->next();
}
}
}
void Note::bufferizeSelectionPixmap()
{
if (m_bufferedSelectionPixmap.isNull()) {
TQColor insideColor = TDEGlobalSettings::highlightColor();
KPixmap kpixmap(m_bufferedPixmap);
m_bufferedSelectionPixmap = KPixmapEffect::fade(kpixmap, 0.25, insideColor);
}
}
TQRect Note::visibleRect()
{
TQValueList<TQRect> areas;
areas.append(rect());
// When we are folding a parent group, if this note is bigger than the first real note of the group, cut the top of this:
Note *parent = parentNote();
while (parent) {
if (parent->expandingOrCollapsing())
substractRectOnAreas(TQRect(x(), parent->y() - height(), width(), height()), areas, true);
parent = parent->parentNote();
}
if (areas.count() > 0)
return areas[0];
else
return TQRect();
}
void Note::recomputeBlankRects(TQValueList<TQRect> &blankAreas)
{
if (!matching())
return;
// visibleRect() instead of rect() because if we are folding/expanding a smaller parent group, then some part is hidden!
// But anyway, a resizer is always a primary note and is never hidden by a parent group, so no visibleResizerRect() method!
substractRectOnAreas(visibleRect(), blankAreas, true);
if (hasResizer())
substractRectOnAreas(resizerRect(), blankAreas, true);
if (isGroup()) {
Note *child = firstChild();
bool first = true;
while (child) {
if ((showSubNotes() || first) && child->matching())
child->recomputeBlankRects(blankAreas);
child = child->next();
first = false;
}
}
}
void Note::linkLookChanged()
{
if (isGroup()) {
Note *child = firstChild();
while (child) {
child->linkLookChanged();
child = child->next();
}
} else
content()->linkLookChanged();
}
Note* Note::noteForFullPath(const TQString &path)
{
if (content() && fullPath() == path)
return this;
Note *child = firstChild();
Note *found;
while (child) {
found = child->noteForFullPath(path);
if (found)
return found;
child = child->next();
}
return 0;
}
void Note::listUsedTags(TQValueList<Tag*> &list)
{
for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it) {
Tag *tag = (*it)->parentTag();
if (!list.contains(tag))
list.append(tag);
}
FOR_EACH_CHILD (child)
child->listUsedTags(list);
}
void Note::usedStates(TQValueList<State*> &states)
{
if (content())
for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it)
if (!states.contains(*it))
states.append(*it);
FOR_EACH_CHILD (child)
child->usedStates(states);
}
Note* Note::nextInStack()
{
// First, search in the childs:
if (firstChild())
if (firstChild()->content())
return firstChild();
else
return firstChild()->nextInStack();
// Then, in the next:
if (next())
if (next()->content())
return next();
else
return next()->nextInStack();
// And finally, in the parent:
Note *note = parentNote();
while (note)
if (note->next())
if (note->next()->content())
return note->next();
else
return note->next()->nextInStack();
else
note = note->parentNote();
// Not found:
return 0;
}
Note* Note::prevInStack()
{
// First, search in the previous:
if (prev() && prev()->content())
return prev();
// Else, it's a group, get the last item in that group:
if (prev()) {
Note *note = prev()->lastRealChild();
if (note)
return note;
}
if (parentNote())
return parentNote()->prevInStack();
else
return 0;
}
Note* Note::nextShownInStack()
{
Note *next = nextInStack();
while (next && !next->isShown())
next = next->nextInStack();
return next;
}
Note* Note::prevShownInStack()
{
Note *prev = prevInStack();
while (prev && !prev->isShown())
prev = prev->prevInStack();
return prev;
}
bool Note::isShown()
{
// First, the easy one: groups are always shown:
if (isGroup())
return true;
// And another easy part: non-matching notes are hidden:
if (!matching())
return false;
if (basket()->isFiltering()) // And isMatching() because of the line above!
return true;
// So, here we go to the complexe case: if the note is inside a collapsed group:
Note *group = parentNote();
Note *child = this;
while (group) {
if (group->isFolded() && group->firstChild() != child)
return false;
child = group;
group = group->parentNote();
}
return true;
}
void Note::debug()
{
std::cout << "Note@" << (TQ_UINT64)this;
if (!this) {
std::cout << std::endl;
return;
}
if (isColumn())
std::cout << ": Column";
else if (isGroup())
std::cout << ": Group";
else
std::cout << ": Content[" << content()->lowerTypeName().local8Bit() << "]: " << toText("").local8Bit();
std::cout << std::endl;
}
Note* Note::firstSelected()
{
if (isSelected())
return this;
Note *first = 0;
FOR_EACH_CHILD (child) {
first = child->firstSelected();
if (first)
break;
}
return first;
}
Note* Note::lastSelected()
{
if (isSelected())
return this;
Note *last = 0, *tmp = 0;
FOR_EACH_CHILD (child) {
tmp = child->lastSelected();
if (tmp)
last = tmp;
}
return last;
}
Note* Note::selectedGroup()
{
if (isGroup() && allSelected() && count() == basket()->countSelecteds())
return this;
FOR_EACH_CHILD (child) {
Note *selectedGroup = child->selectedGroup();
if (selectedGroup)
return selectedGroup;
}
return 0;
}
void Note::groupIn(Note *group)
{
if (this == group)
return;
if (allSelected() && !isColumn()) {
basket()->unplugNote(this);
basket()->insertNote(this, group, Note::BottomColumn, TQPoint(), /*animateNewPosition=*/true);
} else {
Note *next;
Note *child = firstChild();
while (child) {
next = child->next();
child->groupIn(group);
child = next;
}
}
}
bool Note::tryExpandParent()
{
Note *parent = parentNote();
Note *child = this;
while (parent) {
if (parent->firstChild() != child)
return false;
if (parent->isColumn())
return false;
if (parent->isFolded()) {
parent->toggleFolded(true);
basket()->relayoutNotes(true);
return true;
}
child = parent;
parent = parent->parentNote();
}
return false;
}
bool Note::tryFoldParent() // TODO: withCtrl ? withShift ?
{
Note *parent = parentNote();
Note *child = this;
while (parent) {
if (parent->firstChild() != child)
return false;
if (parent->isColumn())
return false;
if (!parent->isFolded()) {
parent->toggleFolded(true);
basket()->relayoutNotes(true);
return true;
}
child = parent;
parent = parent->parentNote();
}
return false;
}
int Note::distanceOnLeftRight(Note *note, int side)
{
if (side == Basket::RIGHT_SIDE) {
// If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
if (finalX() > note->finalX() || finalRightLimit() > note->finalRightLimit())
return -1;
} else /*LEFT_SIDE:*/ {
// If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
if (finalX() < note->finalX() || finalRightLimit() < note->finalRightLimit())
return -1;
}
if (finalX() == note->finalX() && finalRightLimit() == note->finalRightLimit())
return -1;
float thisCenterX = finalX() + (side == Basket::LEFT_SIDE ? width() : /*RIGHT_SIDE:*/ 0);
float thisCenterY = finalY() + finalHeight() / 2;
float noteCenterX = note->finalX() + note->width() / 2;
float noteCenterY = note->finalY() + note->finalHeight() / 2;
if (thisCenterY > note->finalBottom())
noteCenterY = note->finalBottom();
else if (thisCenterY < note->finalY())
noteCenterY = note->finalY();
else
noteCenterY = thisCenterY;
float angle = 0;
if (noteCenterX - thisCenterX != 0)
angle = 1000 * ((noteCenterY - thisCenterY) / (noteCenterX - thisCenterX));
if (angle < 0)
angle = -angle;
return int(sqrt(pow(noteCenterX - thisCenterX, 2) + pow(noteCenterY - thisCenterY, 2)) + angle);
}
int Note::distanceOnTopBottom(Note *note, int side)
{
if (side == Basket::BOTTOM_SIDE) {
// If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
if (finalY() > note->finalY() || finalBottom() > note->finalBottom())
return -1;
} else /*TOP_SIDE:*/ {
// If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
if (finalY() < note->finalY() || finalBottom() < note->finalBottom())
return -1;
}
if (finalY() == note->finalY() && finalBottom() == note->finalBottom())
return -1;
float thisCenterX = finalX() + width() / 2;
float thisCenterY = finalY() + (side == Basket::TOP_SIDE ? finalHeight() : /*BOTTOM_SIDE:*/ 0);
float noteCenterX = note->finalX() + note->width() / 2;
float noteCenterY = note->finalY() + note->finalHeight() / 2;
if (thisCenterX > note->finalRightLimit())
noteCenterX = note->finalRightLimit();
else if (thisCenterX < note->finalX())
noteCenterX = note->finalX();
else
noteCenterX = thisCenterX;
float angle = 0;
if (noteCenterX - thisCenterX != 0)
angle = 1000 * ((noteCenterY - thisCenterY) / (noteCenterX - thisCenterX));
if (angle < 0)
angle = -angle;
return int(sqrt(pow(noteCenterX - thisCenterX, 2) + pow(noteCenterY - thisCenterY, 2)) + angle);
}
Note* Note::parentPrimaryNote()
{
Note *primary = this;
while (primary->parentNote())
primary = primary->parentNote();
return primary;
}
void Note::deleteChilds()
{
Note *child = firstChild();
while (child)
{
Note *tmp = child->next();
delete child;
child = tmp;
}
}
bool Note::saveAgain()
{
if(content())
{
if(!content()->saveToFile())
return false;
}
FOR_EACH_CHILD (child)
{
if(!child->saveAgain())
return false;
}
return true;
}
bool Note::convertTexts()
{
bool convertedNotes = false;
if (content() && content()->lowerTypeName() == "text") {
TQString text = ((TextContent*)content())->text();
TQString html = "<html><head><meta name=\"qrichtext\" content=\"1\" /></head><body>" + Tools::textToHTMLWithoutP(text) + "</body></html>";
basket()->saveToFile(fullPath(), html, /*isLocalEncoding=*/true);
setContent( new HtmlContent(this, content()->fileName()) );
convertedNotes = true;
}
FOR_EACH_CHILD (child)
if (child->convertTexts())
convertedNotes = true;
return convertedNotes;
}
#if 0
/** Note */
TQString Note::toHtml(const TQString &imageName)
{
switch (m_type) {
case Text:
/*return "<font color=" + backgroundColor().name() + + font().name() + font + ">" +
Tools::textToHTMLWithoutP(text()) + "</font>";*/
return Tools::textToHTMLWithoutP(text());
case Html:
return Tools::htmlToParagraph(html());
case Image:
case Animation:
{
if ( (m_type == Image && pixmap() == 0L) ||
(m_type == Animation && movie() == 0L) ) {
TQMimeSourceFactory::defaultFactory()->setData(imageName, 0L);
return i18n("(Image)"); // Image or animation not yet loaded!!
}
TQImage image;
if (m_type == Image)
image = pixmap()->convertToImage();
else
image = movie()->framePixmap().convertToImage();
image = image.smoothScale(200, 150, TQImage::ScaleMin);
TQPixmap pixmap = TQPixmap(image);
TQMimeSourceFactory::defaultFactory()->setPixmap(imageName, pixmap);
return "<img src=" + imageName + ">"; ///
/* // FIXME: movie isn't loaded yet: CRASH!
return i18n("(Image)");
// Not executed, because don't work:
TQImage image;
if (m_type == Image)
image = pixmap()->convertToImage();
else
image = movie()->framePixmap().convertToImage();
image = image.smoothScale(200, 150, TQImage::ScaleMin);
TQPixmap pixmap = TQPixmap(image);
TQMimeSourceFactory::defaultFactory()->setPixmap(imageName, pixmap);
return "<img src=" + imageName + ">"; ///
*/ //TODO?: TQMimeSourceFactory::defaultFactory()->setData(imageName, 0L);
}
case Sound:
case File:
{
/// FIXME: Since fullPath() doesn't exist yet, the icon rely on the extension.
/// Bad if there isn't one or if it's a wrong one.
/*TQPixmap icon = DesktopIcon(
NoteFactory::iconForURL(fullPath()),
(m_type == Sound ? LinkLook::soundLook : LinkLook::fileLook)->iconSize());
TQMimeSourceFactory::defaultFactory()->setPixmap(imageName, icon);
return "<img src=" + imageName + "> " + fileName(); */ ///
return m_linkLabel->toHtml(imageName);
}
case Link:
{
TQString link = m_linkLabel->toHtml(imageName);
if (!autoTitle() && title() != NoteFactory::titleForURL(url().prettyURL()))
link += "<br><i>" + url().prettyURL() + "</i>"; ///
return link;
}
case Launcher:
{
return m_linkLabel->toHtml(imageName);
//KService service(fullPath()); // service.icon()
//return service.name() + "<br><i>" + service.exec() + "</i>"; ///
}
case Color:
return "<b><font color=" + color().name() + ">" + color().name() + "</font></b>";
case Unknown:
return text();
}
return TQString();
}
#endif // #if 0
View Git Blame Copy Permalink