plasma-widget-smooth-tasks/000755 000765 000765 00000000000 11765222400 016571 5ustar00salvosalvo000000 000000 plasma-widget-smooth-tasks/.hgignore000644 000765 000765 00000000102 11724514472 020375 0ustar00salvosalvo000000 000000 syntax: glob *.o .* *.so build smooth-tasks-src-*.tar.bz2 *.kdev4 plasma-widget-smooth-tasks/ChangeLog000644 000765 000765 00000033401 11724514472 020354 0ustar00salvosalvo000000 000000 wip 2010-11-06: FIX: drop whole groups onto pager (removed workaround for KDE < 4.5 which could not handle groups at all) FIX: when dragging a task only a tiny bit it's position was not reset Maybe FIX: a very rare tooltip positioning bug (I have o wait if it reoccurs) wip 2010-11-05 update 1: FIX: fixed unwanted highlight behaviour change which reintroduces flickering :( wip 2010-11-05: FIX: tooltip appearance and background blur under KDE 4.5 FIX: less flickering for the kwin highlight effect wip 2010-02-27: FIX: less flickering for the window preview effect because I removed the kwin highlight effect bug workaround (that bug was obviously fixed in kde 4.4) FIX: crash when right-click on startup item, thanks to anonymous wip 2010-02-13 update 2: FIX: hopefully fixed bug concerning missing taskbar entries wip 2010-02-13 update 1: NOTE: since wip 2010-02-13 Smooth Tasks probably only works with kde 4.4 (and no longer with kde <= 4.3) FIX: same crash as in last version in other places FIX: correct handling of the root group under kde 4.4 wip 2010-02-13: FIX: taskbar items where not updated on desktop switch under kde 4.4 FIX: crash tasks where deleted but not yet removed from the layout (happened sometimes on desktop switch under kde 4.4) wip 2010-02-12: FIX: be more careful in TaskbarLayout::clear, hopefully fixes a crash, thanks to flupp Translations: * updated polish translation, thanks to Maciej Warnecki wip 2009-12-06: NEW: also do middle click action on tooltip FIX: chinese translation by Weng Xuetian (hurricanek) wip 2009-11-26: FIX: tiny bit better animation tick time calculation Translations: * updated polish translation, thanks to Maciej Warnecki wip 2009-11-20: FIX: taskbar getting stuck issue, much thanks to the bitbucket user flupp for fixing this! wip 2009-11-16: FIX: text placement (more like the original taskbar does it) Translations: * updated russian translation, thanks to xep wip 2009-11-11: Translations: * added chinese translation, thanks to Weng Xuetian (hurricanek) * updated french translation, thanks to Sergio * added ukrainian translation, thanks to Oleksandr Natalenko wip 2009-11-07: NEW: added middle click actions because of popular demand wip 2009-11-03: FIX: don't hide the panel when the tooltip is displayed wip 2009-11-02: FIX: gave tooltips a reasonable width when composite is deactivated an thus no preview is shown wip 2009-11-01: FIX: another tooltip placement regression wip 2009-10-30: FIX: crash on right click on startup items wip 2009-10-29: FIX: tooltip layout (text was not expanding horizontally properly) wip 2009-10-28: FIX: keep window order when raising/iconifying groups. thanks to mtz92 for the hint on how to do this wip 2009-10-27: FIX: tooltips moved animated even when it weren't shown before FIX: correctly track mouse hover state Improvements: * updated french translation, thanks to Sergio wip 2009-10-25: FIX: regression where the demand attention animation did only show the light on hover wip 2009-10-24: FIX: tooltip positioning regression NEW: optionally expand tasks on attention NEW: made task switch using wheel optional NEW: made tooltip movement duration configurable NEW: configureable initial window highlight delay Improvemetns: * fixes in german translation, thanks to Markus wip 2009-10-21: FIX: tooltip placement when hovering the taskbar really quick after another task was closed and thus its tooltip was hidden Improvements: * updated french translation, thanks to Sergio wip 2009-10-15: FIX: compile error FIX: expanding/collapsing task regression FIX: position of light during expansion Improvements: * added russian translation, thanks to xep * updated french translation, thanks to Sergio * context menu does not cover the task item anymore wip 2009-10-13: NEW: made 'light color from icon' optional FIX: fixed icon clipping issues which where introduced in the last version FIX: corrected light placement for vertical form factors (was wrong only by a few pixels so I guess nobody noticed) Improvements: * updated czech translation, thanks to Michal wip 2009-10-12: FIX: fixed flickering of the tooltip on hover, thanks to SteveMcQwark for the hint NEW: option to let the lights be the only hover effect NEW: made text shadow optional (the shadow looks pretty ugly for some plasma themes) Improvements: * force minimum saturation and value (brightness) for hover light color * updated french translation, thanks to Sergio wip 2009-10-11: NEW: made rotation of the task items frame in vertical layouts optional. with some plasma themes it looks better rotated, with others it looks better not rotated. NEW: mouse hover light color is now calculated from the color of the task icon. this is more or less based on Harsh Js code. FIX: fixed a possible crash on exit wip 2009-10-07: updated french translation, thanks to Sergio wip 2009-09-27: FIX: bug where widths of task items weren't scaled FIX: limited squeeze layout: scale rows so that there are no empty rows Improvement: * improved logic for "only group when taskbar is full" wip 2009-09-26: NEW: Michal Odstrčil: option "prefer grouping" (over new rows) FIX: Michal Odstrčil: only group when taksbar is full of new "limited squeeze" (former "maximum squeeze ratio") layout Improvement: * rotate task frames in vertical mode * updated french translation, thanks to Sergio wip 2009-09-21: FIX: fixed hack for tiny taskbars, should fix placement of text on thin taskbars FIX: expansion state update (on desktop change and other state changes) NEW: Michal Odstrčil has written a new and better layout "Maximum Squeeze Ratio". This layout isn't 100% completed yet (Michal is still working on the "only group when taskbar is full" feature) and also the name might change. wip 2009-09-18: FIX: hide tooltip when window is closed Improvement: updated french translation, thanks to Sergio wip 2009-09-16: Improvements: * updated czech translation, thanks to Michal Odstrčil * only squeeze collapsed task items when the expanded ones are already squeezed to the same size, also thanks to Michal Odstrčil wip 2009-09-15: Improvement: updated french translation, thanks to Sergio wip 2009-09-14: NEW: option to enable/disable expand task on hover NEW: activate or iconify whole task groups Improvement: more tool tips in the settings dialog wip 2009-09-13: FIX: typos and bad wording in the tooltip of the taskbar layout combobox Improvements: some code cleanups and refactorings wip 2009-09-12: FIX: right-to-left support was completely broken FIX: drag leave tooltip didn't hide the tooltip FIX: czech locale name is 'cz' Improvements: * always use vertical layout for tooltips when composite is disabled * floatingpoint text layouting (should reduce jumpiness of text) * updated french translation, thanks to Sergio * updated czech translation, thanks to Michal * updated polish translation, thanks to Maciej wip 2009-09-10: FIX: maximum height layout FIX: light effect, thanks to Michal Odstrčil NEW: added czech translation, thanks to Michal Odstrčil Improvement: * added setting for by shape layout to define the row aspect ratio manually * updated hungarian translation, thanks to Zsombor * updated french translation, thanks to Sergio * code cleanups wip 2009-09-09: FIX: fix the plama theme hack, thanks to Michal Odstrčil FIX: also delay item expansion (not only collapse) NEW: several alternative taskbar layouts to choose from. which one is the best? which one can I drop? each one has pros and cons. * By Taskbar Shape: the layout used until now * Maximum Squeeze: uses the task item size like it would need to use the defined maximum rows * Fixed Item Number per Row: uses a fixed definable number of items per row * Fixed Maximum Item Height: never let the task items get bigger than the defined maximum item height NEW: french translation, thanks to Sergio Guibert Improvement: improved the settings dialog wip 2009-09-08: FIX: regression where animation duration for tooltip showing delay was ignored FIX: small fix to polish translation HACK: added hack for plasma themes that define a to large margin wip 2009-09-06: NEW: option to only group items when the taskbar is full NEW: two translations (one string in both is translated using Google however): * hungarian: thanks to Nitai * polish: thanks to Maciej Warnecki FIX: calculation of preferred size (seems still not to be propagated in some cases) FIX: better (diagonal!) tooltip movement, especially for multiple rows or rotated view FIX: fixed bug when dropping task to pager and it gets locked or not removed from the taskbar wip 2009-09-05b: FIX: expansion state/animation of newly added task items wip 2009-09-05a: FIX: added short delay for tooltip switching to fix: * reaching tooltips of task items in lower rows * moving to the tooltip but accidently hovering another task item for a very short time wip 2009-09-05: NEW: multirow support! that was hard for my small brain! NEW: always 'scroll' (move) tooltips when using the wheel NEW: exposing fps setting in UI FIX: fixed crash when using wheel on tooltip (in rare cases) wip 2009-09-02: NEW: more 'smooth' animated manual task sorting. This uses QTimer for the animation because I find Plasma::Animator much to limited to do such an animation. I hope kinetic will be more convenient. FIX: fixed a rare crash. let's hope I didn't introduce a new one. NEW: now you can scroll the text on animated text labels per dragging it. just in case it scrolls to fast/slow for your taste. NEW: implemented scrolling of tooltip on mouse wheel when the preview is outside of the screen. thanks to ssri for noticing this. Improvement: Tooltips should now be a bit better glued to their task items. wip 2009-08-28: NEW: work on i18n and german translation (thanks to xadras for reminding me) wip 2009-08-26: NEW: support for native plasma tooltips and for disabling tooltips all together wip 2009-08-25: Improvements: vertical ordering of tooltip in vertical form factors only show preview area when previews are available (for all those who don't like the previews) better (still not perfect) tooltip movement start position don't collapse tasks when hovering tooltip wip 2009-08-24a: FIX: hopefully fixed another tooltip movement regression wip 2009-08-24: FIX: reworked tooltip movement (still not perfect on short animation duration) FIX: improved tooltip placement, thanks to Michal Odstrčil NEW: implemented D'n'D to tooltips. however, sometimes this gets stuck and I have no idea why. HACK: it seems like the pager does not support drops of task groups so only drop the first task of the group FIX: fixed scrolling over tooltips that didn't work together with normal hovering wip 2009-08-23a: FIX: hopefully fixed tooltip bug which was introduced in the last version wip 2009-08-23: overhaul of animations of the task item (color, frame, expansion) update tooltip move animation when task is expanding mouse wheel to switch through window previews used other border for window previews (is this better or worse?) highlight tooltip task icons on hover use only current screen geometry for tooltip placement fixed annoying off by one pixel bug in tooltip movement added cmake requires for KDE4Workspace wip 2009-08-21: FIX: tooltip stealing on window title change bug wip 2009-08-20: FIX: (ugly) workaround for kwin highlight window effect bug NEW: allow animation duration time in ragne [0, 500] ms. FIX: bug that occurred with duration time = 0 (but possibly also in other corner cases) REMOVED: "Show Border Around Window Previews" options (always show it) wip 2009-08-19: NEW: highlight hovered previews NEW: right click for context menu on previews. for some reason the 'crash on right click' bug disappeared with this change. wip 2009-08-18: Renamed to Smooth Tasks. :) A lot of refactoring (now I'm using namespaces). NEW: close icon is only shown when hovering the corresponding preview NEW: transitions between close icons visual states (hidden, shown, highlighted) are now animated wip 2009-08-17: FIX: hopefully really fixing tooltip placement issues on multihead systems wip 2009-08-16: FIX: probably fixed another rare crash on exit. this occurs when the tooltip is already deleted but the task items aren't (they access the tooltip in their destructor) wip 2009-08-15: FIX: fixed layout spacing Improvements: faster scroll back of the text when stopping hovering delete previews when tooltip is hidden wip 2009-08-14: FIX: tooltips for starting tasks NEW: resize previews when their windows are resized. I don't know if I keep this because under some circumstances (showing grouped tooltips for several automatic and continuous fast resizing windows) this can lock up kwin. wip 2009-08-13: some minor improvements on the code (e.g. removed redundancy a bit) wip 2009-08-12: NEW: scroll text of labels on mouse-hover when the text is to big for the label FIX: correct placement of non-square icons IMPROVEMENT: use KIconEffect for close button highlighting wip 2009-08-11: tiny layout improvement: give text enough room to not crop descenders wip 2009-08-10a: Forgot to add new source files. wip 2009-08-10: FIX: A potential crash on exit (only triggered in rare cases). NEW: New alternative tooltip style. NEW: Made preview size configurable. Visual Improvements: Highlight the close button when hovering. Fadeout long task names in tooltips. wip 2009-08-09: NEW: update tooltip when task is added/removed improved layout made border around previews optional wip 2009-08-08: less flicker when moving between tooltip and same task item NEW: show number of grouped tasks in taskbar item (copied code from KDEs original taskbar plasmoid) NEW: window peeking using kwins highlight window effect NEW: animated scrolling of tooltip when its to big for the screen (move your cursor to the screen edges) NEW: tooltip moves animated when moving mouse over taskbar items KNOWN ISSUE: sometimes when you move the mouse fast over the taskbar items the tooltip contains garbage plasma-widget-smooth-tasks/README000644 000765 000765 00000000375 11724514472 017466 0ustar00salvosalvo000000 000000 Smooth Tasks is a fork of the STasks plasma applet. STasks is written by Marcin Baszczewski Smooth Tasks is written by Mathias Panzenböck Requirements: KDE4 >= 4.3 (might work on KDE 4.2) plasma-widget-smooth-tasks/applet/000755 000765 000765 00000000000 11765222347 020070 5ustar00salvosalvo000000 000000 plasma-widget-smooth-tasks/applet/resources.qrc000644 000765 000765 00000000222 11724514472 022603 0ustar00salvosalvo000000 000000 imgs/classic-style.png imgs/new-style.png plasma-widget-smooth-tasks/applet/SmoothTasks/000755 000765 000765 00000000000 11765222347 022347 5ustar00salvosalvo000000 000000 plasma-widget-smooth-tasks/applet/SmoothTasks/Light.cpp000644 000765 000765 00000010443 11724514472 024122 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Mathias panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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. * ***********************************************************************************/ // Smooth Tasks #include "SmoothTasks/Light.h" #include "SmoothTasks/Applet.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/TaskIcon.h" // Qt #include #include #include #include // Plasma #include #include // KDE #include #include #include // Other #include namespace SmoothTasks { Light::Light(TaskItem *item) : QObject(item) , m_item(item) , m_size(1.0) , m_animation(0) , m_currentAnimation(NoAnimation) {} void Light::paint(QPainter *p, const QRectF& boundingRect, const QPointF& mousePos, bool mouseIn, const bool isRotated) { if (!mouseIn && m_currentAnimation == NoAnimation) { return; } qreal cx = 0.5; qreal cy = 0.5; QColor lightColor(m_item->icon()->highlightColor()); if (mouseIn) { if (isRotated) { cx = 1 - (mousePos.y() - boundingRect.left()) / boundingRect.width(); cy = (mousePos.x() - boundingRect.top() ) / boundingRect.height(); } else { cx = (mousePos.x() - boundingRect.left()) / boundingRect.width(); cy = (mousePos.y() - boundingRect.top() ) / boundingRect.height(); } } const LightAnchorConfig& anchorConfig = m_item->applet()->lightAnchorConfig(); if (anchorConfig.isAnchoredHorizontally()) cx = 0.01 * (qreal) anchorConfig.anchorHorizontal(); if (anchorConfig.isAnchoredVertically()) cy = 0.01 * (qreal) (100 - anchorConfig.anchorVertical()); QRadialGradient gradient(cx, cy, m_size); gradient.setCoordinateMode(QRadialGradient::ObjectBoundingMode); lightColor.setAlpha(200); gradient.setColorAt(0.0, lightColor); lightColor.setAlpha(60); gradient.setColorAt(0.6, lightColor); lightColor.setAlpha(0); gradient.setColorAt(1.0, lightColor); p->fillRect(boundingRect, gradient); } void Light::startAnimation(AnimationType animation, int duration, int loopCout) { delete m_animation; QPropertyAnimation* start = new QPropertyAnimation(this, "size", this); start->setEasingCurve(QEasingCurve::InOutSine); start->setDuration(0.5 * duration); start->setStartValue(0.00001); // QRadialGradient does not like a radius of 0 start->setEndValue(1.0); QPropertyAnimation* down = new QPropertyAnimation(this, "size", this); down->setEasingCurve(QEasingCurve::InOutSine); down->setDuration(0.5 * duration); down->setStartValue(1.0); down->setEndValue(0.5); QPropertyAnimation* up = new QPropertyAnimation(this, "size", this); up->setEasingCurve(QEasingCurve::InOutSine); up->setDuration(0.5 * duration); up->setStartValue(0.5); up->setEndValue(1.0); QSequentialAnimationGroup* loop = new QSequentialAnimationGroup(this); loop->addAnimation(down); loop->addAnimation(up); loop->setLoopCount(loopCout); QSequentialAnimationGroup* all = new QSequentialAnimationGroup(this); all->addAnimation(start); all->addAnimation(loop); m_animation = all; m_animation->start(QAbstractAnimation::DeleteWhenStopped); m_currentAnimation = animation; } void Light::stopAnimation() { delete m_animation; m_animation = 0; m_currentAnimation = NoAnimation; setSize(1.0); } void Light::setSize(qreal size) { m_size = size; emit update(); } } // namespace SmoothTasks #include "Light.moc" plasma-widget-smooth-tasks/applet/SmoothTasks/ByShapeTaskbarLayout.h000644 000765 000765 00000003550 11724514472 026562 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009 Toni Dietze * * 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 SMOOTHTASKS_DEFAULTTASKBARLAYOUT_H #define SMOOTHTASKS_DEFAULTTASKBARLAYOUT_H #include "SmoothTasks/TaskbarLayout.h" namespace SmoothTasks { class ByShapeTaskbarLayout : public TaskbarLayout { Q_OBJECT Q_PROPERTY(qreal rowAspectRatio READ rowAspectRatio WRITE setRowAspectRatio) public: ByShapeTaskbarLayout( qreal rowAspectRatio, Qt::Orientation orientation = Qt::Horizontal, QGraphicsLayoutItem *parent = NULL) : TaskbarLayout(orientation, parent), m_rowAspectRatio(rowAspectRatio) {} virtual TaskbarLayoutType type() const { return ByShape; } virtual int optimumCapacity() const; qreal rowAspectRatio() const { return m_rowAspectRatio; } void setRowAspectRatio(qreal rowAspectRatio); protected: virtual void updateLayoutStatic(); private: qreal m_rowAspectRatio; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/MaxSqueezeTaskbarLayout.cpp000644 000765 000765 00000006743 11724514472 027660 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 "SmoothTasks/MaxSqueezeTaskbarLayout.h" #include #include namespace SmoothTasks { int MaxSqueezeTaskbarLayout::optimumCapacity() const { const QRectF effectiveRect(effectiveGeometry()); const bool isVertical = orientation() == Qt::Vertical; const qreal availableHeight = isVertical ? effectiveRect.width() : effectiveRect.height(); const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal spacing = this->spacing(); const qreal cellHeight = ((availableHeight + spacing) / ((qreal) maximumRows())) - spacing; const qreal cellWidth = cellHeight; const qreal additionalWidth = 0; // TODO: value from TaskbarLayout::additionalWidth() in the past const int itemsPerRow = std::ceil((availableWidth + spacing) / (cellWidth + additionalWidth + spacing)); return itemsPerRow * maximumRows(); } void MaxSqueezeTaskbarLayout::updateLayoutStatic() { // I think this way the loops can be optimized by the compiler. // (lifting out the comparison and making two loops; TODO: find out whether this is true): const bool isVertical = orientation() == Qt::Vertical; const QList& items = this->items(); const int N = items.size(); QRectF effectiveRect(effectiveGeometry()); const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal availableHeight = isVertical ? effectiveRect.width() : effectiveRect.height(); const qreal spacing = this->spacing(); #define CELL_HEIGHT(ROWS) (((availableHeight + spacing) / ((qreal) (ROWS))) - spacing) // if there is nothing to layout fill in some dummy data and leave if (N == 0) { m_rows = minimumRows(); m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos.clear(); return; } const qreal additionalWidth = 0; // TODO: value from TaskbarLayout::additionalWidth() in the past // reduce the number of rows until there are no empty rows // (or rows == m_minimumRows) int itemsPerRow = N; int rows = maximumRows(); qreal cellHeight = CELL_HEIGHT(rows); qreal cellWidth = cellHeight; itemsPerRow = std::ceil((availableWidth + spacing) / (cellWidth + additionalWidth + spacing)); if (itemsPerRow * rows < N) { itemsPerRow = std::ceil(((qreal) N) / rows); } QList rowInfos; buildRows(itemsPerRow, rowInfos, rows); m_rows = rows; m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos = rowInfos; updateItemsRowCache(); #undef CELL_HEIGHT } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/FixedItemCountTaskbarLayout.h000644 000765 000765 00000003533 11724514472 030117 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009 Toni Dietze * * 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 SMOOTHTASKS_FIXEDITEMCOUNTTASKBARLAYOUT_H #define SMOOTHTASKS_FIXEDITEMCOUNTTASKBARLAYOUT_H #include "SmoothTasks/TaskbarLayout.h" namespace SmoothTasks { class FixedItemCountTaskbarLayout : public TaskbarLayout { Q_OBJECT Q_PROPERTY(int itemsPerRow READ itemsPerRow WRITE setItemsPerRow) public: FixedItemCountTaskbarLayout( int itemsPerRow, Qt::Orientation orientation = Qt::Horizontal, QGraphicsLayoutItem *parent = NULL) : TaskbarLayout(orientation, parent), m_itemsPerRow(itemsPerRow) {} int itemsPerRow() const { return m_itemsPerRow; } void setItemsPerRow(int itemsPerRow); virtual TaskbarLayoutType type() const { return FixedItemCount; } virtual int optimumCapacity() const; protected: virtual void updateLayoutStatic(); private: int m_itemsPerRow; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/Applet.h000644 000765 000765 00000021267 11724514472 023753 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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 SMOOTHTASKS_APPLET_H #define SMOOTHTASKS_APPLET_H // Ui #include "ui_General.h" #include "ui_Appearance.h" #include "ui_Workarounds.h" // Qt #include #include #include // Plasma #include #include #include // KDE #include // Taskmanager #include #include #include #include #include #include #include #include "LightAnchorConfig.h" class QGraphicsLinearLayout; using TaskManager::AbstractGroupableItem; using TaskManager::LauncherItem; namespace Plasma { class FrameSvg; } namespace TaskManager { class GroupManager; } namespace SmoothTasks { class Task; class TaskbuttonFrameSvg; class TaskItem; class ToolTipBase; class TaskbarLayout; class GroupManager; class Applet : public Plasma::Applet { Q_OBJECT public: enum ExpandType { ExpandNone = 0, ExpandActive = 1, ExpandCurrentDesktop = 2, ExpandAll = 3 }; enum PreviewLayoutType { ClassicPreviewLayout = 0, NewPreviewLayout = 1 }; enum MiddleClickAction { NoAction = 0, CloseTask = 1, MoveToCurrentDesktop = 2 }; Applet(QObject *parent, const QVariantList &args); ~Applet(); void init(); void dropEvent(QGraphicsSceneDragDropEvent *event); void dragMoveEvent(const QPointF& pos); //config TaskManager::GroupManager::TaskGroupingStrategy groupingStrategy() { return m_groupingStrategy; } TaskManager::GroupManager::TaskSortingStrategy sortingStrategy() { return m_sortingStrategy; } bool isPopupShowing() const; bool lights() const { return m_lights; } bool expandTasks() const { return m_expandTasks; } ExpandType keepExpanded() const { return m_keepExpanded; } bool expandOnHover() const { return m_expandOnHover; } bool expandOnAttention() const { return m_expandOnAttention; } qreal expandedWidth() const { return m_expandedWidth; } qreal minIconSpace() const { return m_minIconSpace; } qreal minButtonWidth() const { return m_minButtonWidth; } qreal maxButtonWidth() const { return m_maxButtonWidth; } QColor lightColor() const { return m_lightColor; } const LightAnchorConfig& lightAnchorConfig() const { return m_lightAnchorConfig; }; double iconScale() const { return (double) m_iconScale / 100.0; } int animationDuration() const; int fps() const; ToolTipBase *toolTip() { return m_toolTip; } TaskManager::GroupManager *groupManager() { return m_groupManager; } TaskbuttonFrameSvg *frame() { return m_frame; } const TaskbuttonFrameSvg *frame() const { return m_frame; } QRect currentScreenGeometry() const; QRect virtualScreenGeometry() const; PreviewLayoutType previewLayout() const { return m_previewLayout; } int maximumPreviewSize() const { return m_maxPreviewSize; } int toolTipMoveDuraton() const { return m_tooltipMoveDuration; } int highlightDelay() const { return m_highlightDelay; } bool hideTooltipAfterClick() const { return m_hideTooltipAfterClick; } bool dontRotateFrame() const { return m_dontRotateFrame; } bool onlyLights() const { return m_onlyLights; } bool textShadow() const { return m_textShadow; } bool lightColorFromIcon() const { return m_lightColorFromIcon; } MiddleClickAction middleClickAction() const { return m_middleClickAction; } void dragItem(TaskItem *item, QGraphicsSceneMouseEvent *event); void dragTask(TaskManager::AbstractGroupableItem* task, QWidget *source); void middleClickTask(TaskManager::AbstractGroupableItem* task); void popup(const QPoint& pos, Task *task, QObject *receiver, const char *slot); void popup(const TaskItem* item); void dumpItems(); private: void reloadItems(); void connectRootGroup(); void disconnectRootGroup(); TaskManager::BasicMenu *popup(Task *task); // other TaskbuttonFrameSvg *m_frame; TaskManager::GroupManager *m_groupManager; QWeakPointer m_rootGroup; ToolTipBase *m_toolTip; TaskbarLayout *m_layout; QHash m_tasksHash; Ui::General m_configG; Ui::Appearance m_configA; Ui::Workarounds m_configW; void clear(); void constraintsEvent(Plasma::Constraints constraints); int totalSubTasks(); TaskManager::AbstractGroupableItem *selectSubTask(int index); int activeIndex(); // task TaskManager::GroupManager::TaskGroupingStrategy m_groupingStrategy; TaskManager::GroupManager::TaskSortingStrategy m_sortingStrategy; // config int m_taskSpacing; int m_iconScale; bool m_lights; int m_expandTasks; ExpandType m_keepExpanded; bool m_expandOnHover; bool m_expandOnAttention; qreal m_expandedWidth; qreal m_minIconSpace; qreal m_minButtonWidth; qreal m_maxButtonWidth; QColor m_lightColor; LightAnchorConfig m_lightAnchorConfig; int m_activeIconIndex; PreviewLayoutType m_previewLayout; MiddleClickAction m_middleClickAction; int m_maxPreviewSize; int m_tooltipMoveDuration; int m_highlightDelay; bool m_hideTooltipAfterClick; int m_itemsPerRow; qreal m_squeezeRatio; bool m_preferGrouping; int m_itemHeight; qreal m_rowAspectRatio; bool m_dontRotateFrame; bool m_onlyLights; bool m_textShadow; bool m_lightColorFromIcon; bool m_scrollSwitchTasks; protected: void createConfigurationInterface(KConfigDialog *parent); QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const; void wheelEvent(QGraphicsSceneWheelEvent *event); void hoverEnterEvent(QGraphicsSceneHoverEvent *event); void dragEnterEvent(QGraphicsSceneDragDropEvent *event); void dragMoveEvent(QGraphicsSceneDragDropEvent *event); void dragLeaveEvent(QGraphicsSceneDragDropEvent *event); public slots: virtual void configChanged(); void updateActiveIconIndex(TaskItem *item); void reload(); private slots: void updateFullLimit(); void widgetValueChanged(); void loadDefaults(); void itemAdded(AbstractGroupableItem *groupableItem); void itemRemoved(AbstractGroupableItem *groupableItem); void itemPositionChanged(AbstractGroupableItem *groupableItem); void currentDesktopChanged(); void uiToolTipKindChanged(int index); void uiTaskbarLayoutChanged(int index); void uiMinimumRowsChanged(int minimumRows); void uiMaximumRowsChanged(int maximumRows); void uiMinButtonWidthChanged(int minButtonWidth); void uiMaxButtonWidthChanged(int maxButtonWidth); void uiGroupingStrategyChanged(int index); void newNotification(const QString& notif); protected slots: void configAccepted(); signals: void settingsChanged(); void previewLayoutChanged(Applet::PreviewLayoutType previewLayout); void mouseEnter(); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/DelayedToolTip.cpp000644 000765 000765 00000006575 11724514472 025750 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 "SmoothTasks/DelayedToolTip.h" #include "SmoothTasks/Applet.h" namespace SmoothTasks { DelayedToolTip::DelayedToolTip(Applet *applet) : ToolTipBase(applet), m_delayTimer(new QTimer(this)), m_action(NoAction), m_newHoverItem(NULL) { m_delayTimer->setSingleShot(true); connect( m_delayTimer, SIGNAL(timeout()), this, SLOT(timeout())); } void DelayedToolTip::quickShow(TaskItem *item) { ToolTipBase::quickShow(item); m_action = NoAction; m_newHoverItem = NULL; if (m_delayTimer->isActive()) { m_delayTimer->stop(); } showAction(false); } void DelayedToolTip::hide() { m_action = NoAction; if (m_delayTimer->isActive()) { m_delayTimer->stop(); } ToolTipBase::hide(); m_newHoverItem = NULL; } void DelayedToolTip::itemEnter(TaskItem *item) { if (m_newHoverItem == item && ((m_delayTimer->isActive() && m_action == ShowAction) || m_action == NoAction)) { // do nothing when already delaying the hover or already hovering of the given item return; } if (m_delayTimer->isActive()) { m_delayTimer->stop(); } int duration; if (m_shown) { duration = 150; } else { duration = m_applet->animationDuration(); } m_action = ShowAction; m_newHoverItem = item; m_delayTimer->start(duration); } void DelayedToolTip::itemLeave(TaskItem *item) { if (m_hoverItem == item || m_newHoverItem == item) { if (m_delayTimer->isActive()) { m_delayTimer->stop(); m_action = NoAction; } if (m_shown) { m_action = HideAction; m_delayTimer->start(m_applet->animationDuration()); } else if (!m_hoverItem.isNull()) { m_hoverItem->confirmLeave(); } } if (m_newHoverItem == item) { m_newHoverItem = NULL; if (m_action == ShowAction) { m_action = NoAction; m_delayTimer->stop(); } } } void DelayedToolTip::itemDelete(TaskItem *item) { if (m_hoverItem == item) { if (m_delayTimer->isActive()) { m_delayTimer->stop(); m_action = NoAction; } hide(); } } void DelayedToolTip::timeout() { switch (m_action) { case ShowAction: if (!m_newHoverItem.isNull() && !(m_shown && m_hoverItem == m_newHoverItem)) { bool wasShown = m_shown; if (!m_hoverItem.isNull()) { m_hoverItem->confirmLeave(); } m_hoverItem = m_newHoverItem; m_shown = true; m_hoverItem->confirmEnter(); showAction(wasShown); } break; case HideAction: hideAction(); default: break; } m_action = NoAction; } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/WindowPreview.cpp000644 000765 000765 00000040747 11724514472 025676 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2010, 2012 Toni Dietze * * 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 "SmoothTasks/Animation/AnimationVariant.h" #include "SmoothTasks/WindowPreview.h" #include "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/CloseIcon.h" #include "SmoothTasks/Task.h" #include "SmoothTasks/Global.h" // Qt #include #include #include #include // KDE #include #include #include #include // taskmanager #include #include #include #include #include #include namespace SmoothTasks { const QSize WindowPreview::BIG_ICON_SIZE(48, 48); const QSize WindowPreview::SMALL_ICON_SIZE(16, 16); WindowPreview::WindowPreview ( TaskManager::TaskItem *task , int index , SmoothToolTip *toolTip ) : QWidget() , m_background(new Plasma::FrameSvg(this)) , m_iconSpace(NULL) , m_previewSpace(NULL) , m_highlight(new AnimationVariant(this)) , m_task(new Task(task, this)) , m_toolTip(toolTip) , m_previewSize(0, 0) , m_hover(false) , m_index(index) , m_activateTimer(NULL) , m_didPress(false) , m_dragStartPosition() { setMouseTracking(true); setAcceptDrops(true); // m_background->setImagePath("widgets/button"); m_background->setImagePath("widgets/tasks"); m_background->setElementPrefix(NORMAL); m_background->setCacheAllRenderedFrames(true); setPreviewSize(); // placeholder for preview: if (toolTip->previewsAvailable()) { m_previewSpace = new QSpacerItem( 0, 0, QSizePolicy::Minimum, QSizePolicy::Minimum); } switch (m_toolTip->applet()->previewLayout()) { case Applet::NewPreviewLayout: setNewLayout(); break; case Applet::ClassicPreviewLayout: default: setClassicLayout(); } setMaximumWidth(260); updateTheme(); connect(m_background, SIGNAL(repaintNeeded()), this, SLOT(updateTheme())); connect( task, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(updateTask(::TaskManager::TaskChanges))); m_highlight->setStartValue(qreal(0.0)); m_highlight->setEndValue(qreal(1.0)); connect(m_highlight, SIGNAL(valueChanged(QVariant)), this, SLOT(update())); } WindowPreview::~WindowPreview() { if (m_activateTimer) { m_activateTimer->stop(); delete m_activateTimer; m_activateTimer = NULL; } } void WindowPreview::setPreviewSize() { if (m_toolTip->previewsAvailable()) { // determine preview size: WId wid = 0; TaskManager::Task* task = m_task->task(); if (task) { wid = task->window(); } if (wid && m_task->type() != Task::StartupItem && m_task->type() != Task::LauncherItem) { m_previewSize = KWindowSystem::windowInfo(wid, NET::WMGeometry | NET::WMFrameExtents).frameGeometry().size(); } else { m_previewSize = m_task->icon().pixmap(BIG_ICON_SIZE).size(); } } else { m_previewSize = QSize(0, 0); } if (m_previewSize.isValid()) { int maxSize = m_toolTip->applet()->maximumPreviewSize(); if (m_previewSize.width() > maxSize || m_previewSize.height() > maxSize) { m_previewSize.scale(maxSize, maxSize, Qt::KeepAspectRatio); } } } void WindowPreview::updateTask(::TaskManager::TaskChanges changes) { bool doUpdate = false; QSize oldSize = size(); if (changes & TaskManager::IconChanged) { const KIcon icon(m_task->icon()); if (m_toolTip->previewsAvailable() && (m_task->type() == Task::StartupItem || m_task->type() == Task::LauncherItem)) { m_previewSize = icon.pixmap(BIG_ICON_SIZE).size(); } switch (m_toolTip->applet()->previewLayout()) { case Applet::NewPreviewLayout: m_icon = icon.pixmap(BIG_ICON_SIZE); break; case Applet::ClassicPreviewLayout: default: m_icon = icon.pixmap(SMALL_ICON_SIZE); } doUpdate = true; } if (changes & TaskManager::NameChanged) { m_taskNameLabel->setText(m_task->text()); doUpdate = true; } if (changes & TaskManager::GeometryChanged) { setPreviewSize(); doUpdate = true; } if (changes & TaskManager::NameChanged) { m_taskNameLabel->setText(m_task->text()); doUpdate = true; } if (doUpdate) { updateTheme(); if (size() != oldSize) { emit sizeChanged(); } } } void WindowPreview::setClassicLayout() { QGridLayout *layout = new QGridLayout; layout->setSpacing(3); layout->setContentsMargins(0, 0, 0, 0); setLayout(layout); // task icon: m_iconSpace = new QSpacerItem( 20, 20, QSizePolicy::Fixed, QSizePolicy::Fixed); m_icon = m_task->icon().pixmap(16, 16); layout->addItem(m_iconSpace, 0, 0, 1, 1); // task name: m_taskNameLabel = new FadedText(m_task->text(), this); m_taskNameLabel->setShadow(m_toolTip->applet()->textShadow()); m_taskNameLabel->setMouseTracking(true); m_taskNameLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum); layout->addWidget(m_taskNameLabel, 0, 1, 1, 1); if(m_task->type() != Task::LauncherItem) { // no window preview or close icon for launcher item // close icon: CloseIcon *iconClose = new CloseIcon(this); iconClose->setMouseTracking(true); iconClose->setFixedSize(20, 20); layout->addWidget(iconClose, 0, 2, 1, 1); } // placeholder for preview: if (m_previewSpace) { layout->addItem(m_previewSpace, 1, 0, 1, 3); layout->setRowStretch(1, 100); } } void WindowPreview::setNewLayout() { QGridLayout *layout = new QGridLayout; layout->setSpacing(3); layout->setContentsMargins(8, 8, 8, 8); setLayout(layout); layout->setColumnStretch(1, 100); // placeholder for preview: if (m_previewSpace) { layout->addItem(m_previewSpace, 0, 0, 1, 2); layout->setRowStretch(0, 100); } if(m_task->type() != Task::LauncherItem) { // no window preview or close icon for launcher item // close icon: CloseIcon *iconClose = new CloseIcon(this); iconClose->setMouseTracking(true); iconClose->setFixedSize(20, 20); if(m_previewSpace) { layout->addWidget(iconClose, 0, 2, 1, 1, Qt::AlignTop | Qt::AlignRight); } else { layout->addWidget(iconClose, 0, 3, 1, 1, Qt::AlignTop | Qt::AlignRight); } } // task icon: m_iconSpace = new QSpacerItem( 52, 52, QSizePolicy::Fixed, QSizePolicy::Fixed); m_icon = m_task->icon().pixmap(BIG_ICON_SIZE); if(m_previewSpace) { layout->addItem(m_iconSpace, 1, 0, 2, 1, Qt::AlignCenter); } else { layout->addItem(m_iconSpace, 0, 0, 2, 1, Qt::AlignCenter); } // task name: m_taskNameLabel = new FadedText(m_task->text(), this); m_taskNameLabel->setShadow(m_toolTip->applet()->textShadow()); QFont font(m_taskNameLabel->font()); font.setBold(true); m_taskNameLabel->setMouseTracking(true); m_taskNameLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum); m_taskNameLabel->setFont(font); if(m_previewSpace) { layout->addWidget(m_taskNameLabel, 1, 1, 1, 2); } else { layout->addWidget(m_taskNameLabel, 0, 1, 1, 2); } // task desktop: FadedText *desktopLabel = new FadedText(m_task->description()); desktopLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum); desktopLabel->setShadow(m_toolTip->applet()->textShadow()); desktopLabel->setWrapMode(QTextOption::WordWrap); desktopLabel->setMouseTracking(true); desktopLabel->setMaximumWidth(160); if(m_previewSpace) { layout->addWidget(desktopLabel, 2, 1, 1, 2, Qt::AlignTop); } else { layout->addWidget(desktopLabel, 1, 1, 1, 2, Qt::AlignTop); } } void WindowPreview::highlightTask() { TaskManager::Task* task = m_task->task(); if (task) { m_toolTip->highlightTask(task->window()); } } QRect WindowPreview::previewRect(int x, int y) const { if (m_previewSpace) { QRect spaceGeom(m_previewSpace->geometry()); QRect rect( x + spaceGeom.left() + (spaceGeom.width() - m_previewSize.width()) / 2, y + spaceGeom.top() + (spaceGeom.height() - m_previewSize.height()) / 2, m_previewSize.width(), m_previewSize.height()); return rect; } else { return QRect(); } } void WindowPreview::leftClickTask() { if (m_toolTip->applet()->hideTooltipAfterClick() || !m_task->task()) { m_highlight->stop(); m_highlight->setCurrentTime(0); m_toolTip->hide(); } if(m_task->type() != Task::LauncherItem) { TaskManager::Task* task = m_task->task(); if (task) { if (m_toolTip->applet()->hideTooltipAfterClick() || !task->isActive()) task->activate(); else task->setIconified(true); } else { qWarning("WindowPreview::activateTask: Bug: the task is gone but the task item is still here!"); } } } void WindowPreview::activateForDrop() { TaskManager::Task* task = m_task->task(); if (task) { if (task->isMinimized()) { task->restore(); } task->raise(); m_toolTip->hide(); } } void WindowPreview::closeTask() { TaskManager::Task* task = m_task->task(); if (task) { task->close(); } else { qWarning("WindowPreview::closeTask: Bug: the task is gone but the task item is still here!"); m_toolTip->applet()->reload(); } } QPixmap WindowPreview::hoverIcon() const { KIconEffect *effect = KIconLoader::global()->iconEffect(); if (effect->hasEffect(KIconLoader::Desktop, KIconLoader::ActiveState)) { return effect->apply( m_icon, KIconLoader::Desktop, KIconLoader::ActiveState); } else { return m_icon; } } void WindowPreview::paintEvent(QPaintEvent *event) { Q_UNUSED(event) QPainter painter(this); const qreal currentHighlight = m_highlight->currentValue().toReal(); // draw background (only when previews are used) if (m_previewSpace) { QPixmap backgroundPixmap; qreal normalLeft = 0, normalTop = 0, normalRight = 0, normalBottom = 0; // caching of the pixmap is done by the class FrameSvg m_background->setElementPrefix(NORMAL); m_background->getMargins(normalLeft, normalTop, normalRight, normalBottom); if (qFuzzyCompare(currentHighlight, qreal(0.0))) { backgroundPixmap = m_background->framePixmap(); } else if (qFuzzyCompare(currentHighlight, qreal(1.0))) { m_background->setElementPrefix(HOVER); backgroundPixmap = m_background->framePixmap(); } else { QPixmap normal(m_background->framePixmap()); m_background->setElementPrefix(HOVER); QPixmap hover(m_background->framePixmap()); backgroundPixmap = Plasma::PaintUtils::transition(normal, hover, currentHighlight); } QRect spaceGeom(m_previewSpace->geometry()); QPoint backgroundPos( spaceGeom.left() + (spaceGeom.width() - m_previewSize.width()) / 2 - normalLeft, spaceGeom.top() + (spaceGeom.height() - m_previewSize.height()) / 2 - normalTop); painter.drawPixmap(backgroundPos, backgroundPixmap); // draw icon as fake preview for startup items if (m_task->type() == Task::StartupItem) { painter.drawPixmap(previewRect(0, 0), m_task->icon().pixmap(BIG_ICON_SIZE)); } } // draw icon QPixmap iconPixmap; QRect iconGeom(m_iconSpace->geometry()); QPointF iconPos( iconGeom.left() + (iconGeom.width() - m_icon.width()) * 0.5, iconGeom.top() + (iconGeom.height() - m_icon.height()) * 0.5); if (qFuzzyCompare(currentHighlight, qreal(0.0))) { iconPixmap = m_icon; } else if (qFuzzyCompare(currentHighlight, qreal(1.0))) { iconPixmap = hoverIcon(); } else { iconPixmap = Plasma::PaintUtils::transition(m_icon, hoverIcon(), currentHighlight); } painter.drawPixmap(iconPos, iconPixmap); } void WindowPreview::enterEvent(QEvent *event) { Q_UNUSED(event) hoverEnter(); } void WindowPreview::leaveEvent(QEvent *event) { Q_UNUSED(event) hoverLeave(); } void WindowPreview::hoverEnter() { m_highlight->setDuration(m_toolTip->applet()->animationDuration()); m_highlight->setDirection(QAbstractAnimation::Forward); m_highlight->start(); m_hover = true; emit enter(this); update(); } void WindowPreview::hoverLeave() { m_highlight->setDuration(m_toolTip->applet()->animationDuration()); m_highlight->setDirection(QAbstractAnimation::Backward); m_highlight->start(); m_hover = false; if (m_activateTimer) { delete m_activateTimer; m_activateTimer = NULL; } emit leave(this); update(); } void WindowPreview::mousePressEvent(QMouseEvent *event) { m_didPress = true; m_dragStartPosition = event->pos(); event->accept(); } /* FIXME: why doesn't this work? void WindowPreview::mouseMoveEvent(QMouseEvent *event) { if (!(event->buttons() & Qt::LeftButton)) { return; } if ((event->pos() - m_dragStartPosition).manhattanLength() < QApplication::startDragDistance()) { return; } //m_didPress = false; event->ignore(); m_toolTip->applet()->dragTask(m_task, this); } */ void WindowPreview::mouseReleaseEvent(QMouseEvent *event) { if (event->x() < 0 || event->y() < 0 || event->x() >= width() || event->y() >= height()) { event->ignore(); } else if (m_didPress) { switch (event->button()) { case Qt::LeftButton: leftClickTask(); break; case Qt::RightButton: m_toolTip->popup(QCursor::pos(), m_task); break; case Qt::MidButton: if (m_task->isValid()) { m_toolTip->applet()->middleClickTask(m_task->abstractItem()); } default: break; } event->accept(); } else { event->ignore(); } m_didPress = false; } void WindowPreview::dragEnterEvent(QDragEnterEvent *event) { hoverEnter(); if (m_activateTimer == NULL) { m_activateTimer = new QTimer(this); m_activateTimer->setSingleShot(true); m_activateTimer->setInterval(DRAG_HOVER_DELAY); connect(m_activateTimer, SIGNAL(timeout()), this, SLOT(activateForDrop())); } m_activateTimer->start(); event->ignore(); } void WindowPreview::dragMoveEvent(QDragMoveEvent *event) { if (m_activateTimer) { m_activateTimer->start(); } event->accept(); } void WindowPreview::dragLeaveEvent(QDragLeaveEvent *event) { hoverLeave(); event->accept(); } void WindowPreview::dropEvent(QDropEvent *event) { if (m_activateTimer) { delete m_activateTimer; m_activateTimer = NULL; } event->accept(); } void WindowPreview::updateTheme() { QLayout *layout = this->layout(); m_background->clearCache(); // frame around preview: qreal hoverLeft = 0, hoverTop = 0, hoverRight = 0, hoverBottom = 0; qreal normalLeft = 0, normalTop = 0, normalRight = 0, normalBottom = 0; m_background->setElementPrefix(HOVER); m_background->getMargins(hoverLeft, hoverTop, hoverRight, hoverBottom); m_background->setElementPrefix(NORMAL); m_background->getMargins(normalLeft, normalTop, normalRight, normalBottom); qreal left = qMax(normalLeft, hoverLeft); qreal top = qMax(normalTop, hoverTop); qreal right = qMax(normalRight, hoverRight); qreal bottom = qMax(normalBottom, hoverBottom); QSizeF normalSize( normalLeft + m_previewSize.width() + normalRight, normalTop + m_previewSize.height() + normalBottom); m_background->setElementPrefix(HOVER); // m_background->resizeFrame(QSizeF( // hoverLeft + m_previewSize.width() + hoverRight, // hoverTop + m_previewSize.height() + hoverBottom)); m_background->resizeFrame(normalSize); m_background->setElementPrefix(NORMAL); m_background->resizeFrame(normalSize); // placeholder for preview: if (m_previewSpace) { m_previewSpace->changeSize( left + m_previewSize.width() + right, top + m_previewSize.height() + bottom, QSizePolicy::Minimum, QSizePolicy::Minimum); m_previewSpace->invalidate(); } layout->invalidate(); layout->activate(); update(); if (KWindowSystem::compositingActive()) { if (m_toolTip->applet()->previewLayout() == Applet::NewPreviewLayout) { m_taskNameLabel->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum); } else { m_taskNameLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); } } else { m_taskNameLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum); } adjustSize(); } qreal WindowPreview::highlight() const { return m_highlight->currentValue().toReal(); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/SmoothToolTip.cpp000644 000765 000765 00000030377 11724514472 025647 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/ToolTipWidget.h" #include "SmoothTasks/WindowPreview.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/Task.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace SmoothTasks { SmoothToolTip::SmoothToolTip(Applet *applet) : DelayedToolTip(applet), m_widget(new ToolTipWidget(this)), m_previews(), m_previewsAvailable(false), m_background(new Plasma::FrameSvg(this)), m_hover(false), m_menuShown(false), m_previewsUpdated(false), m_hoverPreview(NULL), m_highlightDelay(new QTimer(this)), m_highlighting(false), m_scrollAnimation(0), m_closeIcon(), m_hoverCloseIcon() { connect( applet, SIGNAL(mouseEnter()), this, SLOT(stopEffect())); previewLayoutChanged(m_applet->previewLayout()); m_background->setImagePath("widgets/tooltip"); m_background->setEnabledBorders(Plasma::FrameSvg::AllBorders); updateTheme(); m_highlightDelay->setInterval(m_applet->highlightDelay()); m_highlightDelay->setSingleShot(true); connect(m_highlightDelay, SIGNAL(timeout()), this, SLOT(highlightDelayTimeout())); connect(m_background, SIGNAL(repaintNeeded()), this, SLOT(updateTheme())); connect( m_applet, SIGNAL(previewLayoutChanged(Applet::PreviewLayoutType)), this, SLOT(previewLayoutChanged(Applet::PreviewLayoutType))); } SmoothToolTip::~SmoothToolTip() { stopScrollAnimation(); m_widget->hide(); delete m_widget; m_widget = NULL; } void SmoothToolTip::previewLayoutChanged(Applet::PreviewLayoutType previewLayout) { QLayout *layout = m_widget->layout(); switch (previewLayout) { case Applet::NewPreviewLayout: layout->setSpacing(0); break; case Applet::ClassicPreviewLayout: default: layout->setSpacing(3); } layout->activate(); } void SmoothToolTip::showAction(bool animate) { updateToolTip(animate); m_widget->show(); } void SmoothToolTip::itemUpdate(TaskItem *item) { if (item == m_hoverItem && m_shown) { updateToolTip(true); } } void SmoothToolTip::updateToolTip(bool forceAnimated) { m_previewsAvailable = Plasma::WindowEffects::isEffectAvailable( Plasma::WindowEffects::WindowPreview); m_widget->hide(); m_previewsUpdated = false; // m_hover = false; // XXX really? Task *task = m_hoverItem->task(); m_widget->setUpdatesEnabled(false); clear(); switch (task->type()) { case Task::TaskItem: case Task::StartupItem: setTasks(TaskManager::ItemList() << task->taskItem()); break; case Task::GroupItem: setTasks(task->group()->members()); break; case Task::LauncherItem: m_previewsAvailable = false; setTasks(TaskManager::ItemList() << task->launcherItem()); break; default: setTasks(TaskManager::ItemList()); } m_widget->setUpdatesEnabled(true); moveBesideTaskItem(forceAnimated); } void SmoothToolTip::hideAction() { if (!m_hover && !m_menuShown) { hide(); } } void SmoothToolTip::moveBesideTaskItem(bool forceAnimated) { if (m_hoverItem.isNull()) { return; } Plasma::Corona* corona = qobject_cast(m_hoverItem->scene()); if (!corona) { kWarning() << "the following object's scene() is not a Plasma::Corona instance, cannot show tool tip:" << m_hoverItem; return; } QSize newSize(m_widget->frameSize()); QPoint pos = corona->popupPosition(m_hoverItem, newSize, Qt::AlignCenter); if (pos == m_widget->pos()) return; if (forceAnimated || m_scrollAnimation) startScrollAnimation(pos.x() - m_widget->x(), pos.y() - m_widget->y()); else m_widget->move(pos); } void SmoothToolTip::moveTo(WindowPreview *preview, const QPoint& mousePos) { const QRect screenGeom(m_applet->currentScreenGeometry()); const QPoint offset(preview->geometry().center() - mousePos); if (qobject_cast(m_widget->layout())->direction() == QBoxLayout::TopToBottom) { const int screenTop = screenGeom.top(); const int screenBottom = screenTop + screenGeom.height(); const int top = m_widget->y() + preview->y() - offset.y(); const int bottom = top + preview->height(); if (top < screenTop) { startScrollAnimation(0, screenTop - top - offset.y()); } else if (bottom > screenBottom) { startScrollAnimation(0, screenBottom - bottom - offset.y()); } else { startScrollAnimation(0, -offset.y()); } } else { const int screenLeft = screenGeom.left(); const int screenRight = screenLeft + screenGeom.width(); const int left = m_widget->x() + preview->x() - offset.x(); const int right = left + preview->width(); if (left < screenLeft) { startScrollAnimation(screenLeft - left - offset.x(), 0); } else if (right > screenRight) { startScrollAnimation(screenRight - right - offset.x(), 0); } else { startScrollAnimation(-offset.x(), 0); } } } void SmoothToolTip::startScrollAnimation(int dx, int dy) { if (!m_scrollAnimation) m_scrollAnimation = new AnimationThrowPoint(m_widget, "pos", this); else m_scrollAnimation->setTargetObject(m_widget); m_scrollAnimation->setAcceleration(2000.0); // TODO: make variable m_scrollAnimation->setStartValue(m_widget->pos()); m_scrollAnimation->setEndValue(m_widget->pos() + QPoint(dx, dy)); m_scrollAnimation->start(QAbstractAnimation::DeleteWhenStopped); } void SmoothToolTip::stopScrollAnimation() { delete m_scrollAnimation; m_scrollAnimation = 0; } void SmoothToolTip::leave() { m_hover = false; m_hoverPreview = NULL; itemLeave(m_hoverItem); } void SmoothToolTip::enterWindowPreview(WindowPreview *preview) { if (m_hoverPreview != NULL) { m_hoverPreview->hoverLeave(); } if (m_hoverPreview != preview) { m_hoverPreview = preview; if (m_highlighting) { highlightDelayTimeout(); } else { m_highlightDelay->start(m_applet->highlightDelay()); } } } void SmoothToolTip::leaveWindowPreview(WindowPreview *preview) { if (m_hoverPreview == preview) { m_hoverPreview = NULL; m_highlightDelay->stop(); } } void SmoothToolTip::highlightDelayTimeout() { if (m_hoverPreview != NULL) { m_hoverPreview->highlightTask(); } } void SmoothToolTip::stopEffect() { Plasma::WindowEffects::highlightWindows( m_widget->winId(), QList()); m_highlighting = false; } void SmoothToolTip::clear() { stopScrollAnimation(); Plasma::WindowEffects::showWindowThumbnails(m_widget->winId()); m_hoverPreview = NULL; QBoxLayout *layout = qobject_cast(m_widget->layout()); foreach (WindowPreview* preview, m_previews) { preview->hide(); layout->removeWidget(preview); delete preview; } m_previews.clear(); } bool SmoothToolTip::isVertical() const { return m_applet->formFactor() == Plasma::Vertical || !KWindowSystem::compositingActive(); } void SmoothToolTip::setTasks(TaskManager::ItemList tasks) { QSize oldSize = m_widget->size(); QBoxLayout *layout = qobject_cast(m_widget->layout()); const int N = tasks.count(); int actualWidth = 0; int actualHeight = 0; layout->setDirection(isVertical() ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight); for (int i = 0; i < N; ++ i) { TaskManager::TaskItem *task = static_cast(tasks.at(i)); if (task == NULL) { continue; } WindowPreview *preview = new WindowPreview(task, i, this); actualWidth += preview->width(); if (actualHeight < preview->height()) { actualHeight = preview->height(); } layout->addWidget(preview); connect( preview, SIGNAL(sizeChanged()), this, SLOT(previewWindowSizeChanged())); connect( preview, SIGNAL(enter(WindowPreview*)), this, SLOT(enterWindowPreview(WindowPreview*))); connect( preview, SIGNAL(leave(WindowPreview*)), this, SLOT(leaveWindowPreview(WindowPreview*))); m_previews.append(preview); } // layout->update(); layout->activate(); m_widget->adjustSize(); m_previewsUpdated = false; // correct position of resized tooltip to prevent overlapping with m_widget QSize newSize = m_widget->size(); if (oldSize != newSize) { Plasma::Direction direction = Plasma::Up; Plasma::Containment* c = dynamic_cast(m_hoverItem->topLevelItem()); if (c) direction = Plasma::locationToDirection(c->location()); int deltaX = oldSize.width () - newSize.width (); int deltaY = oldSize.height() - newSize.height(); switch (direction) { case Plasma::Down : deltaY = 0; case Plasma::Up : deltaX /= 2; break; case Plasma::Right: deltaX = 0; case Plasma::Left : deltaY /= 2; break; } m_widget->move(m_widget->x() + deltaX, m_widget->y() + deltaY); } } void SmoothToolTip::previewWindowSizeChanged() { if (m_hoverItem.isNull()) { kDebug() << "previewWindowSizeChanged() but no m_hoverItem"; } else { moveBesideTaskItem(m_shown); } m_previewsUpdated = false; updatePreviews(); } void SmoothToolTip::updatePreviews() { if (!m_previewsAvailable || m_previewsUpdated) { return; } m_previewsUpdated = true; m_widget->layout()->activate(); QList winIds; QList rects; foreach (WindowPreview *preview, m_previews) { preview->show(); TaskManager::Task* task = preview->task()->task(); if (task && preview->task()->type() != Task::StartupItem && preview->task()->type() != Task::LauncherItem) { winIds.append(task->window()); rects.append(preview->previewRect(preview->pos())); } } Plasma::WindowEffects::showWindowThumbnails(m_widget->winId(), winIds, rects); } void SmoothToolTip::hide() { m_widget->hide(); m_previewsUpdated = false; m_hover = false; clear(); DelayedToolTip::hide(); } void SmoothToolTip::updateTheme() { m_background->clearCache(); m_widget->layout()->setContentsMargins( m_background->marginSize(Plasma::LeftMargin), m_background->marginSize(Plasma::TopMargin), m_background->marginSize(Plasma::RightMargin), m_background->marginSize(Plasma::BottomMargin)); QPalette plasmaPalette = QPalette(); plasmaPalette.setColor( QPalette::Window, Plasma::Theme::defaultTheme()->color(Plasma::Theme::BackgroundColor)); plasmaPalette.setColor( QPalette::WindowText, Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor)); m_widget->setAutoFillBackground(true); m_widget->setPalette(plasmaPalette); m_closeIcon = KIcon("dialog-close").pixmap(16, 16); KIconEffect *effect = KIconLoader::global()->iconEffect(); if (effect->hasEffect(KIconLoader::Desktop, KIconLoader::ActiveState)) { m_hoverCloseIcon = effect->apply( m_closeIcon, KIconLoader::Desktop, KIconLoader::ActiveState); } m_widget->update(); } void SmoothToolTip::popup(const QPoint& point, Task *task) { m_menuShown = true; m_applet->popup(point, task, this, SLOT(popupMenuAboutToHide())); } void SmoothToolTip::popupMenuAboutToHide() { m_menuShown = false; m_hover = m_widget->geometry().contains(QCursor::pos()); if (!m_hover) { itemLeave(m_hoverItem); } } void SmoothToolTip::highlightTask(WId winId) { QList winIds; winIds << m_applet->view()->winId() << m_widget->winId() << winId; Plasma::WindowEffects::highlightWindows( m_widget->winId(), winIds); m_highlighting = true; } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/TaskStateAnimation.h000644 000765 000765 00000005210 11724514472 026257 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_TASKSTATEANIMATION_H #define SMOOTHTASKS_TASKSTATEANIMATION_H #include namespace SmoothTasks { class TaskStateAnimation : public QObject { Q_OBJECT public: TaskStateAnimation(); enum StateFlag { Normal = 0, Hover = 1, Minimized = 2, Attention = 4, Focus = 8, Launcher = 16 }; // animation progresses: qreal hover() const { return m_hover; } qreal minimized() const { return m_minimized; } qreal attention() const { return m_attention; } qreal focus() const { return m_focus; } int fromState() const { return m_fromState; } int toState() const { return m_toState; } int animatedState() const { return m_fromState ^ m_toState; } int animatedToState() const { return (m_fromState ^ m_toState) & m_toState; } int animatedFromState() const { return (m_fromState ^ m_toState) & m_fromState; } int reachedUpState() const { return m_fromState & m_toState; } int reachedDownState() const { return ~m_fromState & ~m_toState; } int reachedState() const { return ~(m_fromState ^ m_toState); } int shownState() const { return m_fromState | m_toState; } int hiddenState() const { return ~(m_fromState | m_toState); } bool isActive() const { return m_animation != 0; } public slots: void setState(int state, int fps, int duration); private slots: void animate(qreal progress); void animationFinished(int animation); private: void stop(); void start(int fps, int duration); signals: void update(); private: int m_animation; int m_fromState; int m_toState; qreal m_hover; qreal m_minimized; qreal m_attention; qreal m_focus; qreal m_lastProgress; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/Applet.cpp000644 000765 000765 00000160503 11724514472 024303 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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. * ***********************************************************************************/ // Smooth Tasks #include "SmoothTasks/Applet.h" #include "TaskbuttonFrameSvg.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/Task.h" #include "SmoothTasks/ByShapeTaskbarLayout.h" #include "SmoothTasks/MaxSqueezeTaskbarLayout.h" #include "SmoothTasks/FixedItemCountTaskbarLayout.h" #include "SmoothTasks/FixedSizeTaskbarLayout.h" #include "SmoothTasks/LimitSqueezeTaskbarLayout.h" #include "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/PlasmaToolTip.h" #include "SmoothTasks/Global.h" // Plasma #include #include #include #include #include // Qt #include #include #include #include #include // KDE #include #include #include #include #include namespace SmoothTasks { class GroupManager : public TaskManager::GroupManager { public: GroupManager(Plasma::Applet *applet) : TaskManager::GroupManager(applet), m_applet(applet) { } protected: KConfigGroup config() const { return m_applet->config(); } private: Plasma::Applet *m_applet; }; Applet::Applet(QObject *parent, const QVariantList &args) : Plasma::Applet(parent, args), m_frame(new TaskbuttonFrameSvg(this)), m_groupManager(new GroupManager(this)), m_rootGroup(m_groupManager->rootGroup()), m_toolTip(new SmoothToolTip(this)), m_layout(new LimitSqueezeTaskbarLayout(0.6, false, (formFactor() == Plasma::Vertical) ? Qt::Vertical : Qt::Horizontal, this)), m_tasksHash(), m_configG(), m_configA(), m_groupingStrategy(TaskManager::GroupManager::ProgramGrouping), m_sortingStrategy(TaskManager::GroupManager::AlphaSorting), m_taskSpacing(5), m_iconScale(100), m_lights(true), m_expandTasks(false), m_keepExpanded(ExpandNone), m_expandOnHover(true), m_expandOnAttention(false), m_lightColor(78, 196, 249, 200), m_lightAnchorConfig(), m_activeIconIndex(0), m_previewLayout(NewPreviewLayout), m_middleClickAction(NoAction), m_maxPreviewSize(200), m_tooltipMoveDuration(500), m_highlightDelay(50), m_hideTooltipAfterClick(true), m_itemsPerRow(14), m_squeezeRatio(0.6), m_preferGrouping(false), m_itemHeight(40), m_rowAspectRatio(1.5), m_dontRotateFrame(false), m_onlyLights(true), m_textShadow(true), m_lightColorFromIcon(true), m_scrollSwitchTasks(true) { KGlobal::locale()->insertCatalog("plasma_applet_smooth-tasks"); setAcceptsHoverEvents(true); setAspectRatioMode(Plasma::IgnoreAspectRatio); setHasConfigurationInterface(true); setAcceptDrops(true); if (formFactor() == Plasma::Vertical) { resize(58, 500); } else { resize(500, 58); } } Applet::~Applet() { // to be sure that nothing gets called on a half deleted applet: disconnect( m_groupManager, SIGNAL(reload()), this, SLOT(reload())); disconnectRootGroup(); m_toolTip->hide(); clear(); // be VERY carefull with the deletions // maybe this is too carefull but better to be too carefull ToolTipBase *toolTip = m_toolTip; TaskbuttonFrameSvg *frame = m_frame; TaskManager::GroupManager *groupManager = m_groupManager; m_toolTip = NULL; m_frame = NULL; m_groupManager = NULL; delete toolTip; delete frame; delete groupManager; } void Applet::init() { m_frame->setImagePath("widgets/tasks"); m_frame->setCacheAllRenderedFrames(false); m_frame->setEnabledBorders(Plasma::FrameSvg::AllBorders); m_frame->setElementPrefix("normal"); Plasma::Containment* appletContainment = containment(); if (appletContainment) { m_groupManager->setScreen(appletContainment->screen()); } connectRootGroup(); connect( m_groupManager, SIGNAL(reload()), this, SLOT(reload())); connect( KWindowSystem::self(), SIGNAL(currentDesktopChanged(int)), this, SLOT(currentDesktopChanged())); m_layout->setContentsMargins(0, 0, 0, 0); m_layout->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); m_layout->setMaximumSize(INT_MAX, INT_MAX); setLayout(m_layout); connect( m_layout, SIGNAL(sizeHintChanged(Qt::SizeHint)), this, SIGNAL(sizeHintChanged(Qt::SizeHint))); configChanged(); setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); setMaximumSize(INT_MAX, INT_MAX); } void Applet::connectRootGroup() { TaskManager::TaskGroup *group = m_rootGroup.data(); if (group) { connect( group, SIGNAL(itemAdded(AbstractGroupableItem*)), this, SLOT(itemAdded(AbstractGroupableItem*))); connect( group, SIGNAL(itemRemoved(AbstractGroupableItem*)), this, SLOT(itemRemoved(AbstractGroupableItem*))); connect( group, SIGNAL(itemPositionChanged(AbstractGroupableItem*)), this, SLOT(itemPositionChanged(AbstractGroupableItem*))); } } void Applet::disconnectRootGroup() { disconnect(m_rootGroup.data(), NULL, this, NULL); } void Applet::itemAdded(AbstractGroupableItem* groupableItem) { // qDebug("itemAdded: 0x%lx \"%s\"", (unsigned long) groupableItem, qPrintable(groupableItem->name())); if (m_tasksHash.value(groupableItem) != NULL) { qWarning("Applet::itemAdded: item already exist: %s", qPrintable(groupableItem->name())); return; } if (groupableItem->itemType() == TaskManager::GroupItemType) { TaskManager::TaskGroup* group = static_cast(groupableItem); connect( group, SIGNAL(itemAdded(AbstractGroupableItem*)), this, SLOT(updateFullLimit())); connect( group, SIGNAL(itemRemoved(AbstractGroupableItem*)), this, SLOT(updateFullLimit())); } else if (groupableItem->itemType() == TaskManager::LauncherItemType) { } else { // copied from default task plasmoid TaskManager::TaskItem * taskItem = static_cast(groupableItem); //if the taskItem is not either a startup o a task, return 0; if (!taskItem->startup() && !taskItem->task()) { return; } } int index = m_groupManager->rootGroup()->members().indexOf(groupableItem); TaskItem *item = new TaskItem(groupableItem, this); m_toolTip->registerItem(item); connect(item, SIGNAL(itemActive(TaskItem*)), this, SLOT(updateActiveIconIndex(TaskItem*))); m_layout->insertItem(index, item); m_tasksHash[groupableItem] = item; updateFullLimit(); m_layout->activate(); } void Applet::itemRemoved(AbstractGroupableItem* groupableItem) { // qDebug("itemRemoved: 0x%lx \"%s\"", (unsigned long) groupableItem, qPrintable(groupableItem->name())); TaskItem* item = m_tasksHash.take(groupableItem); if (item == NULL) { qWarning("Applet::itemRemoved: trying to remove non-existant task: %s", qPrintable(groupableItem->name())); return; } m_layout->removeItem(item); updateFullLimit(); m_layout->activate(); delete item; } void Applet::currentDesktopChanged() { } void Applet::itemPositionChanged(AbstractGroupableItem* groupableItem) { // qDebug("itemPositionChanged: 0x%lx \"%s\"", (unsigned long) groupableItem, qPrintable(groupableItem->name())); TaskItem* item = m_tasksHash[groupableItem]; int currentIndex = m_layout->indexOf(item); if (currentIndex == -1) { qWarning("Applet::itemPositionChanged: trying to move non-existant task: %s", qPrintable(groupableItem->name())); return; } int newIndex = m_groupManager->rootGroup()->members().indexOf(groupableItem); // if we changed the sorting manually it is already moved in the layout: // (it seems like this slot is not called in this case) if (m_layout->itemAt(newIndex) == item) { return; } m_layout->move(currentIndex, newIndex); } void Applet::clear() { m_tasksHash.clear(); m_layout->clear(true); } void Applet::reload() { TaskManager::TaskGroup *group = m_groupManager->rootGroup(); if (group != m_rootGroup.data()) { disconnectRootGroup(); m_rootGroup = group; connectRootGroup(); reloadItems(); } } void Applet::reloadItems() { clear(); foreach(AbstractGroupableItem* item, m_groupManager->rootGroup()->members()) { itemAdded(item); } } void Applet::updateFullLimit() { if (m_groupManager != NULL) { const int limit = m_layout->optimumCapacity(); qDebug() << "Applet::updateFullLimit" << limit; m_groupManager->setFullLimit(limit); } } void Applet::constraintsEvent(Plasma::Constraints constraints) { if (constraints & Plasma::ScreenConstraint) { Plasma::Containment* appletContainment = containment(); if (appletContainment) { m_groupManager->setScreen(appletContainment->screen()); } } if (constraints & Plasma::SizeConstraint) { updateFullLimit(); } if (constraints & Plasma::LocationConstraint) { m_layout->setOrientation(formFactor() == Plasma::Vertical ? Qt::Vertical : Qt::Horizontal); } setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); } void Applet::hoverEnterEvent(QGraphicsSceneHoverEvent *event) { Q_UNUSED(event); emit mouseEnter(); } void Applet::dragEnterEvent(QGraphicsSceneDragDropEvent *event) { Q_UNUSED(event); emit mouseEnter(); } void Applet::dragMoveEvent(QGraphicsSceneDragDropEvent *event) { m_layout->moveDraggedItem(event->pos()); Plasma::Applet::dragMoveEvent(event); } void Applet::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) { m_layout->dragLeave(); Plasma::Applet::dragLeaveEvent(event); } void Applet::dragItem(TaskItem *item, QGraphicsSceneMouseEvent *event) { bool isGroup = item->task()->type() == Task::GroupItem; QByteArray data; data.append("dummy"); m_toolTip->hide(); QMimeData* mimeData = new QMimeData(); if(item->task()->type() == Task::LauncherItem) { QList urls; urls.append(item->task()->launcherItem()->launcherUrl()); mimeData->setUrls(urls); mimeData->setData(TASK_ITEM, data); } else { mimeData->setData(TASK_ITEM, data); } item->task()->addMimeData(mimeData); QDrag *drag = new QDrag(event->widget()); drag->setMimeData(mimeData); drag->setPixmap(item->task()->icon().pixmap(20)); // drag->setDragCursor( set the correct cursor //TODO if (m_sortingStrategy == TaskManager::GroupManager::ManualSorting) { int fromIndex = m_layout->indexOf(item); int toIndex = m_layout->dragItem(item, drag, item->pos() + event->pos()); if (toIndex != -1) { m_groupManager->rootGroup()->moveItem(fromIndex, toIndex); } else if (isGroup) { // XXX: workaround because the pager takes only one task of a group: // maybe allways do that? reloadItems(); } } else { drag->exec(Qt::MoveAction); } } void Applet::dragTask(TaskManager::AbstractGroupableItem *task, QWidget *source) { QMimeData* mimeData = new QMimeData(); if(task->itemType() == TaskManager::LauncherItemType) { TaskManager::LauncherItem *launcher = qobject_cast(task); QList urls; urls.append(launcher->launcherUrl()); mimeData->setUrls(urls); } task->addMimeData(mimeData); QDrag *drag = new QDrag(source); drag->setMimeData(mimeData); drag->setPixmap(task->icon().pixmap(20)); // drag->setDragCursor( set the correct cursor //TODO // qDebug("drag start"); drag->exec(Qt::MoveAction); // Qt::DropAction action = drag->exec(Qt::MoveAction); // if (action & Qt::CopyAction) qDebug("CopyAction"); // if (action & Qt::MoveAction) qDebug("MoveAction"); // if (action & Qt::LinkAction) qDebug("LinkAction"); // if (action & Qt::ActionMask) qDebug("ActionMask"); // if (action & Qt::TargetMoveAction) qDebug("TargetMoveAction"); // if (action & Qt::IgnoreAction) qDebug("IgnoreAction"); // qDebug("action: %d", action); } void Applet::middleClickTask(TaskManager::AbstractGroupableItem* task) { switch (m_middleClickAction) { case Applet::CloseTask: task->close(); break; case Applet::MoveToCurrentDesktop: task->toDesktop(KWindowSystem::currentDesktop()); case Applet::NoAction: break; } } void Applet::dumpItems() { int maxlen = 10; int maxitems = m_layout->count(); TaskManager::ItemList members = m_groupManager->rootGroup()->members(); for (int i = 0; i < maxitems; ++ i) { int len = m_layout->itemAt(i)->task()->text().length(); if (len > maxlen) { maxlen = len; } } if (members.size() > maxitems) { maxitems = members.size(); } if (m_layout->count() > maxitems) { maxitems = m_layout->count(); } qDebug() << qPrintable(QString("%1 | %2 |") .arg(QString("root group").leftJustified(maxlen + 9)) .arg(QString("m_layout").leftJustified(maxlen + 9))); QString hline = QString().leftJustified(maxlen + 9, '-'); qDebug() << qPrintable(QString("%1-+-%2-+---") .arg(hline) .arg(hline)); for (int i = 0; i < maxitems; ++ i) { QString sRootGroup; QString sLayout; WId winRootGroup = 0; WId winLayout = 0; if (i < members.size()) { sRootGroup = members[i]->name(); TaskManager::TaskItem *item = qobject_cast(members[i]); if (item && item->task()) { winRootGroup = item->task()->window(); } } if (i < m_layout->count()) { TaskItem* titem = dynamic_cast(m_layout->itemAt(i)); if (titem && titem->task()) { sLayout = titem->task()->text(); if (titem->task()->task()) { winLayout = titem->task()->task()->window(); } } } bool allEqual = sRootGroup == sLayout && winRootGroup == winLayout; qDebug() << qPrintable(QString("%1 %2 | %3 %4 |") .arg(QString::number(winRootGroup).rightJustified(8)) .arg(sRootGroup.leftJustified(maxlen)) .arg(QString::number(winLayout).rightJustified(8)) .arg(sLayout.leftJustified(maxlen))) << (allEqual ? "" : "X"); } qDebug("\n"); } void Applet::dropEvent(QGraphicsSceneDragDropEvent *event) { KUrl::List urls = KUrl::List::fromMimeData(event->mimeData()); if (urls.count() == 1) { //check if url is a *.desktop file KUrl u = urls.first(); if(u.isLocalFile() && u.fileName().endsWith(".desktop")) { m_groupManager->addLauncher(u); } return; } if (event->mimeData()->hasFormat(TASK_ITEM) && (sortingStrategy() == TaskManager::GroupManager::ManualSorting) && m_layout->isDragging()) { event->acceptProposedAction(); } } void Applet::dragMoveEvent(const QPointF& pos) { m_layout->moveDraggedItem(pos); } int Applet::activeIndex() { int index = 0; for (int i = 0; i < m_layout->count(); ++ i) { TaskItem *item = m_layout->itemAt(i); if (item->task()->type() == Task::GroupItem) { foreach (AbstractGroupableItem *task, item->task()->group()->members()) { if (task->isActive()) { return index; } ++ index; } } else if (item->task()->isActive()) { return index; } ++ index; } return index; } void Applet::updateActiveIconIndex(TaskItem *item) { Q_UNUSED(item); //m_activeIconIndex = m_items.indexOf(item); m_activeIconIndex = activeIndex(); } int Applet::totalSubTasks() { int count = 0; for (int i = 0; i < m_layout->count(); ++ i) { TaskItem *item = m_layout->itemAt(i); if (item->task()->type() == Task::GroupItem) { count += item->task()->group()->members().count(); } else { ++ count; } } return count; } AbstractGroupableItem* Applet::selectSubTask(int index) { for (int i = 0; i < m_layout->count(); ++ i) { TaskItem *item = m_layout->itemAt(i); if (item->task()->type() == Task::GroupItem) { TaskManager::ItemList members(item->task()->group()->members()); const int N = members.count(); if (index < N) { return members.at(index); //return m_tasksHash[item->task()->group()->members().at(index)]; } else { index -= N; } } else if (index == 0) { return item->task()->abstractItem(); } else { -- index; } } return NULL; } void Applet::wheelEvent(QGraphicsSceneWheelEvent *event) { if (!m_scrollSwitchTasks) { return; } int subTasks = totalSubTasks(); // zero or one tasks don't cycle if (subTasks < 1) { return; } // mouse wheel down if (event->delta() < 0) { ++ m_activeIconIndex; if (m_activeIconIndex >= subTasks) { m_activeIconIndex = 0; } // mouse wheel up } else { -- m_activeIconIndex; if (m_activeIconIndex < 0) { m_activeIconIndex = subTasks - 1; // last item is a spacer } } AbstractGroupableItem *taskItem = selectSubTask(m_activeIconIndex); if (taskItem && !taskItem->itemType() == TaskManager::GroupItemType) { TaskManager::TaskItem* task = static_cast(taskItem); if (task->task()) { task->task()->activate(); } } } void Applet::newNotification(const QString& notif) { qDebug() << "new notification" << notif; } void Applet::uiGroupingStrategyChanged(int index) { m_configG.onlyGroupWhenFull->setEnabled( m_configG.groupingStrategy->itemData(index) != TaskManager::GroupManager::NoGrouping); } void Applet::uiMinimumRowsChanged(int minimumRows) { if (minimumRows > m_configA.maximumRows->value()) { m_configA.maximumRows->setValue(minimumRows); } } void Applet::uiMaximumRowsChanged(int maximumRows) { if (maximumRows < m_configA.minimumRows->value()) { m_configA.minimumRows->setValue(maximumRows); } } void Applet::uiMinButtonWidthChanged(int minButtonWidth) { if (m_configA.maxButtonWidth->value() < minButtonWidth) m_configA.maxButtonWidth->setValue(minButtonWidth); } void Applet::uiMaxButtonWidthChanged(int maxButtonWidth) { if (m_configA.minButtonWidth->value() > maxButtonWidth) m_configA.minButtonWidth->setValue(maxButtonWidth); } void Applet::uiToolTipKindChanged(int index) { bool enabled = m_configA.toolTipKind->itemData(index) == ToolTipBase::Smooth; m_configA.previewLayout->setEnabled(enabled); m_configA.previewLayoutLabel->setEnabled(enabled); m_configA.maxPreviewSize->setEnabled(enabled); m_configA.maxPreviewSizeLabel->setEnabled(enabled); m_configA.tooltipMoveDuration->setEnabled(enabled); m_configA.tooltipMoveDurationLabel->setEnabled(enabled); m_configA.highlightDelay->setEnabled(enabled); m_configA.highlightDelayLabel->setEnabled(enabled); m_configA.hideTooltipAfterClick->setEnabled(enabled); } void Applet::uiTaskbarLayoutChanged(int index) { int type = m_configA.taskbarLayout->itemData(index).toInt(); bool enabled = type == TaskbarLayout::LimitSqueeze; m_configA.squeezeRatio->setEnabled(enabled); m_configA.squeezeRatioLabel->setEnabled(enabled); m_configA.preferGrouping->setEnabled(enabled); enabled = type == TaskbarLayout::FixedSize; m_configA.itemHeight->setEnabled(enabled); m_configA.itemHeightLabel->setEnabled(enabled); enabled = type == TaskbarLayout::FixedItemCount; m_configA.itemsPerRow->setEnabled(enabled); m_configA.itemsPerRowLabel->setEnabled(enabled); enabled = type == TaskbarLayout::ByShape; m_configA.rowAspectRatio->setEnabled(enabled); m_configA.rowAspectRatioLabel->setEnabled(enabled); } void Applet::createConfigurationInterface(KConfigDialog *parent) { connect(parent, SIGNAL(applyClicked()), this, SLOT(configAccepted())); connect(parent, SIGNAL(okClicked()), this, SLOT(configAccepted())); connect(parent, SIGNAL(defaultClicked()), this, SLOT(loadDefaults())); parent->showButton(KConfigDialog::Help, false); parent->enableButton(KConfigDialog::Default, true); QWidget *widgetG = new QWidget; m_configG.setupUi(widgetG); parent->addPage(widgetG, i18n("General"), icon()); QWidget *widgetA = new QWidget; m_configA.setupUi(widgetA); parent->addPage(widgetA, i18n("Appearance"), "preferences-desktop-theme"); QWidget *widgetW = new QWidget; m_configW.setupUi(widgetW); parent->addPage(widgetW, i18n("Workarounds"), "preferences-other"); // general m_configA.expandTasks->setChecked(m_expandTasks); // filters m_configG.showOnlyCurrentDesktop->setChecked(m_groupManager->showOnlyCurrentDesktop()); m_configG.showOnlyCurrentScreen->setChecked(m_groupManager->showOnlyCurrentScreen()); m_configG.showOnlyCurrentActivity->setChecked(m_groupManager->showOnlyCurrentActivity()); m_configG.showOnlyMinimized->setChecked(m_groupManager->showOnlyMinimized()); // grouping m_configG.groupingStrategy->addItem(i18n("Do Not Group"), TaskManager::GroupManager::NoGrouping); //m_configG.groupingStrategy->addItem(i18n("Manually"), TaskManager::GroupManager::ManualGrouping); m_configG.groupingStrategy->addItem(i18n("By Program Name"), TaskManager::GroupManager::ProgramGrouping); m_configG.onlyGroupWhenFull->setChecked(m_groupManager->onlyGroupWhenFull() ? Qt::Checked : Qt::Unchecked); connect(m_configG.groupingStrategy, SIGNAL(currentIndexChanged(int)), this, SLOT(uiGroupingStrategyChanged(int))); m_configG.groupingStrategy->setCurrentIndex(m_configG.groupingStrategy->findData(m_groupManager->groupingStrategy())); m_configG.onlyGroupWhenFull->setEnabled(m_groupManager->groupingStrategy() != TaskManager::GroupManager::NoGrouping); // sorting m_configG.sortingStrategy->addItem(i18n("Do Not Sort"), TaskManager::GroupManager::NoSorting); m_configG.sortingStrategy->addItem(i18n("Manually"), TaskManager::GroupManager::ManualSorting); m_configG.sortingStrategy->addItem(i18n("Alphabetically"), TaskManager::GroupManager::AlphaSorting); m_configG.sortingStrategy->addItem(i18n("By Desktop"), TaskManager::GroupManager::DesktopSorting); m_configG.sortingStrategy->setCurrentIndex(m_configG.sortingStrategy->findData(m_groupManager->sortingStrategy())); m_configG.middleClickAction->addItem(i18n("No Action"), NoAction); m_configG.middleClickAction->addItem(i18n("Close Task"), CloseTask); m_configG.middleClickAction->addItem(i18n("Move to Current Desktop"), MoveToCurrentDesktop); m_configG.middleClickAction->setCurrentIndex(m_configG.middleClickAction->findData(m_middleClickAction)); // apearance m_configA.dontRotateFrame->setChecked(m_dontRotateFrame); m_configA.onlyLights->setChecked(m_onlyLights); m_configA.textShadow->setChecked(m_textShadow); m_configA.lightColorFromIcon->setChecked(m_lightColorFromIcon); m_configA.scrollSwitchTasks->setChecked(m_scrollSwitchTasks); m_configA.minimumRows->setValue(m_layout->minimumRows()); m_configA.maximumRows->setValue(m_layout->maximumRows()); connect(m_configA.minimumRows, SIGNAL(valueChanged(int)), this, SLOT(uiMinimumRowsChanged(int))); connect(m_configA.maximumRows, SIGNAL(valueChanged(int)), this, SLOT(uiMaximumRowsChanged(int))); m_configA.taskSpacing->setValue(m_taskSpacing); m_configA.iconScale->setValue(m_iconScale); m_configA.lights->setChecked(m_lights); m_configA.lightColor->setColor(m_lightColor); m_configA.lightAnchorHorizontal->setValue(m_lightAnchorConfig.anchorHorizontal()); m_configA.lightAnchorHorizontalEnabled->setChecked(m_lightAnchorConfig.isAnchoredHorizontally()); m_configA.lightAnchorVertical->setValue(m_lightAnchorConfig.anchorVertical()); m_configA.lightAnchorVerticalEnabled->setChecked(m_lightAnchorConfig.isAnchoredVertically()); m_configA.expandingSize->setValue(m_layout->expandedWidth()); m_configA.minIconSpace->setValue(m_minIconSpace); m_configA.minButtonWidth->setValue(m_minButtonWidth); m_configA.maxButtonWidth->setValue(m_maxButtonWidth); connect(m_configA.minButtonWidth, SIGNAL(valueChanged(int)), this, SLOT(uiMinButtonWidthChanged(int))); connect(m_configA.maxButtonWidth, SIGNAL(valueChanged(int)), this, SLOT(uiMaxButtonWidthChanged(int))); m_configA.fps->setValue(m_layout->fps()); m_configA.animationSpeed->setValue(m_layout->animationSpeed()); m_configA.animationDuration->setValue(m_layout->expandDuration()); connect(m_configA.toolTipKind, SIGNAL(currentIndexChanged(int)), this, SLOT(uiToolTipKindChanged(int))); m_configA.toolTipKind->addItem(i18n("None"), ToolTipBase::None); m_configA.toolTipKind->addItem(i18n("Smooth"), ToolTipBase::Smooth); m_configA.toolTipKind->addItem(i18n("Plasma"), ToolTipBase::Plasma); m_configA.toolTipKind->setCurrentIndex(m_configA.toolTipKind->findData(m_toolTip->kind())); connect(m_configA.taskbarLayout, SIGNAL(currentIndexChanged(int)), this, SLOT(uiTaskbarLayoutChanged(int))); m_configA.taskbarLayout->addItem(i18n("By Taskbar Shape"), TaskbarLayout::ByShape); m_configA.taskbarLayout->addItem(i18n("Maximum Squeeze"), TaskbarLayout::MaxSqueeze); m_configA.taskbarLayout->addItem(i18n("Fixed Item Number per Row"), TaskbarLayout::FixedItemCount); m_configA.taskbarLayout->addItem(i18n("Limited Squeeze"), TaskbarLayout::LimitSqueeze); m_configA.taskbarLayout->addItem(i18n("Fixed Maximum Item Height"), TaskbarLayout::FixedSize); m_configA.taskbarLayout->setCurrentIndex(m_configA.taskbarLayout->findData(m_layout->type())); m_configA.itemsPerRow->setValue(m_itemsPerRow); m_configA.squeezeRatio->setValue(m_squeezeRatio); m_configA.preferGrouping->setChecked(m_preferGrouping); m_configA.itemHeight->setValue(m_itemHeight); m_configA.rowAspectRatio->setValue(m_rowAspectRatio); m_configA.keepExpanded->addItem(i18n("None"), ExpandNone); m_configA.keepExpanded->addItem(i18n("Active"), ExpandActive); m_configA.keepExpanded->addItem(i18n("From the current desktop"), ExpandCurrentDesktop); m_configA.keepExpanded->addItem(i18n("All"), ExpandAll); m_configA.keepExpanded->setCurrentIndex(m_configA.keepExpanded->findData(m_keepExpanded)); m_configA.expandOnHover->setChecked(m_expandOnHover); m_configA.expandOnAttention->setChecked(m_expandOnAttention); m_configA.previewLayout->addItem(i18n("Classic"), ClassicPreviewLayout); m_configA.previewLayout->addItem(i18n("New"), NewPreviewLayout); m_configA.previewLayout->setCurrentIndex(m_configA.previewLayout->findData(m_previewLayout)); m_configA.maxPreviewSize->setValue(m_maxPreviewSize); m_configA.tooltipMoveDuration->setValue(m_tooltipMoveDuration); m_configA.highlightDelay->setValue(m_highlightDelay); m_configA.hideTooltipAfterClick->setChecked(m_hideTooltipAfterClick); m_configW.taskButtonMarginsCustom->setChecked(m_frame->customMarginsEnabled()); m_configW.taskButtonMarginLeft ->setValue(m_frame->customMarginSize(::Plasma::LeftMargin)); m_configW.taskButtonMarginTop ->setValue(m_frame->customMarginSize(::Plasma::TopMargin)); m_configW.taskButtonMarginRight ->setValue(m_frame->customMarginSize(::Plasma::RightMargin)); m_configW.taskButtonMarginBottom->setValue(m_frame->customMarginSize(::Plasma::BottomMargin)); connect(m_configA.expandTasks , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configG.sortingStrategy , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configG.groupingStrategy , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configG.onlyGroupWhenFull , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configG.middleClickAction , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configA.taskSpacing , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.keepExpanded , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configA.expandOnHover , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.expandOnAttention , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.toolTipKind , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configA.taskbarLayout , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configA.previewLayout , SIGNAL(currentIndexChanged(int)), parent, SLOT(settingsModified())); connect(m_configA.maxPreviewSize , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.tooltipMoveDuration , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.highlightDelay , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.hideTooltipAfterClick , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.expandingSize , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.minIconSpace , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.minButtonWidth , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.maxButtonWidth , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.itemsPerRow , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.squeezeRatio , SIGNAL(valueChanged(double)) , parent, SLOT(settingsModified())); connect(m_configA.preferGrouping , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.itemHeight , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.rowAspectRatio , SIGNAL(valueChanged(double)) , parent, SLOT(settingsModified())); connect(m_configA.iconScale , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.minimumRows , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.maximumRows , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.lightColor , SIGNAL(changed(QColor)) , parent, SLOT(settingsModified())); connect(m_configA.lightColor , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.lightAnchorHorizontalEnabled, SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.lightAnchorHorizontal , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.lightAnchorVerticalEnabled , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.lightAnchorVertical , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.fps , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.animationSpeed , SIGNAL(valueChanged(double)) , parent, SLOT(settingsModified())); connect(m_configA.animationDuration , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configA.lights , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.dontRotateFrame , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.onlyLights , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.textShadow , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.lightColorFromIcon , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configA.scrollSwitchTasks , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configG.showOnlyCurrentDesktop , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configG.showOnlyCurrentActivity , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configG.showOnlyCurrentScreen , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configG.showOnlyMinimized , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configW.taskButtonMarginsCustom , SIGNAL(toggled(bool)) , parent, SLOT(settingsModified())); connect(m_configW.taskButtonMarginLeft , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configW.taskButtonMarginTop , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configW.taskButtonMarginRight , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); connect(m_configW.taskButtonMarginBottom , SIGNAL(valueChanged(int)) , parent, SLOT(settingsModified())); } void Applet::loadDefaults() { qDebug("Applet::loadDefaults: TODO"); // m_configDialog->enableButton(KConfigDialog::Default, true); } QSizeF Applet::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const { qDebug() << "Applet::sizeHint" << "which" << which << "constraint" << constraint; if (m_layout && which == Qt::PreferredSize) { if(constraint.width() == -1 || constraint.height() == -1) { switch(formFactor()) { case Plasma::Vertical: return m_layout->effectiveSizeHint(which, QSizeF(geometry().width(), -1)); case Plasma::Horizontal: return m_layout->effectiveSizeHint(which, QSizeF(-1, geometry().height())); default:; } } return m_layout->effectiveSizeHint(which, constraint); } else { return Plasma::Applet::sizeHint(which, constraint); } } void Applet::configAccepted() { KConfigGroup cg(config()); bool changed = false; // general if ((bool) m_configA.expandTasks->checkState() != m_expandTasks) { cg.writeEntry("expandTasks", m_configA.expandTasks->checkState() == Qt::Checked); changed = true; } // sorting if (m_configG.sortingStrategy->currentIndex() == -1) { m_sortingStrategy = TaskManager::GroupManager::AlphaSorting; } else { int cfgSortingStrategy = m_configG.sortingStrategy->itemData(m_configG.sortingStrategy->currentIndex()).toInt(); m_sortingStrategy = static_cast(cfgSortingStrategy); } if (m_groupManager->sortingStrategy() != m_sortingStrategy) { m_groupManager->setSortingStrategy(m_sortingStrategy); cg.writeEntry("sortingStrategy", static_cast(m_sortingStrategy)); changed = true; } // grouping if (m_configG.groupingStrategy->currentIndex() == -1) { m_groupingStrategy = TaskManager::GroupManager::ProgramGrouping; } else { int cfgGroupingStrategy = m_configG.groupingStrategy->itemData(m_configG.groupingStrategy->currentIndex()).toInt(); m_groupingStrategy = static_cast(cfgGroupingStrategy); } if (m_groupManager->groupingStrategy() != m_groupingStrategy) { m_groupManager->setGroupingStrategy(m_groupingStrategy); cg.writeEntry("groupingStrategy", static_cast(m_groupingStrategy)); changed = true; } bool cfgOnlyGroupWhenFull = m_configG.onlyGroupWhenFull->isChecked(); if (m_groupManager->onlyGroupWhenFull() != cfgOnlyGroupWhenFull) { m_groupManager->setOnlyGroupWhenFull(cfgOnlyGroupWhenFull); cg.writeEntry("onlyGroupWhenFull", cfgOnlyGroupWhenFull); changed = true; } int cfgMiddleClickAction = m_configG.middleClickAction->itemData(m_configG.middleClickAction->currentIndex()).toInt(); if (cfgMiddleClickAction != m_middleClickAction) { cg.writeEntry("middleClickAction", cfgMiddleClickAction); changed = true; } // appearance if (m_configA.taskSpacing->value() != m_taskSpacing) { cg.writeEntry("taskSpacing", m_configA.taskSpacing->value()); changed = true; } int cfgKeepExpanded = m_configA.keepExpanded->itemData(m_configA.keepExpanded->currentIndex()).toInt(); if (cfgKeepExpanded != m_keepExpanded) { cg.writeEntry("keepExpanded", cfgKeepExpanded); changed = true; } if (m_configA.expandOnHover->isChecked() != m_expandOnHover) { cg.writeEntry("expandOnHover", m_configA.expandOnHover->isChecked()); changed = true; } if (m_configA.expandOnAttention->isChecked() != m_expandOnAttention) { cg.writeEntry("expandOnAttention", m_configA.expandOnAttention->isChecked()); changed = true; } int cfgToolTipKind = m_configA.toolTipKind->itemData(m_configA.toolTipKind->currentIndex()).toInt(); if (cfgToolTipKind != m_toolTip->kind()) { cg.writeEntry("toolTipKind", cfgToolTipKind); changed = true; } int cfgTaskbarLayout = m_configA.taskbarLayout->itemData(m_configA.taskbarLayout->currentIndex()).toInt(); if (cfgTaskbarLayout != m_layout->type()) { cg.writeEntry("taskbarLayout", cfgTaskbarLayout); changed = true; } int cfgPreviewLayout = m_configA.previewLayout->itemData(m_configA.previewLayout->currentIndex()).toInt(); if (cfgPreviewLayout != m_previewLayout) { cg.writeEntry("previewLayout", cfgPreviewLayout); changed = true; } if (m_configA.maxPreviewSize->value() != m_maxPreviewSize) { cg.writeEntry("maxPreviewSize", m_configA.maxPreviewSize->value()); changed = true; } if (m_configA.tooltipMoveDuration->value() != m_tooltipMoveDuration) { cg.writeEntry("tooltipMoveDuration", m_configA.tooltipMoveDuration->value()); changed = true; } if (m_configA.highlightDelay->value() != m_highlightDelay) { cg.writeEntry("highlightDelay", m_configA.highlightDelay->value()); changed = true; } if (m_configA.hideTooltipAfterClick->isChecked() != m_hideTooltipAfterClick) { cg.writeEntry("hideTooltipAfterClick", m_configA.hideTooltipAfterClick->isChecked()); changed = true; } if (m_configA.expandingSize->value() != m_layout->expandedWidth()) { cg.writeEntry("expandingSize", m_configA.expandingSize->value()); changed = true; } if (m_configA.minIconSpace->value() != m_minIconSpace) { cg.writeEntry("minIconSpace", m_configA.minIconSpace->value()); changed = true; } if (m_configA.minButtonWidth->value() != m_minButtonWidth) { cg.writeEntry("minButtonWidth", m_configA.minButtonWidth->value()); changed = true; } if (m_configA.maxButtonWidth->value() != m_maxButtonWidth) { cg.writeEntry("maxButtonWidth", m_configA.maxButtonWidth->value()); changed = true; } if (m_configA.itemsPerRow->value() != m_itemsPerRow) { cg.writeEntry("itemsPerRow", m_configA.itemsPerRow->value()); changed = true; } if (m_configA.squeezeRatio->value() != m_squeezeRatio) { cg.writeEntry("squeezeRatio", m_configA.squeezeRatio->value()); changed = true; } if (m_configA.preferGrouping->isChecked() != m_preferGrouping) { cg.writeEntry("preferGrouping", m_configA.preferGrouping->isChecked()); changed = true; } if (m_configA.itemHeight->value() != m_itemHeight) { cg.writeEntry("itemHeight", m_configA.itemHeight->value()); changed = true; } if (m_configA.rowAspectRatio->value() != m_rowAspectRatio) { cg.writeEntry("rowAspectRatio", m_configA.rowAspectRatio->value()); changed = true; } if (m_configA.iconScale->value() != m_iconScale) { cg.writeEntry("iconScale", m_configA.iconScale->value()); changed = true; } if (m_configA.minimumRows->value() != m_layout->minimumRows()) { cg.writeEntry("minimumRows", m_configA.minimumRows->value()); changed = true; } if (m_configA.maximumRows->value() != m_layout->maximumRows()) { cg.writeEntry("maximumRows", m_configA.maximumRows->value()); changed = true; } if (m_configA.lightColor->color() != m_lightColor) { cg.writeEntry("lightColor", m_configA.lightColor->color()); changed = true; } if (m_configA.lightAnchorHorizontalEnabled->isChecked() != m_lightAnchorConfig.isAnchoredHorizontally()) { cg.writeEntry("lightAnchorHorizontalEnabled", m_configA.lightAnchorHorizontalEnabled->isChecked()); changed = true; } if (m_configA.lightAnchorHorizontal->value() != m_lightAnchorConfig.anchorHorizontal()) { cg.writeEntry("lightAnchorHorizontal", m_configA.lightAnchorHorizontal->value()); changed = true; } if (m_configA.lightAnchorVerticalEnabled->isChecked() != m_lightAnchorConfig.isAnchoredVertically()) { cg.writeEntry("lightAnchorVerticalEnabled", m_configA.lightAnchorVerticalEnabled->isChecked()); changed = true; } if (m_configA.lightAnchorVertical->value() != m_lightAnchorConfig.anchorVertical()) { cg.writeEntry("lightAnchorVertical", m_configA.lightAnchorVertical->value()); changed = true; } if (m_configA.fps->value() != m_layout->fps()) { cg.writeEntry("fps", m_configA.fps->value()); changed = true; } if (m_configA.animationSpeed->value() != m_layout->animationSpeed()) { cg.writeEntry("animationSpeed", m_configA.animationSpeed->value()); changed = true; } if (m_configA.animationDuration->value() != m_layout->expandDuration()) { cg.writeEntry("animationDuration", m_configA.animationDuration->value()); changed = true; } if (m_configA.lights->checkState() != m_lights) { cg.writeEntry("lights", m_configA.lights->checkState() == Qt::Checked); changed = true; } bool cfgDontRotateFrame = m_configA.dontRotateFrame->isChecked(); if (cfgDontRotateFrame != m_dontRotateFrame) { cg.writeEntry("dontRotateFrame", cfgDontRotateFrame); changed = true; } bool cfgOnlyLights = m_configA.onlyLights->isChecked(); if (cfgOnlyLights != m_onlyLights) { cg.writeEntry("onlyLights", cfgOnlyLights); changed = true; } bool cfgTextShadow = m_configA.textShadow->isChecked(); if (cfgTextShadow != m_textShadow) { cg.writeEntry("textShadow", cfgTextShadow); changed = true; } bool cfgLightColorFromIcon = m_configA.lightColorFromIcon->isChecked(); if (cfgLightColorFromIcon != m_lightColorFromIcon) { cg.writeEntry("lightColorFromIcon", cfgLightColorFromIcon); changed = true; } bool cfgScrollSwitchTasks = m_configA.scrollSwitchTasks->isChecked(); if (cfgScrollSwitchTasks != m_scrollSwitchTasks) { cg.writeEntry("scrollSwitchTasks", cfgScrollSwitchTasks); changed = true; } // filters if (m_groupManager->showOnlyCurrentDesktop() != m_configG.showOnlyCurrentDesktop->isChecked()) { m_groupManager->setShowOnlyCurrentDesktop(!m_groupManager->showOnlyCurrentDesktop()); cg.writeEntry("showOnlyCurrentDesktop", m_groupManager->showOnlyCurrentDesktop()); changed = true; } if (m_groupManager->showOnlyCurrentActivity() != m_configG.showOnlyCurrentActivity->isChecked()) { m_groupManager->setShowOnlyCurrentActivity(!m_groupManager->showOnlyCurrentActivity()); cg.writeEntry("showOnlyCurrentActivity", m_groupManager->showOnlyCurrentActivity()); changed = true; } if (m_groupManager->showOnlyCurrentScreen() != m_configG.showOnlyCurrentScreen->isChecked()) { m_groupManager->setShowOnlyCurrentScreen(!m_groupManager->showOnlyCurrentScreen()); cg.writeEntry("showOnlyCurrentScreen", m_groupManager->showOnlyCurrentScreen()); changed = true; } if (m_groupManager->showOnlyMinimized() != m_configG.showOnlyMinimized->isChecked()) { m_groupManager->setShowOnlyMinimized(!m_groupManager->showOnlyMinimized()); cg.writeEntry("showOnlyMinimized", m_groupManager->showOnlyMinimized()); changed = true; } // workarounds if (m_configW.taskButtonMarginsCustom->isChecked() != m_frame->customMarginsEnabled()) { cg.writeEntry("taskButtonMarginsCustom", (m_configW.taskButtonMarginsCustom->checkState() == Qt::Checked)); changed = true; } if (m_configW.taskButtonMarginLeft->value() != m_frame->customMarginSize(Plasma::LeftMargin)) { cg.writeEntry("taskButtonMarginLeft", m_configW.taskButtonMarginLeft->value()); changed = true; } if (m_configW.taskButtonMarginTop->value() != m_frame->customMarginSize(Plasma::TopMargin)) { cg.writeEntry("taskButtonMarginTop", m_configW.taskButtonMarginTop->value()); changed = true; } if (m_configW.taskButtonMarginRight->value() != m_frame->customMarginSize(Plasma::RightMargin)) { cg.writeEntry("taskButtonMarginRight", m_configW.taskButtonMarginRight->value()); changed = true; } if (m_configW.taskButtonMarginBottom->value() != m_frame->customMarginSize(Plasma::BottomMargin)) { cg.writeEntry("taskButtonMarginBottom", m_configW.taskButtonMarginBottom->value()); changed = true; } if (changed) emit configNeedsSaving(); } void Applet::widgetValueChanged() { // if (!m_configDialog.isNull()) { // // TODO: check whether state is default state // m_configDialog->enableButton(KConfigDialog::Default, true); // } } void Applet::configChanged() { KConfigGroup cg = config(); m_taskSpacing = cg.readEntry("taskSpacing", 5); m_layout->setSpacing(m_taskSpacing); m_iconScale = cg.readEntry("iconScale", 100); m_lights = cg.readEntry("lights", true); m_expandTasks = cg.readEntry("expandTasks", false); int cfgMinimumRows = cg.readEntry("minimumRows", 1); int cfgMaximumRows = cg.readEntry("maximumRows", 3); m_layout->setRowBounds(cfgMinimumRows, cfgMaximumRows); int cfgToolTipKind = cg.readEntry("toolTipKind", (int) ToolTipBase::Smooth); if (cfgToolTipKind != m_toolTip->kind()) { for (int i = 0; i < m_layout->count(); ++ i) { m_toolTip->unregisterItem(m_layout->itemAt(i)); } delete m_toolTip; switch (cfgToolTipKind) { case ToolTipBase::None: m_toolTip = new ToolTipBase(this); break; case ToolTipBase::Plasma: m_toolTip = new PlasmaToolTip(this); break; case ToolTipBase::Smooth: default: m_toolTip = new SmoothToolTip(this); } for (int i = 0; i < m_layout->count(); ++ i) { m_toolTip->registerItem(m_layout->itemAt(i)); } } int cfgTaskbarLayout = cg.readEntry("taskbarLayout", (int) TaskbarLayout::LimitSqueeze); m_itemsPerRow = cg.readEntry("itemsPerRow", 14); if (m_itemsPerRow < 1) { m_itemsPerRow = 14; } if (cfgTaskbarLayout == m_layout->type() && cfgTaskbarLayout == TaskbarLayout::FixedItemCount) { FixedItemCountTaskbarLayout *layout = static_cast(m_layout); layout->setItemsPerRow(m_itemsPerRow); } m_preferGrouping = cg.readEntry("preferGrouping", false); m_squeezeRatio = cg.readEntry("squeezeRatio", qreal(0.6)); if (m_squeezeRatio <= 0 || m_squeezeRatio > 1) { m_squeezeRatio = 0.6; } if (cfgTaskbarLayout == m_layout->type() && cfgTaskbarLayout == TaskbarLayout::LimitSqueeze) { LimitSqueezeTaskbarLayout *layout = static_cast(m_layout); layout->setSqueezeRatio(m_squeezeRatio); layout->setPreferGrouping(m_preferGrouping); } m_itemHeight = cg.readEntry("itemHeight", 40); if (m_itemHeight < 1) { m_itemHeight = 40; } if (cfgTaskbarLayout == m_layout->type() && cfgTaskbarLayout == TaskbarLayout::FixedSize) { FixedSizeTaskbarLayout *layout = static_cast(m_layout); layout->setFixedCellHeight(m_itemHeight); } m_rowAspectRatio = cg.readEntry("rowAspectRatio", qreal(1.5)); if (m_rowAspectRatio <= 0.0) { m_rowAspectRatio = 1.5; } if (cfgTaskbarLayout == m_layout->type() && cfgTaskbarLayout == TaskbarLayout::ByShape) { ByShapeTaskbarLayout *layout = static_cast(m_layout); layout->setRowAspectRatio(m_rowAspectRatio); } if (cfgTaskbarLayout != m_layout->type()) { TaskbarLayout *newLayout; disconnect(m_layout, SIGNAL(sizeHintChanged(Qt::SizeHint)), 0, 0); switch (cfgTaskbarLayout) { case TaskbarLayout::MaxSqueeze: newLayout = new MaxSqueezeTaskbarLayout(m_layout->orientation(), NULL); break; case TaskbarLayout::FixedItemCount: newLayout = new FixedItemCountTaskbarLayout(m_itemsPerRow, m_layout->orientation(), NULL); break; case TaskbarLayout::FixedSize: newLayout = new FixedSizeTaskbarLayout(m_itemHeight, m_layout->orientation(), NULL); break; case TaskbarLayout::ByShape: newLayout = new ByShapeTaskbarLayout(m_rowAspectRatio, m_layout->orientation(), NULL); break; case TaskbarLayout::LimitSqueeze: default: newLayout = new LimitSqueezeTaskbarLayout(m_squeezeRatio, m_preferGrouping, m_layout->orientation(), NULL); } newLayout->takeFrom(m_layout); newLayout->setSpacing(m_layout->spacing()); newLayout->setMinimumRows(m_layout->minimumRows()); newLayout->setMaximumRows(m_layout->maximumRows()); newLayout->setFps(m_layout->fps()); newLayout->setAnimationSpeed(m_layout->animationSpeed()); newLayout->setExpandDuration(m_layout->expandDuration()); newLayout->setExpandedWidth(m_layout->expandedWidth()); newLayout->setAnimationsEnabled(m_layout->animationsEnabled()); newLayout->setContentsMargins(0, 0, 0, 0); newLayout->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); newLayout->setMaximumSize(INT_MAX, INT_MAX); connect( newLayout, SIGNAL(sizeHintChanged(Qt::SizeHint)), this, SIGNAL(sizeHintChanged(Qt::SizeHint))); m_layout = newLayout; setLayout(m_layout); } int cfgKeepExpanded = cg.readEntry("keepExpanded", (int) ExpandNone); // input validation: switch (cfgKeepExpanded) { case ExpandNone: case ExpandActive: case ExpandCurrentDesktop: case ExpandAll: m_keepExpanded = (ExpandType) cfgKeepExpanded; break; default: kDebug() << "illegal value for keepExpanded: " << cfgKeepExpanded; m_keepExpanded = ExpandNone; } m_expandOnHover = cg.readEntry("expandOnHover", true); m_expandOnAttention = cg.readEntry("expandOnAttention", false); int cfgMiddleClickAction = cg.readEntry("middleClickAction", (int) NoAction); switch (cfgMiddleClickAction) { case NoAction: case CloseTask: case MoveToCurrentDesktop: m_middleClickAction = (MiddleClickAction) cfgMiddleClickAction; break; default: kDebug() << "illegal value for middleClickAction: " << cfgMiddleClickAction; m_middleClickAction = NoAction; } int cfgPreviewLayout = cg.readEntry("previewLayout", (int) ClassicPreviewLayout); // input validation: switch (cfgPreviewLayout) { case ClassicPreviewLayout: case NewPreviewLayout: m_previewLayout = (PreviewLayoutType) cfgPreviewLayout; emit previewLayoutChanged(m_previewLayout); break; default: kDebug() << "illegal value for previewLayout: " << cfgPreviewLayout; m_previewLayout = ClassicPreviewLayout; emit previewLayoutChanged(m_previewLayout); } m_maxPreviewSize = cg.readEntry("maxPreviewSize", 200); // input validation if (m_maxPreviewSize < 5) { m_maxPreviewSize = 5; } else if (m_maxPreviewSize > 500) { m_maxPreviewSize = 500; } m_tooltipMoveDuration = cg.readEntry("tooltipMoveDuration", 500); // input validation if (m_tooltipMoveDuration < 0) { m_tooltipMoveDuration = 0; } else if (m_tooltipMoveDuration > 2000) { m_tooltipMoveDuration = 2000; } m_highlightDelay = cg.readEntry("highlightDelay", 50); // input validation if (m_highlightDelay < 50) { m_highlightDelay = 50; } else if (m_highlightDelay > 1000) { m_highlightDelay = 1000; } m_hideTooltipAfterClick = cg.readEntry("hideTooltipAfterClick", true); m_dontRotateFrame = cg.readEntry("dontRotateFrame", false); m_onlyLights = cg.readEntry("onlyLights", true); m_textShadow = cg.readEntry("textShadow", true); m_lightColorFromIcon = cg.readEntry("lightColorFromIcon", true); m_scrollSwitchTasks = cg.readEntry("scrollSwitchTasks", true); m_expandedWidth = cg.readEntry("expandingSize", 175); m_minIconSpace = cg.readEntry("minIconSpace", 16); m_minButtonWidth = cg.readEntry("minButtonWidth", 0); m_maxButtonWidth = cg.readEntry("maxButtonWidth", 9999); m_layout->setExpandedWidth(m_expandedWidth); m_lightColor = cg.readEntry("lightColor", QColor(78, 196, 249, 200)); m_lightAnchorConfig.setAnchoredHorizontally(cg.readEntry("lightAnchorHorizontalEnabled", false)); m_lightAnchorConfig.setAnchorHorizontal(cg.readEntry("lightAnchorHorizontal", 50)); m_lightAnchorConfig.setAnchoredVertically(cg.readEntry("lightAnchorVerticalEnabled", false)); m_lightAnchorConfig.setAnchorVertical(cg.readEntry("lightAnchorVertical", 50)); m_layout->setExpandDuration(cg.readEntry("animationDuration", 175)); m_layout->setFps(cg.readEntry("fps", 25)); m_layout->setAnimationSpeed(cg.readEntry("animationSpeed", 2000.0)); m_frame->enableCustomMargins(cg.readEntry("taskButtonMarginsCustom", false)); m_frame->setCustomMargins( cg.readEntry("taskButtonMarginLeft", 3), cg.readEntry("taskButtonMarginTop", 3), cg.readEntry("taskButtonMarginRight", 3), cg.readEntry("taskButtonMarginBottom", 3) ); int cfgSortingStrategy = cg.readEntry("sortingStrategy", static_cast(TaskManager::GroupManager::AlphaSorting)); // input validation switch (cfgSortingStrategy) { case TaskManager::GroupManager::NoSorting: case TaskManager::GroupManager::ManualSorting: case TaskManager::GroupManager::AlphaSorting: case TaskManager::GroupManager::DesktopSorting: m_sortingStrategy = static_cast(cfgSortingStrategy); break; default: kDebug() << "illegal value for sorting strategy: " << cfgSortingStrategy; m_sortingStrategy = TaskManager::GroupManager::AlphaSorting; } int cfgGroupingStrategy = cg.readEntry("groupingStrategy", static_cast(TaskManager::GroupManager::ProgramGrouping)); switch (cfgGroupingStrategy) { case TaskManager::GroupManager::NoGrouping: case TaskManager::GroupManager::ProgramGrouping: m_groupingStrategy = static_cast(cfgGroupingStrategy); break; default: kDebug() << "illegal value for grouping strategy: " << cfgGroupingStrategy; m_groupingStrategy = TaskManager::GroupManager::ProgramGrouping; } m_groupManager->setOnlyGroupWhenFull(cg.readEntry("onlyGroupWhenFull", false)); m_groupManager->setSortingStrategy(m_sortingStrategy); m_groupManager->setGroupingStrategy(m_groupingStrategy); m_groupManager->setShowOnlyCurrentDesktop(cg.readEntry("showOnlyCurrentDesktop", false)); m_groupManager->setShowOnlyCurrentActivity(cg.readEntry("showOnlyCurrentActivity", false)); m_groupManager->setShowOnlyCurrentScreen(cg.readEntry("showOnlyCurrentScreen", false)); m_groupManager->setShowOnlyMinimized(cg.readEntry("showOnlyMinimized", false)); m_groupManager->reconnect(); m_groupManager->readLauncherConfig(); emit settingsChanged(); updateFullLimit(); } bool Applet::isPopupShowing() const { return m_toolTip->isShown(); } int Applet::animationDuration() const { return m_layout->expandDuration(); } int Applet::fps() const { return m_layout->fps(); } QRect Applet::currentScreenGeometry() const { /* Plasma::Containment *containment = this->containment(); if (containment) { return containment->corona()->screenGeometry(containment->screen()); } else { return containment->corona()->screenGeometry(-1); } */ QDesktopWidget* desktop = QApplication::desktop(); if (desktop == NULL) { kDebug() << "currentScreenGeometry(): desktop is NULL\n"; return QRect(); } QGraphicsView *view = this->view(); if (view == NULL) { kDebug() << "currentScreenGeometry(): view is NULL\n"; return desktop->screenGeometry(-1); } QWidget *viewport = view->viewport(); if (viewport == NULL) { kDebug() << "currentScreenGeometry(): viewport is NULL\n"; return desktop->screenGeometry(-1); } return desktop->screenGeometry(desktop->screenNumber(viewport)); } QRect Applet::virtualScreenGeometry() const { QDesktopWidget* desktop = QApplication::desktop(); if (desktop == NULL) { kDebug() << "virtualScreenGeometry(): desktop is NULL\n"; return QRect(); } QWidget *screen = desktop->screen(); if (screen == NULL) { kDebug() << "virtualScreenGeometry(): screen is NULL\n"; return desktop->screenGeometry(-1); } return screen->geometry(); } void Applet::popup(const QPoint& pos, Task *task, QObject *receiver, const char *slot) { TaskManager::BasicMenu *taskMenu = popup(task); if (taskMenu != NULL) { if (receiver != NULL) { connect(taskMenu, SIGNAL(aboutToHide()), receiver, slot); } taskMenu->popup(pos); } } void Applet::popup(const TaskItem* item) { TaskManager::BasicMenu *taskMenu = popup(item->task()); if (taskMenu != NULL) { taskMenu->popup(containment()->corona()->popupPosition(item, taskMenu->sizeHint())); } } TaskManager::BasicMenu* Applet::popup(Task *task) { QList actionList; QAction *configAction = action("configure"); if (configAction && configAction->isEnabled()) { actionList.append(configAction); } if (task && task->isValid()) { switch (task->type()) { case Task::TaskItem: return new TaskManager::BasicMenu( NULL, task->taskItem(), m_groupManager, actionList); case Task::GroupItem: return new TaskManager::BasicMenu( NULL, task->group(), m_groupManager, actionList); case Task::LauncherItem: return new TaskManager::BasicMenu( NULL, task->launcherItem(), m_groupManager, actionList); default: break; } } return NULL; } } // namespace SmoothTasks K_EXPORT_PLASMA_APPLET(smooth-tasks, SmoothTasks::Applet) #include "Applet.moc" plasma-widget-smooth-tasks/applet/SmoothTasks/ToolTipWidget.cpp000644 000765 000765 00000013353 11724514472 025614 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/ToolTipWidget.h" #include "SmoothTasks/WindowPreview.h" #include #include #include namespace SmoothTasks { const int ToolTipWidget::ANIMATION_MARGIN = 25; const int ToolTipWidget::SCROLL_DURATION = 5; ToolTipWidget::ToolTipWidget(SmoothToolTip* toolTip) : QWidget(), m_toolTip(toolTip) { setWindowFlags(Qt::ToolTip | Qt::WindowStaysOnTopHint); setWindowModality(Qt::NonModal); setAttribute(Qt::WA_TranslucentBackground); setMouseTracking(true); setAcceptDrops(true); setProperty("_KDE_NET_WM_SKIP_SHADOW", true); Plasma::WindowEffects::overrideShadow(winId(), true); QBoxLayout *layout = new QBoxLayout(toolTip->isVertical() ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight); layout->setContentsMargins(0, 0, 0, 0); setLayout(layout); } void ToolTipWidget::paintEvent(QPaintEvent *event) { QPainter painter(this); painter.setRenderHint(QPainter::Antialiasing); painter.setClipRect(event->rect()); painter.setCompositionMode(QPainter::CompositionMode_Source); painter.fillRect(rect(), Qt::transparent); m_toolTip->m_background->paintFrame(&painter); m_toolTip->updatePreviews(); } void ToolTipWidget::resizeEvent(QResizeEvent *event) { QWidget::resizeEvent(event); m_toolTip->m_background->resizeFrame(size()); if (Plasma::Theme::defaultTheme()->windowTranslucencyEnabled()) { Plasma::WindowEffects::enableBlurBehind(winId(), true, m_toolTip->m_background->mask()); clearMask(); } else { setMask(m_toolTip->m_background->mask()); } } void ToolTipWidget::enterEvent(QEvent *event) { m_toolTip->m_hover = true; event->accept(); } void ToolTipWidget::dragEnterEvent(QDragEnterEvent *event) { m_toolTip->m_hover = true; event->accept(); } void ToolTipWidget::leaveEvent(QEvent *event) { m_toolTip->leave(); event->accept(); } void ToolTipWidget::dragLeaveEvent(QDragLeaveEvent *event) { m_toolTip->leave(); event->accept(); } void ToolTipWidget::mousePressEvent(QMouseEvent *event) { m_toolTip->hide(); event->accept(); } void ToolTipWidget::mouseMoveEvent(QMouseEvent *event) { if (m_toolTip->m_scrollAnimation) { return; } const QRect screenGeom = m_toolTip->m_applet->currentScreenGeometry(); if (m_toolTip->m_applet->formFactor() == Plasma::Vertical) { const int height = this->height(); const int y = this->y(); const int mouseY = event->globalY(); const int screenTop = screenGeom.top(); const int screenBottom = screenTop + screenGeom.height(); if (!m_toolTip->m_scrollAnimation) { if (y < screenTop && mouseY - ANIMATION_MARGIN <= screenTop) { const int dy = screenTop - y; m_toolTip->startScrollAnimation(0, dy); } else if (y + height > screenBottom && mouseY + ANIMATION_MARGIN >= screenBottom) { const int dy = -(y + height - screenBottom); m_toolTip->startScrollAnimation(0, dy); } } else if ( mouseY > screenTop + ANIMATION_MARGIN && mouseY < screenBottom - ANIMATION_MARGIN) { m_toolTip->stopScrollAnimation(); } } else { const int width = this->width(); const int x = this->x(); const int mouseX = event->globalX(); const int screenLeft = screenGeom.left(); const int screenRight = screenLeft + screenGeom.width(); if (!m_toolTip->m_scrollAnimation) { if (x < screenLeft && mouseX - ANIMATION_MARGIN <= screenLeft) { const int dx = screenLeft - x; m_toolTip->startScrollAnimation(dx, 0); } else if (x + width > screenRight && mouseX + ANIMATION_MARGIN >= screenRight) { const int dx = -(x + width - screenRight); m_toolTip->startScrollAnimation(dx, 0); } } else if ( mouseX > screenLeft + ANIMATION_MARGIN && mouseX < screenRight - ANIMATION_MARGIN) { m_toolTip->stopScrollAnimation(); } } } void ToolTipWidget::hideEvent(QHideEvent *event) { Q_UNUSED(event); m_toolTip->m_previewsUpdated = false; m_toolTip->m_hover = false; m_toolTip->stopEffect(); } void ToolTipWidget::wheelEvent(QWheelEvent *event) { int newIndex; if (m_toolTip->m_previews.isEmpty()) { return; } else if (m_toolTip->m_hoverPreview == NULL) { newIndex = 0; } else if (m_toolTip->m_previews.size() == 1) { return; } else if (event->delta() < 0) { newIndex = m_toolTip->m_hoverPreview->index() + 1; if (newIndex >= m_toolTip->m_previews.size()) { newIndex = 0; } } else { newIndex = m_toolTip->m_hoverPreview->index() - 1; if (newIndex < 0) { newIndex = m_toolTip->m_previews.size() - 1; } } if (m_toolTip->m_hoverPreview) { m_toolTip->m_hoverPreview->hoverLeave(); } WindowPreview *preview = m_toolTip->m_previews[newIndex]; preview->hoverEnter(); m_toolTip->moveTo(preview, event->pos()); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/TaskbuttonFrameSvg.cpp000644 000765 000765 00000010421 11724514472 026640 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009-2010 Toni Dietze * * 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 "TaskbuttonFrameSvg.h" #include "Global.h" #include namespace SmoothTasks { TaskbuttonFrameSvg::TaskbuttonFrameSvg(QObject *parent) : Plasma::FrameSvg(parent), m_customMargins(false), m_customMarginLeft(0.0), m_customMarginTop(0.0), m_customMarginRight(0.0), m_customMarginBottom(0.0) { } void TaskbuttonFrameSvg::getMaximalMargins(qreal &left, qreal &top, qreal &right, qreal &bottom) { QString elementPrefixes[] = {ACTIVE, MINIMIZED, FOCUS, ATTENTION, HOVER, NORMAL}; setElementPrefix(elementPrefixes[0]); getMargins(left, top, right, bottom); for (unsigned i = 1; i < sizeof(elementPrefixes) / sizeof(QString); ++i) { setElementPrefix(elementPrefixes[i]); qreal l, t, r, b; getMargins(l, t, r, b); if (l > left ) left = l; if (t > top ) top = t; if (r > right ) right = r; if (b > bottom) bottom = b; } } QRectF TaskbuttonFrameSvg::minimalContentsRect() { QString elementPrefixes[] = {ACTIVE, MINIMIZED, FOCUS, ATTENTION, HOVER, NORMAL}; setElementPrefix(elementPrefixes[0]); QRectF contentsRect(this->contentsRect()); for (unsigned i = 1; i < sizeof(elementPrefixes) / sizeof(QString); ++i) { setElementPrefix(elementPrefixes[i]); contentsRect &= this->contentsRect(); } return contentsRect; } void TaskbuttonFrameSvg::getMaximalMarginsCustom(qreal &left, qreal &top, qreal &right, qreal &bottom) { if (m_customMargins) { getMarginsCustom(left, top, right, bottom); } else { getMaximalMargins(left, top, right, bottom); } } QRectF TaskbuttonFrameSvg::minimalContentsRectCustom() { if (m_customMargins) { return contentsRectCustom(); } else { return minimalContentsRect(); } } void TaskbuttonFrameSvg::setCustomMargins(const qreal &left, const qreal &top, const qreal &right, const qreal &bottom) { m_customMarginLeft = left; m_customMarginTop = top; m_customMarginRight = right; m_customMarginBottom = bottom; } qreal TaskbuttonFrameSvg::customMarginSize(const Plasma::MarginEdge edge) const { switch(edge) { case Plasma::LeftMargin : return m_customMarginLeft ; break; case Plasma::TopMargin : return m_customMarginTop ; break; case Plasma::RightMargin : return m_customMarginRight ; break; case Plasma::BottomMargin: return m_customMarginBottom; break; } return 0.0; } void TaskbuttonFrameSvg::enableCustomMargins(const bool &enable) { m_customMargins = enable; } QRectF TaskbuttonFrameSvg::contentsRectCustom() const { if (m_customMargins) { QSizeF size = ::Plasma::FrameSvg::frameSize(); return QRectF( m_customMarginLeft, m_customMarginTop, size.width() - m_customMarginLeft - m_customMarginRight, size.height() - m_customMarginTop - m_customMarginBottom ); } else { return ::Plasma::FrameSvg::contentsRect(); } } void TaskbuttonFrameSvg::getMarginsCustom(qreal &left, qreal &top, qreal &right, qreal &bottom) const { if (m_customMargins) { left = m_customMarginLeft; top = m_customMarginTop; right = m_customMarginRight; bottom = m_customMarginBottom; } else { ::Plasma::FrameSvg::getMargins(left, top, right, bottom); } } qreal TaskbuttonFrameSvg::marginSizeCustom(const Plasma::MarginEdge edge) const { if (m_customMargins) { return customMarginSize(edge); } else { return ::Plasma::FrameSvg::marginSize(edge); } } }plasma-widget-smooth-tasks/applet/SmoothTasks/TaskbarLayout.cpp000644 000765 000765 00000065146 11724514472 025652 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 #include #include #include #include #include #include #include #include "SmoothTasks/Applet.h" #include "SmoothTasks/TaskbarLayout.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/Global.h" namespace SmoothTasks { TaskbarItem::~TaskbarItem() { if (item) { item->setParentLayoutItem(NULL); if (item->ownedByLayout()) { delete item; } } } const qreal TaskbarLayout::PIXELS_PER_SECOND = 500; TaskbarLayout::TaskbarLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent) : QGraphicsLayout(parent), m_draggedItem(NULL), m_currentIndex(-1), m_mouseIn(false), m_orientation(orientation), m_spacing(0.0), m_animationTimer(new QTimer(this)), m_grabPos(), m_fps(35), m_animationsEnabled(true), m_minimumRows(1), m_maximumRows(6), m_expandedWidth(175), m_expandDuration(160), m_preferredSizeChanged(false), m_cellHeight(1.0), m_rows(1) { m_animationTimer->setInterval(1000 / m_fps); connect(m_animationTimer, SIGNAL(timeout()), this, SLOT(animate())); } // more or less copied from QGraphicsLinearLayout TaskbarLayout::~TaskbarLayout() { clear(); } void TaskbarLayout::setOrientation(Qt::Orientation orientation) { if (orientation != m_orientation) { m_orientation = orientation; foreach (TaskbarItem *item, m_items) { item->item->setOrientation(orientation); } invalidate(); } } void TaskbarLayout::setSpacing(qreal spacing) { if (spacing < 0) { qWarning("TaskbarLayout::setSpacing: invalid spacing %g", spacing); return; } if (spacing != m_spacing) { m_spacing = spacing; invalidate(); } } void TaskbarLayout::setFps(int fps) { if (fps <= 0) { qWarning("TaskbarLayout::setFps: invalid fps %d", fps); return; } if (m_fps != fps) { m_fps = fps; m_animationTimer->setInterval(1000 / m_fps); } } void TaskbarLayout::setAnimationSpeed(qreal animationSpeed) { if (animationSpeed <= 0) { qWarning("TaskbarLayout::setFps: invalid fps %f", animationSpeed); return; } m_animationSpeed = animationSpeed; } void TaskbarLayout::setAnimationsEnabled(bool animationsEnabled) { m_animationsEnabled = animationsEnabled; if (!animationsEnabled) { skipAnimation(); } } void TaskbarLayout::setMaximumRows(int maximumRows) { if (maximumRows < 1) { qWarning("TaskbarLayout::setMaximumRows: invalid maximumRows %d", maximumRows); return; } if (maximumRows != m_maximumRows) { m_maximumRows = maximumRows; if (m_minimumRows > maximumRows) { m_minimumRows = maximumRows; } invalidate(); } } void TaskbarLayout::setMinimumRows(int minimumRows) { if (minimumRows < 1) { qWarning("TaskbarLayout::setMinimumRows: invalid minimumRows %d", minimumRows); return; } if (minimumRows != m_minimumRows) { m_minimumRows = minimumRows; if (m_maximumRows < minimumRows) { m_maximumRows = minimumRows; } invalidate(); } } void TaskbarLayout::setRowBounds(int minimumRows, int maximumRows) { if (minimumRows < 1) { qWarning("TaskbarLayout::setRowBounds: invalid minimumRows %d", minimumRows); return; } if (minimumRows > maximumRows) { qWarning( "TaskbarLayout::setRowBounds: invalid row bounds: minimumRows: %d, maximumRows: %d", minimumRows, maximumRows); return; } if (minimumRows != m_minimumRows || maximumRows != m_maximumRows) { m_minimumRows = minimumRows; m_maximumRows = maximumRows; invalidate(); } } void TaskbarLayout::setExpandedWidth(qreal expandedWidth) { if (expandedWidth < 0.0) { qWarning("TaskbarLayout::setExpandedSize: invalid expandedWidth %g", expandedWidth); return; } if (expandedWidth != m_expandedWidth) { m_expandedWidth = expandedWidth; invalidate(); } } void TaskbarLayout::setExpandDuration(int expandDuration) { if (expandDuration < 0) { qWarning("TaskbarLayout::setExpandDuration: invalid expandDuration %d", expandDuration); return; } if (expandDuration != m_expandDuration) { m_expandDuration = expandDuration; } } QSizeF TaskbarLayout::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const { switch (which) { case Qt::MinimumSize: return QSizeF(0.0, 0.0); case Qt::PreferredSize: // the value gets cached by effectiveSizeHint() { QSizeF rdConstraint; swapRdAndWorldSize(constraint, rdConstraint, m_orientation == Qt::Vertical); qreal maxRdHeigt = rdConstraint.height() > 0 ? rdConstraint.height() : std::numeric_limits::infinity(); qreal maxItemRdHeight; qreal rdWithSum = comulativePreferredItemRdWidthStatic(maxRdHeigt, true, 0, &maxItemRdHeight); rdWithSum += qMax(0.0, (qreal) (m_items.count() - minimumRows()) * m_spacing); QSizeF preferredSize = QSizeF(rdWithSum / (qreal) minimumRows(), (qreal) minimumRows() * maxItemRdHeight); swapRdAndWorldSize(preferredSize, preferredSize, m_orientation == Qt::Vertical); qreal left = 0, top = 0, right = 0, bottom = 0; getContentsMargins(&left, &top, &right, &bottom); preferredSize.setWidth(preferredSize.width() + left + right); preferredSize.setHeight(preferredSize.height() + top + bottom); qDebug() << "TaskbarLayout::sizeHint(Qt::PreferredSize," << constraint << ")" << preferredSize; return preferredSize; } case Qt::MaximumSize: return QSizeF(std::numeric_limits::max(), std::numeric_limits::max()); case Qt::MinimumDescent: return QSizeF(0.0, 0.0); default: break; } return QSizeF(); } void TaskbarLayout::setGeometry(const QRectF& rect) { if (rect != geometry()) qDebug() << "TaskbarLayout::setGeometry" << rect << "(old:" << geometry() << ")"; else qDebug() << "TaskbarLayout::setGeometry" << rect; static bool skipAni = false; skipAni = skipAni || (rect != geometry()); QGraphicsLayout::setGeometry(rect); static bool geometryIsSet; geometryIsSet = false; if (m_preferredSizeChanged) { m_preferredSizeChanged = false; emit sizeHintChanged(Qt::PreferredSize); // maybe this emit causes another call of setGeometry // but then geometryIsSet will be true such that // the layouting is not done twice } if (geometryIsSet) return; updateLayoutStatic (); updateLayoutDynamic(); if (skipAni) { skipAni = false; skipAnimation(); } geometryIsSet = true; } QRectF TaskbarLayout::effectiveGeometry() const { QRectF effectiveRect(geometry()); qreal left = 0, top = 0, right = 0, bottom = 0; getContentsMargins(&left, &top, &right, &bottom); if (QApplication::isRightToLeft()) { if (m_orientation == Qt::Vertical) { qSwap(top, bottom); } else { qSwap(left, right); } } effectiveRect.adjust(+left, +top, -right, -bottom); return effectiveRect; } qreal TaskbarLayout::comulativePreferredItemRdWidthStatic(const qreal maxRdHeight, const bool decomposeGroups, int *const count, qreal* maxItemRdHeight) const { int cnt = 0; qreal sum = 0.0; qreal maxHeight = 0.0; foreach (TaskbarItem* item, m_items) { if (decomposeGroups && item->item->abstractGroupableItem()->isGroupItem()) { Applet& applet = *item->item->applet(); foreach(TaskManager::AbstractGroupableItem* subitem, static_cast(item->item->abstractGroupableItem())->members()) { QSizeF size = TaskItem::preferredRdSizeStatic(*subitem, applet, *applet.frame(), m_orientation, maxRdHeight); sum += size.width(); if (size.height() > maxHeight) maxHeight = size.height(); ++cnt; } } else { QSizeF size = item->item->preferredRdSizeStatic(maxRdHeight); sum += size.width(); if (size.height() > maxHeight) maxHeight = size.height(); ++cnt; } } if (count) *count = cnt; if (maxItemRdHeight) *maxItemRdHeight = maxHeight; return sum; } qreal TaskbarLayout::averagePreferredItemRdWidthStatic(const qreal maxRdHeight, const bool decomposeGroups, int *const count, qreal* maxItemRdHeight) const { int cnt; qreal averageItemRdWidth = comulativePreferredItemRdWidthStatic(maxRdHeight, decomposeGroups, &cnt, maxItemRdHeight); if (cnt > 0) averageItemRdWidth /= (qreal) cnt; if (averageItemRdWidth < 1.0) averageItemRdWidth = 1.0; if (count) *count = cnt; return averageItemRdWidth; } void TaskbarLayout::buildRows(const int itemsPerRow, QList& rowInfos, int& rows) const { const int N = m_items.size(); rowInfos.clear(); int startIndex = 0; int endIndex = 0; for (int row = 0; row < rows && endIndex < N; ++ row) { startIndex = endIndex; if (row + 1 == rows) { endIndex = N; } else { endIndex = qMin(startIndex + itemsPerRow, N); } rowInfos.append(RowInfo(startIndex, endIndex)); } // if we assumed expanded there still might be empty row // therefore just scale up the layout (maybe do only this and not the other way of row removal) rows = qMax(m_minimumRows, rowInfos.size()); } void TaskbarLayout::updateItemsRowCache() { int rows = m_rowInfos.size(); for (int row = 0; row < rows; ++row) { int start = m_rowInfos[row].startIndex; int end = m_rowInfos[row].endIndex; for (int i = start; i < end; ++i) m_items[i]->row = row; } } void TaskbarLayout::rdToWorld(const QRectF& src, QRectF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const { if (rtl) { if (isVertical) { // rtl and vertical dst.setRect(effectiveRect.left() + src.top(), effectiveRect.top() + src.left(), src.height(), src.width()); } else { // rtl dst.setRect(effectiveRect.right() - src.right(), effectiveRect.top() + src.top(), src.width(), src.height()); } } else { if (isVertical) { // vertical dst.setRect(effectiveRect.left() + src.top(), effectiveRect.bottom() - src.right(), src.height(), src.width()); } else { // normal dst.setRect(effectiveRect.left() + src.left(), effectiveRect.top() + src.top(), src.width(), src.height()); } } } void TaskbarLayout::rdToWorld(const QPointF& src, QPointF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const { if (rtl) { if (isVertical) { // rtl and vertical dst.setX(effectiveRect.left() + src.y()); dst.setY(effectiveRect.top() + src.x()); } else { // rtl dst.setX(effectiveRect.right() - src.x()); dst.setY(effectiveRect.top() + src.y()); } } else { if (isVertical) { // vertical dst.setX(effectiveRect.left() + src.y()); dst.setY(effectiveRect.bottom() - src.x()); } else { // normal dst.setX(effectiveRect.left() + src.x()); dst.setY(effectiveRect.top() + src.y()); } } } void TaskbarLayout::worldToRd(const QRectF& src, QRectF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const { if (rtl) { if (isVertical) { // rtl and vertical dst.setRect(src.top() - effectiveRect.top(), src.left() - effectiveRect.left(), src.height(), src.width()); } else { // rtl dst.setRect(effectiveRect.right() - src.right(), src.top() - effectiveRect.top(), src.width(), src.height()); } } else { if (isVertical) { // vertical dst.setRect(effectiveRect.bottom() - src.bottom(), src.left() - effectiveRect.left(), src.height(), src.width()); } else { // normal dst.setRect(src.left() - effectiveRect.left(), src.top() - effectiveRect.top(), src.width(), src.height()); } } } void TaskbarLayout::worldToRd(const QPointF& src, QPointF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const { if (rtl) { if (isVertical) { // rtl and vertical dst.setX(src.y() - effectiveRect.top()); dst.setY(src.x() - effectiveRect.left()); } else { // rtl dst.setX(effectiveRect.right() - src.x()); dst.setY(src.y() - effectiveRect.top()); } } else { if (isVertical) { // vertical dst.setX(effectiveRect.bottom() - src.y()); dst.setY(src.x() - effectiveRect.left()); } else { // normal dst.setX(src.x() - effectiveRect.left()); dst.setY(src.y() - effectiveRect.top()); } } } void TaskbarLayout::swapRdAndWorldSize(const QSizeF& src, QSizeF& dst, bool isVertical) const { dst = src; if (isVertical) dst.transpose(); } void TaskbarLayout::updateLayoutDynamic() { qDebug("TaskbarLayout::updateLayoutDynamic"); // before updating the geometries of the items set the properties // that might get read by the items in their event handlers: const bool isVertical = m_orientation == Qt::Vertical; const qreal spacing = m_spacing; const QRectF& effectiveRect = effectiveGeometry(); const qreal availableRdWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const bool rtl = QApplication::isRightToLeft(); // "rd" stands for "reading direction" qreal currentRdY = 0.0; for (int row = 0; row < m_rowInfos.size(); ++ row) { const RowInfo& rowInfo = m_rowInfos[row]; int rdWidthsSize = rowInfo.endIndex - rowInfo.startIndex; QVector rdWidths(rdWidthsSize); qreal rdWidthSum = 0; for (int index = rowInfo.startIndex; index < rowInfo.endIndex; ++ index) { qreal rdWidth; if (m_draggedItem) rdWidth = m_items[index]->item->preferredRdSizeStatic(m_cellHeight).width(); else rdWidth = m_items[index]->item->preferredRdWidthDynamic(m_cellHeight); rdWidths[index - rowInfo.startIndex] = rdWidth; rdWidthSum += rdWidth; } qreal currentSpacing = spacing; qreal rowSpacings = (rowInfo.endIndex - rowInfo.startIndex - 1) * currentSpacing; qreal availableRdWidthSum = availableRdWidth - rowSpacings; if (availableRdWidthSum <= 0) { if (availableRdWidth > 0) availableRdWidthSum = availableRdWidth; else availableRdWidthSum = 0; currentSpacing = 0; rowSpacings = 0; } // calculate fitting rdWidths rdWidthSum = ::SmoothTasks::squeezeWidths(rdWidths, availableRdWidthSum); // apply rdWidths qreal currentRdX = 0; for (int index = rowInfo.startIndex; index < rowInfo.endIndex; ++ index) { TaskbarItem *item = m_items[index]; int i = index - rowInfo.startIndex; if (!item->item->isVisible()) { qDebug() << "new task button:" << item->item->task()->text(); if (i > 0) { QRectF geo(m_items[index - 1]->item->geometry()); worldToRd(geo, geo, effectiveRect, rtl, isVertical); geo.setRect(geo.right() + 0.5 * currentSpacing, geo.top(), 1.0, m_cellHeight); rdToWorld(geo, geo, effectiveRect, rtl, isVertical); item->item->setGeometry(geo); } else { QRectF geo(0.0, 0.0, 1.0, m_cellHeight); rdToWorld(geo, geo, effectiveRect, rtl, isVertical); item->item->setGeometry(geo); } item->item->setVisible(true); } QRectF targetRect(currentRdX, currentRdY, rdWidths[i], m_cellHeight); rdToWorld(targetRect, targetRect, effectiveRect, rtl, isVertical); if (m_draggedItem == item) { targetRect.moveTo(item->item->pos()); item->item->setGeometry(targetRect); } item->item->setAnimationTargetGeometry(targetRect); currentRdX += rdWidths[i] + currentSpacing; } currentRdY += m_cellHeight + spacing; } startAnimation(); } void TaskbarLayout::preferredItemSizeStaticChange(TaskItem* item) { Q_UNUSED(item); qDebug("TaskbarLayout::preferredItemSizeStaticChange"); m_preferredSizeChanged = true; invalidate(); } void TaskbarLayout::preferredItemSizeDynamicChange(TaskItem* item) { Q_UNUSED(item); qDebug("TaskbarLayout::preferredItemSizeDynamicChange"); if (m_draggedItem) return; updateLayoutDynamic(); } TaskItem *TaskbarLayout::itemAt(int index) const { if (index < 0 || index >= m_items.size()) { qWarning("TaskbarLayout::itemAt: invalid index %d", index); return NULL; } return m_items[index]->item; } int TaskbarLayout::addItem(TaskItem *item) { const int index = count(); insertItem(index, item); return index; } void TaskbarLayout::insertItem(int index, TaskItem *item) { if (!item) { qWarning("TaskbarLayout::insertItem: cannot insert null item"); return; } if (indexOf(item) != -1) { qWarning("TaskbarLayout::insertItem: cannot instert same item twice"); return; } item->setVisible(false); // make the button invisible until it gets a valid resonable in updateLayoutDynamic() item->setParentLayoutItem(this); TaskbarItem *titem = new TaskbarItem(item); m_items.insert(index, titem); item->setOrientation(m_orientation); connectItem(item); invalidate(); } void TaskbarLayout::connectItem(TaskItem *item) { connect(item, SIGNAL(preferredSizeStaticChange(TaskItem*)), this, SLOT(preferredItemSizeStaticChange(TaskItem*))); connect(item, SIGNAL(preferredSizeDynamicChange(TaskItem*)), this, SLOT(preferredItemSizeDynamicChange(TaskItem*))); } void TaskbarLayout::move(int fromIndex, int toIndex) { if (fromIndex < 0 || fromIndex >= m_items.size()) { qWarning("TaskbarLayout::move: invalid fromIndex %d", fromIndex); return; } if (toIndex < 0 || toIndex >= m_items.size()) { qWarning("TaskbarLayout::move: invalid toIndex %d", toIndex); return; } m_items.move(fromIndex, toIndex); invalidate(); } void TaskbarLayout::removeAt(int index) { if (index < 0 || index >= m_items.size()) { qWarning("TaskbarLayout::removeAt: invalid index %d", index); return; } TaskbarItem *item = m_items.takeAt(index); if (m_draggedItem == item) { m_currentIndex = -1; m_draggedItem = NULL; } disconnectItem(item->item); delete item; invalidate(); } void TaskbarLayout::removeItem(TaskItem *item) { if (item == NULL) { qWarning("TaskbarLayout::removeItem: cannot remove null item"); return; } removeAt(indexOf(item)); } TaskItem *TaskbarLayout::itemAt(const QPointF& pos) const { const qreal halfSpacing = m_spacing * 0.5; foreach (TaskbarItem *item, m_items) { QRectF rect = item->item->geometry(); qreal y = rect.y(); qreal x = rect.x(); if ( pos.y() >= (y - halfSpacing) && pos.y() < (y + rect.height() + halfSpacing) && pos.x() >= (x - halfSpacing) && pos.x() < (x + rect.width() + halfSpacing)) { return item->item; } } return NULL; } int TaskbarLayout::rowOf(TaskItem *item) const { if (item == NULL) { qWarning("TaskbarLayout::rowOf: item cannot be null"); return -1; } foreach (TaskbarItem* titem, m_items) { if (titem->item == item) { return titem->row; } } qWarning("TaskbarLayout::rowOf: not a child item"); return -1; } int TaskbarLayout::rowOf(int index) const { if (index < 0 || index >= m_items.size()) { qWarning("TaskbarLayout::rowOf: invalid index %d", index); return -1; } return m_items[index]->row; } int TaskbarLayout::rowOf(const QPointF& pos) const { qDebug() << "TaskbarLayout::rowOf" << pos << " m_rows = " << m_rows; QRectF effectiveRect(effectiveGeometry()); if (m_orientation == Qt::Vertical) { qreal x = pos.x(); if (x <= effectiveRect.left()) { return 0; } else if (x >= effectiveRect.right() || effectiveRect.width() == 0) { return m_rows - 1; } else { return (int) ((x - effectiveRect.left()) * m_rows / effectiveRect.width()); } } else { qreal y = pos.y(); if (y <= effectiveRect.top()) { return 0; } else if (y >= effectiveRect.bottom() || effectiveRect.height() == 0) { return m_rows - 1; } else { return (int) ((y - effectiveRect.top()) * m_rows / effectiveRect.height()); } } } int TaskbarLayout::indexOf(const QPointF& pos, int *rowPtr, bool *overLeftPartPtr) const { const QRectF effectiveRect(effectiveGeometry()); const int row = rowOf(pos); const bool isVertical = m_orientation == Qt::Vertical; if (row >= m_rowInfos.size()) { if (rowPtr ) *rowPtr = qMax(0, m_rowInfos.size() - 1); if (overLeftPartPtr) *overLeftPartPtr = false; return qMax(0, m_items.size() - 1); } const qreal rdPosX = isVertical ? pos.y() : pos.x(); qreal minDistance = std::numeric_limits::infinity(); int index = m_rowInfos[row].startIndex; bool overLeftPart = !QApplication::isRightToLeft(); for (int i = m_rowInfos[row].startIndex; i < m_rowInfos[row].endIndex; ++i) { if (m_items[i] == m_draggedItem) continue; const QRectF animationTargetGeometry = m_items[i]->item->animationTargetGeometry(); qreal rdItemPosX = isVertical ? animationTargetGeometry.bottom() : animationTargetGeometry.left(); qreal distance = std::abs(rdItemPosX - rdPosX); if (minDistance > distance) { minDistance = distance; index = i; overLeftPart = true; } rdItemPosX = isVertical ? animationTargetGeometry.top() : animationTargetGeometry.right(); distance = std::abs(rdItemPosX - rdPosX); if (minDistance > distance) { minDistance = distance; index = i; overLeftPart = false; } } if (QApplication::isRightToLeft()) overLeftPart = !overLeftPart; if (rowPtr ) *rowPtr = row; if (overLeftPartPtr) *overLeftPartPtr = overLeftPart; return index; } int TaskbarLayout::indexOf(TaskItem *item) const { const int N = m_items.size(); for (int index = 0; index < N; ++ index) { if (m_items[index]->item == item) { return index; } } return -1; } void TaskbarLayout::takeFrom(TaskbarLayout *other) { Q_ASSERT(other != NULL); if (other == this) { return; } m_currentIndex = other->m_currentIndex; m_draggedItem = other->m_draggedItem; m_mouseIn = other->m_mouseIn; m_grabPos = other->m_grabPos; m_items.append(other->m_items); foreach (TaskbarItem *item, other->m_items) { item->item->setParentLayoutItem(this); other->disconnectItem(item->item); connectItem(item->item); } other->m_draggedItem = NULL; other->m_currentIndex = -1; other->m_mouseIn = false; other->m_items.clear(); other->stopAnimation(); invalidate(); } int TaskbarLayout::dragItem(TaskItem *item, QDrag *drag, const QPointF& pos) { qDebug("TaskbarLayout::dragItem"); if (m_draggedItem != NULL) { qWarning("TaskbarLayout::dragItem: already dragging"); return -1; } int index = indexOf(item); if (index == -1) { qWarning("TaskbarLayout::dragItem: invalid item"); return -1; } m_mouseIn = true; m_draggedItem = m_items[index]; m_currentIndex = index; m_grabPos = pos - m_draggedItem->item->geometry().topLeft(); bool enabled = m_draggedItem->item->graphicsItem()->isEnabled(); m_draggedItem->item->graphicsItem()->setZValue(1); m_draggedItem->item->graphicsItem()->setEnabled(false); int dropIndex = index; if (drag->exec(Qt::MoveAction) == Qt::IgnoreAction || drag->target() == drag->source()) { dropIndex = currentDragIndex(); } // free item for layouting TaskbarItem* draggedItem = m_draggedItem; m_currentIndex = -1; m_draggedItem = NULL; if (draggedItem == NULL) { qDebug("TaskbarLayout::dragItem: item was deleted during dragging"); } else if (draggedItem->item != item) { qWarning( "TaskbarLayout::dragItem: dragged item changed during dragging!?\n" "This _might_ cause a memleak under some circumstances."); return -1; } else { draggedItem->item->graphicsItem()->setZValue(0); draggedItem->item->graphicsItem()->setEnabled(enabled); if (dropIndex >= 0) { // move dropped item animated to dest: invalidate(); } } return dropIndex; } void TaskbarLayout::moveDraggedItem(const QPointF& pos) { qDebug("TaskbarLayout::moveDraggedItem"); if (m_draggedItem == NULL) { return; } m_mouseIn = true; QRectF effectiveRect(effectiveGeometry()); QRectF rect(m_draggedItem->item->geometry()); if (m_grabPos.y() > rect.height()) { m_grabPos.setY(rect.height() * 0.5); } if (m_grabPos.x() > rect.width()) { m_grabPos.setX(rect.width() * 0.5); } QPointF newPos(pos - m_grabPos); if (newPos.y() < effectiveRect.top()) { newPos.setY(effectiveRect.top()); } else if (newPos.y() + rect.height() > effectiveRect.bottom()) { newPos.setY(effectiveRect.bottom() - rect.height()); } if (newPos.x() < effectiveRect.left()) { newPos.setX(effectiveRect.left()); } else if (newPos.x() + rect.width() > effectiveRect.right()) { newPos.setX(effectiveRect.right() - rect.width()); } rect.moveTopLeft(newPos); m_draggedItem->item->setGeometry(rect); m_draggedItem->item->setAnimationTargetGeometry(rect); int row; bool overLeftPart; int index = indexOf(pos, &row, &overLeftPart); if (index == m_currentIndex) { return; } else if (index < m_currentIndex) { if (!overLeftPart) index = qMax(0, qMin(m_items.size() - 1, index + 1)); } else { if (overLeftPart) index = qMax(0, index - 1); } if (index == m_currentIndex) return; qDebug() << "TaskbarLayout::moveDraggedItem()" << "from" << m_currentIndex << "to" << index; m_items.move(m_currentIndex, index); m_currentIndex = index; m_draggedItem->row = row; invalidate(); } void TaskbarLayout::dragLeave() { qDebug("TaskbarLayout::dragLeave"); if (m_draggedItem == NULL) { return; } m_mouseIn = false; startAnimation(); } void TaskbarLayout::animate() { qreal dt = 0.001 * (qreal) m_animationFrameTimer.restart(); bool stopAni = true; foreach (TaskbarItem *item, m_items) stopAni &= item->item->animateStep(m_animationSpeed, dt); if (stopAni) stopAnimation(); } void TaskbarLayout::disconnectItem(TaskItem *item) { disconnect(item, SIGNAL(preferredSizeStaticChange(TaskItem*)), this, SLOT(preferredItemSizeStaticChange(TaskItem*))); disconnect(item, SIGNAL(preferredSizeDynamicChange(TaskItem*)), this, SLOT(preferredItemSizeDynamicChange(TaskItem*))); } void TaskbarLayout::startAnimation() { if (m_animationsEnabled && !m_animationTimer->isActive()) { m_animationFrameTimer.start(); m_animationTimer->start(); } } void TaskbarLayout::stopAnimation() { m_animationTimer->stop(); } void TaskbarLayout::skipAnimation() { stopAnimation(); foreach (TaskbarItem *item, m_items) if (item != m_draggedItem || !m_mouseIn) item->item->skipAnimation(); } TaskItem *TaskbarLayout::draggedItem() const { if (m_draggedItem) { return m_draggedItem->item; } else { return NULL; } } void TaskbarLayout::clear(bool forceDeleteItems) { stopAnimation(); while (!m_items.isEmpty()) { TaskbarItem *item = m_items.takeLast(); TaskItem *titem = item->item; if (titem != NULL) { disconnectItem(titem); if (forceDeleteItems && !titem->ownedByLayout()) { delete titem; item->item = NULL; } } delete item; } if (m_draggedItem) { m_currentIndex = -1; m_draggedItem = NULL; } } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/LightAnchorConfig.h000644 000765 000765 00000004027 11724514472 026051 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009-2010 Toni Dietze * * 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 LIGHTANCHORCONFIG_H #define LIGHTANCHORCONFIG_H namespace SmoothTasks { class LightAnchorConfig { public: LightAnchorConfig(); void setAnchoredHorizontally(const bool isAnchoredHorizontally) { m_isAnchoredHorizontally = isAnchoredHorizontally; } void setAnchoredVertically (const bool isAnchoredVertically ) { m_isAnchoredVertically = isAnchoredVertically ; } void setAnchorHorizontal (const int anchorHorizontal ) { m_anchorHorizontal = anchorHorizontal ; } void setAnchorVertical (const int anchorVertical ) { m_anchorVertical = anchorVertical ; } bool isAnchoredHorizontally() const { return m_isAnchoredHorizontally; } bool isAnchoredVertically () const { return m_isAnchoredVertically ; } int anchorHorizontal () const { return m_anchorHorizontal ; } int anchorVertical () const { return m_anchorVertical ; } private: bool m_isAnchoredHorizontally; bool m_isAnchoredVertically; int m_anchorHorizontal; int m_anchorVertical; }; } // namespace SmoothTasks #endif // LIGHTANCHORCONFIG_H plasma-widget-smooth-tasks/applet/SmoothTasks/FadedText.h000644 000765 000765 00000010143 11724514472 024365 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 SMOOTHTASKS_FADETEXT_H #define SMOOTHTASKS_FADETEXT_H #include #include #include #include class QAbstractAnimation; namespace SmoothTasks { class FadedText : public QWidget { Q_OBJECT Q_PROPERTY(QString text READ text WRITE setText) Q_PROPERTY(QTextOption textOption READ textOption WRITE setTextOption) Q_PROPERTY(int fadeWidth READ fadeWidth WRITE setFadeWidth) Q_PROPERTY(bool shadow READ shadow WRITE setShadow) // Q_PROPERTY(QTextOption::WrapMode wrapMode READ wrapMode WRITE setWrapMode) Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment) Q_PROPERTY(qreal scrollPosition READ scrollPosition WRITE setScrollPosition) public: const static int SCROLL_DURATION; const static int SCROLL_STOP_DURATION; const static int SCROLL_WAIT_AT_ENDS; const static int SCROLL_WAIT_AFTER_DRAG; FadedText(QWidget *parent = NULL, Qt::WindowFlags flags = 0) : QWidget(parent, flags), m_text(), m_textOption() { init(); } FadedText(const QString& text, QWidget *parent = NULL, Qt::WindowFlags flags = 0) : QWidget(parent, flags), m_text(text), m_textOption() { init(); } ~FadedText(); QSize sizeHint() const { return m_sizeHint; } QString text() const { return m_text; } QTextOption textOption() const { return m_textOption; } int fadeWidth() const { return m_fadeWidth; } bool shadow() const { return m_shadow; } QTextOption::WrapMode wrapMode() const { return m_textOption.wrapMode(); } Qt::Alignment alignment() const { return m_textOption.alignment(); } protected: void paintEvent(QPaintEvent * event); QSizeF layoutText(QTextLayout& layout) const; void drawTextLayout(QPainter& painter, const QTextLayout& layout, const QSizeF& textSize); void enterEvent(QEvent *event); void leaveEvent(QEvent *event); void resizeEvent(QResizeEvent *event); void changeEvent(QEvent *event); void mouseMoveEvent(QMouseEvent *event); void mousePressEvent(QMouseEvent *event); void mouseReleaseEvent(QMouseEvent *event); public slots: void setText(const QString& text); void setTextOption(const QTextOption& textOption); void setFadeWidth(int fadeWidth); void setShadow(bool shadow); void setWrapMode(QTextOption::WrapMode wrapMode); void setAlignment(Qt::Alignment alignment); private: void startScrollAnimation(int delay = 0); void stopScrollAnimation(); qreal scrollPosition() const { return m_animLeft; } void setScrollPosition(qreal position); enum DragState { NoDrag, BegunDrag, ConfirmedDrag }; void init(); void updateText(); int scrollDistance() const { return m_sizeHint.width() - width(); } static QPointF visualPos(Qt::LayoutDirection layoutDirection, const QRect& bounds, const QPointF& pos); QString m_text; QSize m_sizeHint; QTextOption m_textOption; int m_fadeWidth; bool m_shadow; // animation: qreal m_animLeft; int m_scrollOffset; QPointer m_scrollAnimation; // draging text: DragState m_dragState; int m_mouseX; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/SmoothToolTip.h000644 000765 000765 00000007276 11724514472 025316 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 SMOOTHTASKS_SMOOTHTOOLTIP_H #define SMOOTHTASKS_SMOOTHTOOLTIP_H #include #include #include #include #include #include #include #include #include #include #include #include #include "SmoothTasks/Animation/AnimationThrowPoint.h" #include "SmoothTasks/Applet.h" #include "SmoothTasks/DelayedToolTip.h" namespace SmoothTasks { class AnimationThrowPoint; class WindowPreview; class ToolTipWidget; class Task; class SmoothToolTip : public DelayedToolTip { Q_OBJECT friend class ToolTipWidget; friend class WindowPreview; public: SmoothToolTip(Applet *applet); ~SmoothToolTip(); Kind kind() const { return Smooth; } void hide(); void moveBesideTaskItem(bool forceAnimated); WindowPreview *hoverWindowPreview() { return m_hoverPreview; } const QPixmap& closeIcon() const { return m_closeIcon; } const QPixmap& hoverCloseIcon() const { return m_hoverCloseIcon; } bool previewsAvailable() const { return m_previewsAvailable; } void popup(const QPoint& point, Task *task); void highlightTask(WId winId); public slots: void stopEffect(); virtual void itemUpdate(TaskItem* item); virtual void popupMenuAboutToHide(); protected: virtual void showAction(bool animate); virtual void hideAction(); private slots: void updateTheme(); void previewLayoutChanged(Applet::PreviewLayoutType previewLayout); void previewWindowSizeChanged(); void enterWindowPreview(WindowPreview *preview); void leaveWindowPreview(WindowPreview *preview); void highlightDelayTimeout(); private: void updateToolTip(bool forceAnimated); void setTasks(TaskManager::ItemList tasks); void clear(); void leave(); void startScrollAnimation(int dx, int dy); void stopScrollAnimation(); void moveTo(WindowPreview *preview, const QPoint& mousePos); void updatePreviews(); bool isVertical() const; ToolTipWidget *m_widget; QList m_previews; bool m_previewsAvailable; Plasma::FrameSvg *m_background; bool m_hover; bool m_menuShown; bool m_previewsUpdated; WindowPreview *m_hoverPreview; QTimer *m_highlightDelay; bool m_highlighting; // animation: QPointer m_scrollAnimation; // close icon: QPixmap m_closeIcon; QPixmap m_hoverCloseIcon; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/ToolTipWidget.h000644 000765 000765 00000003431 11724514472 025255 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_TOOLTIPWIDGET_H #define SMOOTHTASKS_TOOLTIPWIDGET_H #include namespace SmoothTasks { class SmoothToolTip; class ToolTipWidget : public QWidget { Q_OBJECT friend class SmoothToolTip; protected: ToolTipWidget(SmoothToolTip* toolTip); private: SmoothToolTip *m_toolTip; static const int ANIMATION_MARGIN; static const int SCROLL_DURATION; protected: void paintEvent(QPaintEvent *event); void resizeEvent(QResizeEvent *event); void enterEvent(QEvent *event); void leaveEvent(QEvent *event); void mousePressEvent(QMouseEvent *event); void mouseMoveEvent(QMouseEvent *event); void hideEvent(QHideEvent *event); void wheelEvent(QWheelEvent *event); void dragEnterEvent(QDragEnterEvent *event); void dragLeaveEvent(QDragLeaveEvent *event); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/LimitSqueezeTaskbarLayout.cpp000644 000765 000765 00000011424 11724514472 030201 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Michal Odstrčil * Copyright (C) 2009 Mathias Panzenböck (minor contributions) * Copyright (C) 2009-2010 Toni Dietze * * 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 "SmoothTasks/LimitSqueezeTaskbarLayout.h" #include "Global.h" #include namespace SmoothTasks { void LimitSqueezeTaskbarLayout::setSqueezeRatio(qreal squeezeRatio) { if (m_squeezeRatio != squeezeRatio) { m_squeezeRatio = squeezeRatio; invalidate(); } } void LimitSqueezeTaskbarLayout::setPreferGrouping(bool preferGrouping) { if (m_preferGrouping != preferGrouping) { m_preferGrouping = preferGrouping; invalidate(); } } int LimitSqueezeTaskbarLayout::optimumCapacity() const { const QRectF effectiveRect(effectiveGeometry()); const bool isVertical = orientation() == Qt::Vertical; const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal spacing = this->spacing(); const int rows = m_preferGrouping ? minimumRows() : maximumRows(); return static_cast(rows) * (availableWidth + spacing) / (m_squeezeRatio * averagePreferredItemRdWidthStatic(m_cellHeight, true) + spacing); } void LimitSqueezeTaskbarLayout::updateLayoutStatic() { const bool isVertical = orientation() == Qt::Vertical; const QList& items = this->items(); const int N = items.size(); const QRectF effectiveRect(effectiveGeometry()); const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal availableHeight = isVertical ? effectiveRect.width() : effectiveRect.height(); const qreal spacing = this->spacing(); #define CELL_HEIGHT(ROWS) (((availableHeight + spacing) / ((qreal) (ROWS))) - spacing) // if there is nothing to layout fill in some dummy data and leave if (N == 0) { m_rows = minimumRows(); m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos.clear(); m_compression = 1.0; return; } QList rowInfos; int rows = std::ceil(m_squeezeRatio * (comulativePreferredItemRdWidthStatic(CELL_HEIGHT(minimumRows())) + (qreal) (N - minimumRows()) * spacing) / availableWidth); if (rows < minimumRows()) rows = minimumRows(); if (rows > maximumRows()) rows = maximumRows(); QVector itemRdWidths(N); { const qreal cellHeight = CELL_HEIGHT(rows); int i = 0; foreach (TaskbarItem* item, items) { itemRdWidths[i] = item->item->preferredRdSizeStatic(cellHeight).width(); ++i; } } qreal itemRdWidthsSum = ::SmoothTasks::squeezeWidths(itemRdWidths, (qreal) rows * availableWidth - (qreal) (N - rows) * spacing); { const int maxRowIndex = maximumRows() - 1; qreal currentRdWidth = -spacing; int currentRow = 0; int currentStartIndex = 0; for (int i = 0; i < N; ++i) { currentRdWidth += itemRdWidths[i] + spacing; if (currentRdWidth >= availableWidth) { if (currentRdWidth - availableWidth > 0.5 * itemRdWidths[i] && currentStartIndex != i) { // much overhang -> put on next row rowInfos.append(RowInfo(currentStartIndex, i)); currentStartIndex = i; currentRdWidth = itemRdWidths[i]; } else { // little overhang -> put on this row rowInfos.append(RowInfo(currentStartIndex, i + 1)); currentStartIndex = i + 1; currentRdWidth = -spacing; } ++currentRow; if (currentRow == maxRowIndex) break; } } if (currentStartIndex < N) { rowInfos.append(RowInfo(currentStartIndex, N)); } } // if we assumed expanded there still might be empty row // therefore just scale up the layout (maybe do only this and not the other way of row removal) m_rows = qMax(minimumRows(), rowInfos.size()); m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos = rowInfos; updateItemsRowCache(); m_compression = (itemRdWidthsSum + (qreal) (N - m_rows) * spacing) / (comulativePreferredItemRdWidthStatic(m_cellHeight) + (qreal) (N - m_rows) * spacing); #undef CELL_HEIGHT } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/TaskItem.cpp000644 000765 000765 00000114313 11724514472 024575 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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. * ***********************************************************************************/ // Smooth Tasks #include "TaskbuttonFrameSvg.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/Applet.h" #include "SmoothTasks/TaskIcon.h" #include "SmoothTasks/Light.h" #include "SmoothTasks/Global.h" #include "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/TaskbarLayout.h" // Qt #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // KDE #include #include #include #include #include #include #include #include #include #include // Plasma #include #include #include #include #include namespace SmoothTasks { const qreal TaskItem::MINIMIZED_TEXT_ALPHA = 0.85; const QString TaskItem::GROUP_EXPANDER_TOP = QString::fromLatin1("group-expander-top"); const QString TaskItem::GROUP_EXPANDER_RIGHT = QString::fromLatin1("group-expander-right"); const QString TaskItem::GROUP_EXPANDER_LEFT = QString::fromLatin1("group-expander-left"); const QString TaskItem::GROUP_EXPANDER_BOTTOM = QString::fromLatin1("group-expander-bottom"); TaskItem::TaskItem(AbstractGroupableItem *abstractItem, Applet *applet) : QGraphicsWidget(applet), m_applet(applet), m_icon(new TaskIcon(this)), m_task(new Task(abstractItem, this)), m_light(new Light(this)), m_abstractItem(abstractItem), m_activateTimer(NULL), m_updateTimer(new QTimer()), m_mouseIn(false), m_delayedMouseIn(false), m_stateAnimation(), m_orientation(Qt::Horizontal), m_updateScheduled(false), m_staticallyExpanded(false), m_dynamicallyExpanded(false) { qDebug("TaskItem::TaskItem"); connect(applet, SIGNAL(settingsChanged()), this, SLOT(settingsChanged())); m_icon->setIcon(m_task->icon()); m_updateTimer->setInterval(1000 / m_applet->fps()); connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(updateTimerTick())); setAcceptsHoverEvents(true); setAcceptDrops(true); // task signals connect(m_task, SIGNAL(update()), this, SLOT(update())); connect(m_task, SIGNAL(updateState()), this, SLOT(updateState())); connect(m_task, SIGNAL(textChanged()), this, SLOT(updateText())); connect(m_task, SIGNAL(updateToolTip()), this, SLOT(updateToolTip())); connect(m_task, SIGNAL(gotTask()), this, SLOT(publishIconGeometry())); // icon connect(m_icon, SIGNAL(update()), this, SLOT(update())); connect(m_task, SIGNAL(updateIcon(const QIcon&)), m_icon, SLOT(setIcon(const QIcon&))); // desktop changes connect(KWindowSystem::self(), SIGNAL(currentDesktopChanged(int)), this, SLOT(updateExpansion())); // light connect(m_light, SIGNAL(update()), this, SLOT(update())); m_preferredTextLayoutSize = ::SmoothTasks::preferredTextLayoutSize(m_task->text(), KGlobalSettings::taskbarFont()); updateState(); if (m_task->type() == Task::StartupItem) { m_icon->startStartupAnimation(500); m_light->startAnimation(Light::StartupAnimation, 500, -1); } if (abstractItem->itemType() == TaskManager::GroupItemType) { TaskManager::TaskGroup* group = static_cast(abstractItem); connect( group, SIGNAL(itemAdded(AbstractGroupableItem*)), this, SLOT(updateToolTip())); connect( group, SIGNAL(itemRemoved(AbstractGroupableItem*)), this, SLOT(updateToolTip())); } connect( &m_stateAnimation, SIGNAL(update()), this, SLOT(update())); } TaskItem::~TaskItem() { m_applet->toolTip()->itemDelete(this); m_updateTimer->deleteLater(); if (m_activateTimer) { delete m_activateTimer; m_activateTimer = NULL; } } void TaskItem::setOrientation(Qt::Orientation orientation) { m_orientation = orientation; } QSizeF TaskItem::preferredRdSizeStatic(const TaskManager::AbstractGroupableItem& abstractGroupableItem, const Applet& applet, TaskbuttonFrameSvg& taskbuttonFrameSvg, const Qt::Orientation& orientation, const qreal maxRdHeight, const TaskIcon* taskIcon, const QSizeF* preferredTextLayoutSize) { qreal l, t, r, b; taskbuttonFrameSvg.getMaximalMargins(l, t, r, b); qreal frameRdWidth, frameRdHeight; if (orientation == Qt::Vertical && !applet.dontRotateFrame()) { frameRdWidth = t + b; frameRdHeight = l + r; } else { frameRdWidth = l + r; frameRdHeight = t + b; } const QSizeF iconSize = taskIcon ? taskIcon->preferredRdSize(maxRdHeight - frameRdHeight, maxRdHeight) : TaskIcon::preferredRdSize(abstractGroupableItem.icon(), applet, orientation, maxRdHeight - frameRdHeight, maxRdHeight); qreal rdWidth = iconSize.width(); qreal rdHeight = iconSize.height(); const bool expandedStatic = isExpandedStatic(abstractGroupableItem, applet); if (expandedStatic) { QSizeF prefTextSize = preferredTextLayoutSize ? *preferredTextLayoutSize : ::SmoothTasks::preferredTextLayoutSize(abstractGroupableItem.name() /* TODO: is this sufficient her? see Task::text() */, KGlobalSettings::taskbarFont(), applet.maxButtonWidth()); rdWidth += 5 + prefTextSize.width(); // TODO: make text seperation variable rdHeight = qMax(rdHeight, prefTextSize.height()); } if (abstractGroupableItem.itemType() == TaskManager::GroupItemType) { QRectF expanderRec = expanderRect(abstractGroupableItem, applet, orientation, QRectF(0, 0, 0, 0)); rdWidth += expanderRec.width() + 5; // TODO: make text seperation variable rdHeight = qMax(rdHeight, expanderRec.height()); } rdWidth += frameRdWidth; rdHeight += frameRdHeight; if (rdWidth > applet.maxButtonWidth()) rdWidth = applet.maxButtonWidth(); if (rdWidth < applet.minButtonWidth() && expandedStatic) rdWidth = applet.minButtonWidth(); return QSizeF(rdWidth, rdHeight); } QSizeF TaskItem::preferredRdSizeStatic(const qreal maxRdHeight) const { return preferredRdSizeStatic(*m_abstractItem, *m_applet, *m_applet->frame(), m_orientation, maxRdHeight, m_icon, &m_preferredTextLayoutSize); } qreal TaskItem::preferredRdWidthDynamic(const qreal& rdHeight) const { if (isExpandedByHover()) return m_applet->expandedWidth(); else return preferredRdSizeStatic(rdHeight).width(); } bool TaskItem::isExpandedByHover() const { return m_dynamicallyExpanded && !m_staticallyExpanded; } bool TaskItem::isExpandedStatic() const { return m_staticallyExpanded; } bool TaskItem::isExpanded() const { return m_staticallyExpanded || m_dynamicallyExpanded; } void TaskItem::settingsChanged() { qDebug("TaskItem::settingsChanged"); m_updateTimer->setInterval(1000 / m_applet->fps()); updateText(); updateExpansion(); } bool TaskItem::isExpandedStatic(const TaskManager::AbstractGroupableItem& abstractGroupableItem, const Applet& applet) { if (applet.expandTasks() && abstractGroupableItem.itemType() != TaskManager::LauncherItemType) { switch (applet.keepExpanded()) { case Applet::ExpandNone : return false; case Applet::ExpandAll : return true; case Applet::ExpandCurrentDesktop: return abstractGroupableItem.isOnCurrentDesktop() || abstractGroupableItem.isOnAllDesktops(); case Applet::ExpandActive : return abstractGroupableItem.isActive(); } } return false; } void TaskItem::updateExpansion() { bool staticallyExpanded = false; bool dynamicallyExpanded = false; if (m_applet->expandTasks() && m_task->type() != Task::LauncherItem) { switch (m_applet->keepExpanded()) { case Applet::ExpandNone: staticallyExpanded = false; break; case Applet::ExpandAll: staticallyExpanded = true; break; case Applet::ExpandCurrentDesktop: staticallyExpanded = m_task->isOnCurrentDesktop() || m_task->isOnAllDesktops(); break; case Applet::ExpandActive: staticallyExpanded = m_task->isActive(); break; } dynamicallyExpanded = staticallyExpanded; if (!staticallyExpanded) { if (m_applet->expandOnHover() && m_delayedMouseIn) { dynamicallyExpanded = true; } if (m_applet->expandOnAttention() && m_task->demandsAttention()) { dynamicallyExpanded = true; } } } qDebug() << "TaskItem::updateExpansion" << " static:" << m_staticallyExpanded << "->" << staticallyExpanded << " dynamic:" << m_dynamicallyExpanded << "->" << dynamicallyExpanded; if (m_staticallyExpanded != staticallyExpanded) { m_staticallyExpanded = staticallyExpanded; m_dynamicallyExpanded = dynamicallyExpanded; emit preferredSizeStaticChange(this); } else if (m_dynamicallyExpanded != dynamicallyExpanded) { m_dynamicallyExpanded = dynamicallyExpanded; emit preferredSizeDynamicChange(this); } } void TaskItem::updateTimerTick() { if (m_updateScheduled) { QGraphicsWidget::update(); m_updateScheduled = false; } else { m_updateTimer->stop(); } } void TaskItem::update() { // limit framerate to configured value if (m_updateTimer->isActive()) { m_updateScheduled = true; } else { m_updateTimer->start(); QGraphicsWidget::update(); } } void TaskItem::updateToolTip() { m_applet->toolTip()->itemUpdate(this); } void TaskItem::setAnimationTargetGeometry(const QRectF& rect) { m_animationDestinationGeometry = rect; } QPointF TaskItem::pointAnimationStep(const QPointF& current, const QPointF& target, const qreal v, const qreal dt) { qreal dx = -target.x() + current.x(); qreal dy = -target.y() + current.y(); qreal l = std::sqrt(dx * dx + dy * dy); if (l <= 1.0) return target; // Wurf-Bewegung const qreal t0 = 0.0; qreal t = -std::sqrt((l + t0 * t0) / v) + t0 + dt; if (t >= 0.0) return target; qreal lNew = v * (t - t0) * (t - t0) - t0 * t0; lNew = lNew / l; // eine Division sparen dx = dx * lNew; dy = dy * lNew; return QPointF(target.x() + dx, target.y() + dy); // exponentielle Annäherung /*const qreal c = std::pow(0.5, 30); const qreal f = std::pow(c, dt); dx = f * dx; dy = f * dy; return QPointF(target.x() + dx, target.y() + dy);*/ } bool TaskItem::animateStep(const qreal v, qreal dt) { const QRectF geometryCurrent = geometry(); const QRectF& geometryTarget = m_animationDestinationGeometry; if (geometryCurrent != geometryTarget) { QRectF geometryNew( pointAnimationStep(geometryCurrent.topLeft(), geometryTarget.topLeft(), v, dt), pointAnimationStep(geometryCurrent.bottomRight(), geometryTarget.bottomRight(), v, dt) ); setGeometry(geometryNew); if (geometryNew != geometryTarget) return false; } return true; } void TaskItem::skipAnimation() { setGeometry(m_animationDestinationGeometry); } // XXX: for some reason sometimes this cannot find a parent view when // TaskItem width > heigth and shown in the plasmoidviewer QRect TaskItem::iconGeometry() const { if (!scene() || !boundingRect().isValid()) { return QRect(); } QRectF sceneBoundingRect(this->sceneBoundingRect()); QPointF scenePos(this->scenePos()); QGraphicsView *parentView = NULL; QGraphicsView *possibleParentView = NULL; // The following was taken from Plasma::Applet, // it doesn't make sense to make the item an applet, // and this was the easiest way around it. foreach (QGraphicsView *view, scene()->views()) { if (view->sceneRect().intersects(sceneBoundingRect) || view->sceneRect().contains(scenePos)) { if (view->isActiveWindow()) { parentView = view; break; } else { possibleParentView = view; } } } if (!parentView) { parentView = possibleParentView; if (!parentView) { return QRect(); } } QRect rect(parentView->mapFromScene( mapToScene(boundingRect())).boundingRect().adjusted(0, 0, 1, 1)); rect.moveTopLeft(parentView->mapToGlobal(rect.topLeft())); return rect; } void TaskItem::publishIconGeometry() { QRect iconRect(iconGeometry()); TaskManager::Task* task; TaskManager::GroupPtr group; switch (m_task->type()) { case Task::TaskItem: task = m_task->task(); if (task) { task->publishIconGeometry(iconRect); } break; case Task::GroupItem: group = m_task->group(); if (group) { foreach (TaskManager::AbstractGroupableItem *item, group->members()) { TaskManager::TaskItem *task = qobject_cast(item); if (task) { task->task()->publishIconGeometry(iconRect); } } } default: break; } } // XXX: this gets called to often! (still?) void TaskItem::updateState() { qDebug("TaskItem::updateState"); int newState = m_mouseIn ? TaskStateAnimation::Hover : TaskStateAnimation::Normal; //m_applet->sorting(this); publishIconGeometry(); m_icon->stopStartupAnimation(); m_light->stopAnimation(); if (m_task->demandsAttention()) { newState |= TaskStateAnimation::Attention; m_light->startAnimation(Light::AttentionAnimation, 900, 3); } else if (m_task->type() == Task::LauncherItem) { newState |= TaskStateAnimation::Launcher; } else if (m_task->isMinimized()) { newState |= TaskStateAnimation::Minimized; } else if (m_task->isActive()) { emit itemActive(this); newState |= TaskStateAnimation::Focus; } updateExpansion(); m_stateAnimation.setState(newState, m_applet->fps(), m_applet->animationDuration()); } void TaskItem::updateText() { qDebug("TaskItem::updateText"); QSizeF preferredTextLayoutSize(::SmoothTasks::preferredTextLayoutSize(m_task->text(), KGlobalSettings::taskbarFont(), m_applet->maxButtonWidth())); if (preferredTextLayoutSize.width() < m_preferredTextLayoutSize.width() - 10.0 // add a little toleranze (e.g. for play time counters in titles) || preferredTextLayoutSize.width() > m_preferredTextLayoutSize.width()) { m_preferredTextLayoutSize = preferredTextLayoutSize; qDebug() << "m_preferredTextLayoutSize changed to" << m_preferredTextLayoutSize; if (m_staticallyExpanded) emit preferredSizeStaticChange(this); else if (m_dynamicallyExpanded) emit preferredSizeDynamicChange(this); } if (isExpanded()) update(); } void TaskItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) { switch (m_task->type()) { case Task::TaskItem: case Task::GroupItem: m_applet->toolTip()->hide(); m_applet->popup(this); event->accept(); break; case Task::LauncherItem: m_applet->toolTip()->hide(); m_applet->popup(this); event->accept(); break; default: event->ignore(); } } void TaskItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { update(); event->accept(); // event->ignore(); } void TaskItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { if ( QPoint(event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)) .manhattanLength() < QApplication::startDragDistance()) { return; } m_applet->dragItem(this, event); } void TaskItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { TaskManager::Task* task; switch (event->button()) { case Qt::LeftButton: m_applet->toolTip()->hide(); publishIconGeometry(); switch (m_task->type()) { case Task::TaskItem: task = m_task->task(); if (task) { if (event->modifiers() == Qt::ControlModifier) { KUrl url = launcherUrl(m_task->abstractItem()); if (m_applet->groupManager()->launcherExists(url)) { new KRun(url, 0); } } else { task->activateRaiseOrIconify(); } } break; case Task::GroupItem: if (event->modifiers() == Qt::ControlModifier) { KUrl url = launcherUrl(m_task->abstractItem()); if (m_applet->groupManager()->launcherExists(url)) { new KRun(url, 0); } } else { activateOrIconifyGroup(); } // { // TaskManager::GroupPopupMenu *groupMenu = new TaskManager::GroupPopupMenu( // NULL, // m_task->group(), // m_applet->groupManager()); // groupMenu->exec(QCursor::pos()); // // delete groupMenu; // } break; case Task::LauncherItem: m_task->launcherItem()->launch(); break; default: break; } break; case Qt::MidButton: m_applet->middleClickTask(m_task->abstractItem()); default: break; } } KUrl TaskItem::launcherUrl(AbstractGroupableItem* item) { if (!item) return KUrl(); if (item->itemType() == TaskManager::TaskItemType) { TaskManager::TaskItem * t = qobject_cast(item); // Search for applications which are executable and case-insensitively match the windowclass of the task and // See http://techbase.kde.org/Development/Tutorials/Services/Traders#The_KTrader_Query_Language QString query = QString("exist Exec and ('%1' =~ Name)").arg(t->task()->classClass()); KService::List services = KServiceTypeTrader::self()->query("Application", query); if (!services.empty()) { return KUrl::fromPath((services[0]->entryPath())); } else { // No desktop-file was found, so try to find at least the executable // usually it's the lower cased window class class, but if that fails let's trust it QString path = KStandardDirs::findExe(t->task()->classClass().toLower()); if (path.isEmpty()) { path = KStandardDirs::findExe(t->task()->classClass()); } if (!path.isEmpty()) { return KUrl::fromPath(path); } } } else if (item->itemType() == TaskManager::GroupItemType) { TaskManager::TaskGroup * t = qobject_cast(item); // Strategy: try to return the first non-group item's launcherUrl, // failing that, try to return the launcherUrl of the first group // if any foreach (TaskManager::AbstractGroupableItem *i, t->members()) { if (i->itemType() != TaskManager::GroupItemType) { return launcherUrl(i); } } if (t->members().isEmpty()) { return KUrl(); } return launcherUrl(t->members().first()); } else { return KUrl(); } return KUrl(); } void TaskItem::activateOrIconifyGroup() { TaskManager::GroupPtr group = m_task->group(); if (group == NULL) { return; } bool includesActive = false; TaskManager::ItemList items(group->members()); int iconified = 0; foreach (TaskManager::AbstractGroupableItem *item, items) { TaskManager::TaskItem *task = qobject_cast(item); if (task) { if (task->task()->isIconified()) { ++ iconified; } if (task->task()->isActive()) { includesActive = true; } } } if (includesActive && items.size() - iconified > iconified) { // iconify foreach (TaskManager::AbstractGroupableItem *item, items) { TaskManager::TaskItem *task = qobject_cast(item); if (task) { task->task()->setIconified(true); } } } else { // activate QList winOrder(KWindowSystem::stackingOrder()); const int winCount = winOrder.size(); TaskManager::TaskItem* sortedItems[winCount]; std::memset(sortedItems, 0, sizeof(TaskManager::TaskItem*) * winCount); foreach (TaskManager::AbstractGroupableItem *item, items) { TaskManager::TaskItem *task = qobject_cast(item); if (task) { int index = winOrder.indexOf(task->task()->window()); if (index != -1) { sortedItems[index] = task; } } } for (int index = 0; index < winCount; ++ index) { TaskManager::TaskItem* task = sortedItems[index]; if (task) { task->task()->activate(); } } } } void TaskItem::activate() { TaskManager::Task* task; switch (m_task->type()) { case Task::TaskItem: task = m_task->task(); if (task) { task->activate(); } break; case Task::GroupItem: m_applet->toolTip()->quickShow(this); default: break; } } void TaskItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) { qDebug("TaskItem::dragEnterEvent"); if (event->mimeData()->hasFormat(TASK_ITEM)) { //event->ignore(); //ignore it so the taskbar gets the event event->acceptProposedAction(); return; } event->accept(); if (m_task->type() == Task::GroupItem) { m_stateAnimation.setState( m_stateAnimation.toState() | TaskStateAnimation::Hover, m_applet->fps(), m_applet->animationDuration()); /*if (m_applet->expandTasks()) { expandTask(); }*/ // TODO: check necessarity m_applet->toolTip()->quickShow(this); } else { if (!m_activateTimer) { m_activateTimer = new QTimer(this); m_activateTimer->setSingleShot(true); m_activateTimer->setInterval(DRAG_HOVER_DELAY); connect(m_activateTimer, SIGNAL(timeout()), this, SLOT(activate())); } m_activateTimer->start(); hoverEnterEvent(); } } void TaskItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event) { Q_UNUSED(event); if (m_activateTimer) { m_activateTimer->start(); } update(); m_applet->dragMoveEvent(pos() + event->pos()); } void TaskItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) { Q_UNUSED(event); if (m_activateTimer) { delete m_activateTimer; m_activateTimer = NULL; } hoverLeaveEvent(); } void TaskItem::dropEvent(QGraphicsSceneDragDropEvent *event) { if (m_activateTimer) { delete m_activateTimer; m_activateTimer = NULL; } m_applet->dropEvent(event); } void TaskItem::hoverMoveEvent(QGraphicsSceneHoverEvent* e) { update(); QGraphicsWidget::hoverMoveEvent(e); } void TaskItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event) { Q_UNUSED(event); hoverEnterEvent(); } void TaskItem::hoverEnterEvent() { m_mouseIn = true; m_stateAnimation.setState( m_stateAnimation.toState() | TaskStateAnimation::Hover, m_applet->fps(), m_applet->animationDuration()); } void TaskItem::confirmEnter() { m_delayedMouseIn = true; updateExpansion(); } void TaskItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) { Q_UNUSED(event); hoverLeaveEvent(); } void TaskItem::hoverLeaveEvent() { m_mouseIn = false; m_stateAnimation.setState( m_stateAnimation.toState() & ~TaskStateAnimation::Hover, m_applet->fps(), m_applet->animationDuration()); if (m_applet->toolTip()->hoverItem() != this) { updateExpansion(); } } void TaskItem::confirmLeave() { m_delayedMouseIn = false; updateExpansion(); } QPointF TaskItem::mapFromGlobal(const QPoint& point, bool *contained) const { QGraphicsScene *scene = this->scene(); if (scene == NULL) { if (contained) { *contained = false; } return QPointF(-1, -1); } foreach (QGraphicsView *view, scene->views()) { QPointF mapped(mapFromScene(view->mapToScene(view->mapFromGlobal(point)))); if (contains(mapped)) { if (contained) { *contained = true; } return mapped; } } if (contained) { *contained = false; } return QPointF(-1, -1); } void TaskItem::paint(QPainter *p, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); const QRectF bounds = boundingRect(); if (!bounds.isValid()) return; const bool isVertical = m_orientation == Qt::Vertical; const bool showFrame = m_task->type() != Task::LauncherItem; QRectF contentsRdRect; QRectF lightsRdRect; QRectF boundsRdRect; p->setRenderHint(QPainter::Antialiasing); // draw frame // TODO: cache frame in TaskItem? TaskbuttonFrameSvg *frame = m_applet->frame(); if (isVertical) { boundsRdRect.setRect(bounds.y(), bounds.x(), bounds.height(), bounds.width()); if (m_applet->dontRotateFrame()) { frame->resizeFrame(bounds.size()); if(showFrame) { drawFrame(p, frame); } contentsRdRect = frame->minimalContentsRect(); contentsRdRect.setRect(contentsRdRect.y(), bounds.right() - contentsRdRect.right(), contentsRdRect.height(), contentsRdRect.width()); lightsRdRect = frame->minimalContentsRectCustom(); lightsRdRect.setRect(lightsRdRect.y(), bounds.right() - lightsRdRect.right(), lightsRdRect.height(), lightsRdRect.width()); p->save(); p->rotate(-90); p->translate(-bounds.height(), 0); } else { p->save(); p->rotate(-90); p->translate(-bounds.height(), 0); frame->resizeFrame(QSizeF(bounds.height(), bounds.width())); if(showFrame) { drawFrame(p, frame); } contentsRdRect = frame->minimalContentsRect(); // frame->contentsRect(); lightsRdRect = frame->minimalContentsRectCustom(); } } else { boundsRdRect = bounds; frame->resizeFrame(bounds.size()); if(showFrame) { drawFrame(p, frame); } contentsRdRect = frame->minimalContentsRect(); // frame->contentsRect(); lightsRdRect = frame->minimalContentsRectCustom(); } if (!contentsRdRect.isValid()) return; // TODO: It would be nice if I could use p->setClipPath(), but it doesn't // seem to be possible to get a bounding path of a FrameSvg. // p->setClipRegion(frame->mask()); // draw light if (m_applet->lights() && lightsRdRect.isValid() && m_task->type() != Task::LauncherItem) { bool mouseIn = false; QPointF pos(mapFromGlobal(QCursor::pos(), &mouseIn)); m_light->paint(p, lightsRdRect, pos, mouseIn, isVertical); } QRectF expRect = expanderRect(contentsRdRect); // hack to leave space vor expander // does not work in vertical mode const bool rtl = QApplication::layoutDirection() == Qt::RightToLeft; m_icon->setRects ( contentsRdRect.adjusted(rtl ? expRect.width() : 0, 0, rtl ? 0 : -expRect.width(), 0) , boundsRdRect.adjusted(rtl ? expRect.width() : 0, 0, rtl ? 0 : -expRect.width(), 0) ); // draw text if (m_applet->expandTasks()) { const qreal textSep = 5; QRectF textRect(contentsRdRect); if (QApplication::isRightToLeft()) { textRect.setRight(contentsRdRect.right() - m_icon->rdSize().width() - textSep); textRect.setLeft(expRect.right()); } else { textRect.setLeft(contentsRdRect.left() + m_icon->rdSize().width() + textSep); textRect.setRight(expRect.left()); } drawText(p, textRect); } drawExpander(p, expRect.intersect(contentsRdRect)); if (isVertical) { p->restore(); } // draw icon m_icon->paint(p, m_stateAnimation.hover(), m_task->type() == Task::GroupItem); } void TaskItem::drawFrame(QPainter *p, Plasma::FrameSvg *frame) { // draw "layers": // hover // attention // focus // minimized // normal int animatedState = m_stateAnimation.animatedState(); int reachedUpState = m_stateAnimation.reachedUpState(); if (animatedState) { QPixmap pixmap; bool didPaint = false; int shownState = m_stateAnimation.shownState(); if (!reachedUpState) { frame->setElementPrefix(NORMAL); pixmap = frame->framePixmap(); didPaint = true; } if (shownState & TaskStateAnimation::Minimized && !(reachedUpState & ( TaskStateAnimation::Hover | TaskStateAnimation::Attention | TaskStateAnimation::Focus))) { frame->setElementPrefix(MINIMIZED); if (didPaint) { pixmap = Plasma::PaintUtils::transition( pixmap, frame->framePixmap(), m_stateAnimation.minimized()); } else { pixmap = frame->framePixmap(); didPaint = true; } } if (shownState & TaskStateAnimation::Focus && !(reachedUpState & ( TaskStateAnimation::Hover | TaskStateAnimation::Attention))) { frame->setElementPrefix(FOCUS); if (didPaint) { pixmap = Plasma::PaintUtils::transition( pixmap, frame->framePixmap(), m_stateAnimation.focus()); } else { pixmap = frame->framePixmap(); didPaint = true; } } if (shownState & TaskStateAnimation::Attention && !(reachedUpState & TaskStateAnimation::Hover)) { frame->setElementPrefix(ATTENTION); if (didPaint) { pixmap = Plasma::PaintUtils::transition( pixmap, frame->framePixmap(), m_stateAnimation.attention()); } else { pixmap = frame->framePixmap(); didPaint = true; } } if (shownState & TaskStateAnimation::Hover && !(m_applet->lights() && m_applet->onlyLights())) { frame->setElementPrefix(HOVER); if (didPaint) { pixmap = Plasma::PaintUtils::transition( pixmap, frame->framePixmap(), m_stateAnimation.hover()); } else { pixmap = frame->framePixmap(); didPaint = true; } } p->drawPixmap(QPoint(0, Plasma::TopMargin), pixmap); } else { if (reachedUpState & TaskStateAnimation::Hover && !(m_applet->lights() && m_applet->onlyLights())) { frame->setElementPrefix(HOVER); } else if (reachedUpState & TaskStateAnimation::Attention) { frame->setElementPrefix(ATTENTION); } else if (reachedUpState & TaskStateAnimation::Focus) { frame->setElementPrefix(FOCUS); } else if (reachedUpState & TaskStateAnimation::Minimized) { frame->setElementPrefix(MINIMIZED); } // else if (reachedUpState & TaskStateAnimation::Launcher) { // frame->setElementPrefix(MINIMIZED); // } else { frame->setElementPrefix(NORMAL); } frame->paintFrame(p); } } QColor TaskItem::textColor() const { QColor color; Plasma::Theme *theme = Plasma::Theme::defaultTheme(); int animatedState = m_stateAnimation.animatedState(); int reachedUpState = m_stateAnimation.reachedUpState(); if (animatedState) { // TODO: think about whether this makes sense // I think this can be simplified at least bool didPaint = false; int shownState = m_stateAnimation.shownState(); if (!reachedUpState) { color = theme->color(Plasma::Theme::TextColor); didPaint = true; } if (shownState & TaskStateAnimation::Minimized && !(reachedUpState & ( TaskStateAnimation::Hover | TaskStateAnimation::Attention | TaskStateAnimation::Focus))) { if (didPaint) { color.setAlphaF(1.0 - (1.0 - MINIMIZED_TEXT_ALPHA) * m_stateAnimation.minimized()); } else { color = theme->color(Plasma::Theme::TextColor); color.setAlphaF(MINIMIZED_TEXT_ALPHA); didPaint = true; } } if (shownState & TaskStateAnimation::Focus && !(reachedUpState & ( TaskStateAnimation::Hover | TaskStateAnimation::Attention))) { if (didPaint) { color = KColorUtils::mix( color, theme->color(Plasma::Theme::TextColor), m_stateAnimation.focus()); } else { color = theme->color(Plasma::Theme::TextColor); didPaint = true; } } if (shownState & TaskStateAnimation::Attention && !(reachedUpState & TaskStateAnimation::Hover)) { if (didPaint) { color = KColorUtils::mix( color, theme->color(Plasma::Theme::ButtonTextColor), m_stateAnimation.focus()); } else { color = theme->color(Plasma::Theme::ButtonTextColor); didPaint = true; } } if (shownState & TaskStateAnimation::Hover) { if (didPaint) { color = KColorUtils::mix( color, theme->color(Plasma::Theme::TextColor), m_stateAnimation.focus()); } else { color = theme->color(Plasma::Theme::TextColor); didPaint = true; } } } else if (reachedUpState & TaskStateAnimation::Hover) { color = theme->color(Plasma::Theme::TextColor); } else if (reachedUpState & TaskStateAnimation::Attention) { color = theme->color(Plasma::Theme::ButtonTextColor); } else if (reachedUpState & TaskStateAnimation::Focus) { color = theme->color(Plasma::Theme::TextColor); } else if (reachedUpState & TaskStateAnimation::Minimized) { color = theme->color(Plasma::Theme::TextColor); color.setAlphaF(MINIMIZED_TEXT_ALPHA); } else { color = theme->color(Plasma::Theme::TextColor); } return color; } void TaskItem::drawText(QPainter *p, const QRectF& contentsRect) { QColor color(textColor()); p->setPen(QPen(color, 1.0)); //const bool rtl = QApplication::isRightToLeft(); QTextLayout layout(m_task->text(), KGlobalSettings::taskbarFont()); QTextOption textOption(layout.textOption()); textOption.setTextDirection(QApplication::layoutDirection()); layout.setTextOption(textOption); QRectF textRect(contentsRect); QSizeF textSize(::SmoothTasks::layoutText(layout, contentsRect.size())); // Hack for plamsa layouts that define a to large margin: // This causes the text to be drawn over the painted button border // in case the text does not fit the available space. // However, the layouting function still uses the space where the // margins are subtracted so this should only make a difference // when the button is really thin and not even one line fits the // available space. if (contentsRect.height() <= textSize.height()) { qreal hackTextSize = textSize.height() + 1.0; textRect.setY(contentsRect.y() - hackTextSize * 0.5 + contentsRect.height() * 0.5); textRect.setHeight(hackTextSize); } drawTextLayout(p, layout, textRect, textSize, color); } void TaskItem::drawTextLayout(QPainter *painter, const QTextLayout& layout, const QRectF& rect, const QSizeF& textSize, const QColor& color) const { if (!rect.isValid()) return; QPixmap pixmap(std::ceil(rect.width()), std::ceil(rect.height())); pixmap.fill(Qt::transparent); QPainter p(&pixmap); p.setPen(painter->pen()); QFontMetrics fm(layout.font()); QPointF position(0, (rect.height() - textSize.height()) * 0.5 + (fm.tightBoundingRect(M).height() - fm.xHeight()) * 0.5); QLinearGradient alphaGradient(0, 0, 1, 0); alphaGradient.setCoordinateMode(QGradient::ObjectBoundingMode); const bool rtl = layout.textOption().textDirection() == Qt::RightToLeft; if (rtl) { alphaGradient.setColorAt(0, QColor(0, 0, 0, 0)); alphaGradient.setColorAt(1, QColor(0, 0, 0, 255)); } else { alphaGradient.setColorAt(0, QColor(0, 0, 0, 255)); alphaGradient.setColorAt(1, QColor(0, 0, 0, 0)); } QList fadeRects; const qreal fadeWidth = 30; // Draw each line in the layout for (int i = 0; i < layout.lineCount(); ++ i) { QTextLine line(layout.lineAt(i)); QPointF linePos(position); qreal textWidth = line.naturalTextWidth(); if (rtl) linePos.setX(rect.width() - textWidth); line.draw(&p, linePos); // Add a fade out rect to the list if the line is too long if (textWidth > rect.width()) fadeRects.append ( QRectF ( rtl ? 0 : rect.width() - fadeWidth , line.position().y() + linePos.y() , fadeWidth , line.height() ) ); } // Reduce the alpha in each fade out rect using the alpha gradient if (!fadeRects.isEmpty()) { p.setCompositionMode(QPainter::CompositionMode_DestinationIn); foreach (const QRectF &r, fadeRects) p.fillRect(r, alphaGradient); p.setCompositionMode(QPainter::CompositionMode_SourceOver); } p.end(); if (m_applet->textShadow()) { QImage shadow(pixmap.toImage()); Plasma::PaintUtils::shadowBlur(shadow, 2, (color.value() < 128 ? Qt::white : Qt::black)); painter->drawImage(rect.topLeft() + QPointF(1, 2), shadow); } painter->drawPixmap(rect.topLeft(), pixmap); } /** initially copied from KDEs Task plasmoid but substantially altered */ void TaskItem::drawExpander(QPainter *painter, const QRectF& expRect) const { if (m_task->type() == Task::GroupItem && expRect.isValid()) { QFont font(KGlobalSettings::smallestReadableFont()); QFontMetrics fm(font); TaskbuttonFrameSvg *itemBackground = m_applet->frame(); const QString& expElem(expanderElement()); QRectF textRect(expRect.left(), expRect.top(), expRect.width(), fm.height()); if (itemBackground->hasElement(expElem)) { QSizeF arrowSize(itemBackground->elementSize(expElem)); QRectF arrowRect( expRect.left() + expRect.width() * 0.5 - arrowSize.width() * 0.5, expRect.top(), arrowSize.width(), arrowSize.height()); switch (m_applet->location()) { case Plasma::TopEdge: case Plasma::LeftEdge: arrowRect.moveTop(arrowRect.top() + fm.height() + fm.leading()); break; case Plasma::BottomEdge: case Plasma::RightEdge: textRect.moveTop(textRect.top() + arrowSize.height()); break; default: if (m_orientation == Qt::Vertical) { arrowRect.moveTop(arrowRect.top() + fm.height() + fm.leading()); } else { textRect.moveTop(textRect.top() + arrowSize.height()); } } itemBackground->paint(painter, arrowRect, expElem); } else { textRect.moveTop(expRect.top() + expRect.height() * 0.5 - textRect.height() * 0.5); } painter->setFont(font); painter->drawText(textRect, Qt::AlignHCenter | Qt::AlignTop, QString::number(m_task->taskCount())); } } /** initially copied from KDEs Task plasmoid but substantially altered */ QRectF TaskItem::expanderRect(const TaskManager::AbstractGroupableItem& abstractGroupableItem, const Applet& applet, const Qt::Orientation& orientation, const QRectF& bounds) { if (!abstractGroupableItem.itemType() == TaskManager::GroupItemType) { if (QApplication::isLeftToRight()) { return QRectF(bounds.right(), bounds.top(), 0, 0); } else { return QRectF(bounds.left(), bounds.top(), 0, 0); } } QFontMetrics fm(KGlobalSettings::smallestReadableFont()); const TaskbuttonFrameSvg *itemBackground = applet.frame(); QSize arrowSize(itemBackground->elementSize(expanderElement(applet.location(), orientation))); QString text(QString::number(static_cast(abstractGroupableItem).members().size())); int width = qMax(fm.width(text), arrowSize.width()); int height = fm.height() + fm.leading() + arrowSize.height(); qreal top = bounds.top() + bounds.height() * 0.5 - height * 0.5; if (QApplication::isRightToLeft()) { return QRectF(bounds.left(), top, width, height); } else { return QRectF(bounds.right() - width, top, width, height); } } QRectF TaskItem::expanderRect(const QRectF &bounds) const { return expanderRect(*m_abstractItem, *m_applet, m_orientation, bounds); } const QString& TaskItem::expanderElement(const Plasma::Location& location, const Qt::Orientation& orientation) { // because of the rotation we never need _LEFT or _RIGHT switch (location) { case Plasma::TopEdge: case Plasma::LeftEdge: return GROUP_EXPANDER_TOP; case Plasma::BottomEdge: case Plasma::RightEdge: return GROUP_EXPANDER_BOTTOM; default: if (orientation) { return GROUP_EXPANDER_TOP; } else { return GROUP_EXPANDER_BOTTOM; } } } const QString& TaskItem::expanderElement() const { return expanderElement(m_applet->location(), m_orientation); } } // namespace SmoothTasks #include "TaskItem.moc" plasma-widget-smooth-tasks/applet/SmoothTasks/Task.cpp000644 000765 000765 00000021353 11724514472 023757 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009, 2012 Toni Dietze * * 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. * ***********************************************************************************/ // Smooth Tasks #include "SmoothTasks/Task.h" #include "SmoothTasks/Applet.h" // Qt #include // KDE #include namespace SmoothTasks { Task::Task(TaskManager::AbstractGroupableItem *abstractItem, QObject *parent) : QObject(parent), m_task(NULL), m_group(NULL), m_abstractItem(abstractItem), m_flags(0), m_type(OtherItem), m_icon() { connect( abstractItem, SIGNAL(destroyed(QObject*)), this, SLOT(itemDestroyed())); if (abstractItem->itemType() == TaskManager::GroupItemType) { m_type = GroupItem; m_group = static_cast(abstractItem); connect( m_group, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(updateTask(::TaskManager::TaskChanges))); updateTask(::TaskManager::EverythingChanged); } else if (abstractItem->itemType() == TaskManager::LauncherItemType) { m_type = LauncherItem; m_launcher = static_cast(abstractItem); connect( m_launcher, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(updateTask(::TaskManager::TaskChanges))); updateTask(::TaskManager::EverythingChanged); } else { m_task = static_cast(abstractItem); if (task()) { m_type = TaskItem; connect( m_task, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(updateTask(::TaskManager::TaskChanges))); updateTask(::TaskManager::EverythingChanged); emit gotTask(); } else if (startup()) { m_type = StartupItem; connect(m_task, SIGNAL(gotTaskPointer()), this, SLOT(gotTaskPointer())); connect( m_task, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(updateTask(::TaskManager::TaskChanges))); updateTask(::TaskManager::EverythingChanged); } } } void Task::itemDestroyed() { m_abstractItem = NULL; m_task = NULL; m_group = NULL; m_launcher = NULL; } bool Task::isActive() const { return m_abstractItem ? m_abstractItem->isActive() : false; } bool Task::isOnCurrentDesktop() const { return m_abstractItem ? m_abstractItem->isOnCurrentDesktop() : false; } bool Task::isOnAllDesktops() const { return m_abstractItem ? m_abstractItem->isOnAllDesktops() : false; } bool Task::isMinimized() const { return m_abstractItem ? m_abstractItem->isMinimized() : false; } bool Task::demandsAttention() const { return m_abstractItem ? m_abstractItem->demandsAttention() : false; } void Task::addMimeData(QMimeData* mimeData) { if (m_group) { m_group->addMimeData(mimeData); } else if (m_task) { m_task->addMimeData(mimeData); } } QString Task::text() const { TaskManager::Task* task; TaskManager::Startup* startup; switch (type()) { case StartupItem: startup = this->startup(); if (startup) { return startup->text(); } break; case TaskItem: task = this->task(); if (task) { return task->visibleName(); } break; case GroupItem: if (m_group != NULL) { return m_group->name(); } break; case LauncherItem: if (m_launcher != NULL) { return m_launcher->name(); } break; default: if (m_abstractItem != NULL) { return m_abstractItem->name(); } break; } return QString::null; } QString Task::description() const { QString temp; switch (type()) { case StartupItem: temp = i18n("Starting application..."); break; case TaskItem: case GroupItem: temp = isOnAllDesktops() ? i18n("On all desktops") : i18nc("Which virtual desktop a window is currently on", "On %1", KWindowSystem::desktopName(m_abstractItem->desktop())); break; case LauncherItem: temp = launcherItem()->genericName(); break; case OtherItem: break; } return temp; } int Task::desktop() const { return m_task ? m_task->task()->desktop() : -1; } TaskManager::Task* Task::task() const { return m_task ? m_task->task() : 0; } TaskManager::Startup* Task::startup() const { return m_task ? m_task->startup() : 0; } int Task::taskCount() const { switch (type()) { case GroupItem: if (m_group == NULL) { return 0; } return m_group->members().size(); default: return 1; } } void Task::updateTask(::TaskManager::TaskChanges changes) { //if (m_type != TaskItem && m_type != GroupItem) // return; if (!isValid()) { return; } // ======================================== QString changesStr("Task::updateTask:"); if (changes & TaskManager::NameChanged) changesStr += " NameChanged"; if (changes & TaskManager::StateChanged) changesStr += " StateChanged"; if (changes & TaskManager::DesktopChanged) changesStr += " DesktopChanged"; if (changes & TaskManager::GeometryChanged) changesStr += " GeometryChanged"; if (changes & TaskManager::WindowTypeChanged) changesStr += " WindowTypeChanged"; if (changes & TaskManager::ActionsChanged) changesStr += " ActionsChanged"; if (changes & TaskManager::TransientsChanged) changesStr += " TransientsChanged"; if (changes & TaskManager::IconChanged) changesStr += " IconChanged"; // TODO: ActivitiesChanged, AttentionChanged, ClassChanged //if (changes & TaskManager::EverythingChanged) changesStr += " EverythingChanged"; if (m_group) { changesStr += " ["; changesStr += m_group->name(); changesStr += "]"; } if (m_task) { changesStr += " ("; changesStr += m_task->name(); changesStr += ")"; } qDebug() << changesStr; // ======================================== bool needsUpdate = false; // true, if redraw is needed bool needsUpdateState = false; // when other thiings change TaskFlags t_flags = m_flags; if (isActive()) { t_flags |= TaskHasFocus; } else { t_flags &= ~TaskHasFocus; } if (demandsAttention()) { t_flags |= TaskWantsAttention; } else { t_flags &= ~TaskWantsAttention; } if (isMinimized()) { t_flags |= TaskIsMinimized; } else { t_flags &= ~TaskIsMinimized; } if (m_flags != t_flags) { needsUpdate = true; m_flags = t_flags; needsUpdateState = true; } if (changes & TaskManager::IconChanged) { switch (type()) { case StartupItem: if (!KIcon(startup()->icon()).isNull()) { m_icon = KIcon(startup()->icon()); } break; case TaskItem: if (!KIcon(task()->icon()).isNull()) { m_icon = KIcon(task()->icon()); } break; case GroupItem: if (!KIcon(group()->icon()).isNull()) { m_icon = KIcon(group()->icon()); } break; case LauncherItem: if (!KIcon(launcherItem()->icon()).isNull()) { m_icon = KIcon(launcherItem()->icon()); } break; case OtherItem: break; } emit updateIcon(m_icon); needsUpdate = true; } if (changes & (TaskManager::StateChanged | TaskManager::IconChanged)) { needsUpdate = true; } if (changes & (TaskManager::StateChanged | TaskManager::DesktopChanged)) { emit updateToolTip(); needsUpdateState = true; } if (changes & TaskManager::NameChanged) { emit updateToolTip(); // TODO: necessary? emit textChanged(); } if (needsUpdateState) { emit updateState(); } if (needsUpdate) { emit update(); } } void Task::gotTaskPointer() { TaskManager::TaskItem *item = qobject_cast(sender()); if (item) { setWindowTask(item); } } // XXX: do I have to tell the applet about this? void Task::setWindowTask(TaskManager::TaskItem* taskItem) { m_type = TaskItem; if (m_task && m_task->task()) { disconnect(m_task->task(), 0, this, 0); } m_task = taskItem; m_abstractItem = qobject_cast(taskItem); if (m_abstractItem) { connect(m_abstractItem, SIGNAL(destroyed(QObject*)), this, SLOT(itemDestroyed())); } connect( m_task, SIGNAL(changed(::TaskManager::TaskChanges)), this, SLOT(updateTask(::TaskManager::TaskChanges))); updateTask(::TaskManager::EverythingChanged); // for publishing the item geometry: emit gotTask(); } } // namespace SmoothTasks #include "Task.moc" plasma-widget-smooth-tasks/applet/SmoothTasks/Light.h000644 000765 000765 00000003727 11724514472 023576 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009-2012 Toni Dietze * * 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 SMOOTHTASKSLIGHT_H #define SMOOTHTASKSLIGHT_H // Qt #include #include #include #include class QAbstractAnimation; class QRadialGradient; class QStyleOptionGraphicsItem; namespace SmoothTasks { class TaskItem; class Light : public QObject { Q_OBJECT Q_PROPERTY(qreal size READ size WRITE setSize) public: enum AnimationType { NoAnimation, StartupAnimation, AttentionAnimation }; Light(TaskItem *item); void paint(QPainter *p, const QRectF& geometry, const QPointF& mousePos, bool mouseIn, const bool isRotated); public slots: void startAnimation(AnimationType animation, int duration = 300, int loopCout = -1); void stopAnimation(); private: qreal size() const { return m_size; } void setSize(qreal size); TaskItem *m_item; qreal m_size; QPointer m_animation; AnimationType m_currentAnimation; signals: void update(); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/CloseIcon.cpp000644 000765 000765 00000006224 11724514472 024733 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/CloseIcon.h" #include "SmoothTasks/Animation/AnimationVariant.h" #include namespace SmoothTasks { CloseIcon::CloseIcon(WindowPreview *preview) : QWidget(preview) , m_preview(preview) , m_highlight(new AnimationVariant(this)) { m_highlight->setStartValue(qreal(0.0)); m_highlight->setEndValue(qreal(1.0)); connect(m_highlight, SIGNAL(valueChanged(QVariant)), this, SLOT(update())); } void CloseIcon::mousePressEvent(QMouseEvent *event) { Q_UNUSED(event); m_preview->closeTask(); } void CloseIcon::mouseDoubleClickEvent(QMouseEvent *event) { QWidget::mouseDoubleClickEvent(event); // XXX: debug strange issue with doubled task items: m_preview->toolTip()->applet()->dumpItems(); } void CloseIcon::enterEvent(QEvent *event) { Q_UNUSED(event); m_highlight->setDuration(m_preview->toolTip()->applet()->animationDuration()); m_highlight->setDirection(QAbstractAnimation::Forward); m_highlight->start(); } void CloseIcon::leaveEvent(QEvent *event) { Q_UNUSED(event); m_highlight->setDuration(m_preview->toolTip()->applet()->animationDuration()); m_highlight->setDirection(QAbstractAnimation::Backward); m_highlight->start(); } void CloseIcon::paintEvent(QPaintEvent *event) { Q_UNUSED(event); SmoothToolTip *toolTip = m_preview->toolTip(); const qreal currentHighlight = m_highlight->currentValue().toReal(); const qreal opacity = m_preview->highlight(); if (opacity + qreal(1.0) > qreal(1.0)) { // fuzzy compare QPainter painter(this); QPixmap pixmap; if (qFuzzyCompare(currentHighlight, qreal(0.0))) { pixmap = toolTip->closeIcon(); } else if (qFuzzyCompare(currentHighlight, qreal(0.0))) { pixmap = toolTip->hoverCloseIcon(); } else { pixmap = Plasma::PaintUtils::transition( toolTip->closeIcon(), toolTip->hoverCloseIcon(), currentHighlight); } qreal x = qreal(width() - pixmap.width()) * 0.5; qreal y = qreal(height() - pixmap.height()) * 0.5; painter.setOpacity(opacity); painter.drawPixmap(x, y, pixmap); } } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/Global.cpp000644 000765 000765 00000011552 11724514472 024255 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 "SmoothTasks/Global.h" // Qt #include #include #include #include #include // STD C++ #include namespace SmoothTasks { const QString TASK_ITEM = QString::fromLatin1("SmoothTasks::TaskItem"); const QString NORMAL = QString::fromLatin1("normal"); const QString ACTIVE = QString::fromLatin1("active"); const QString MINIMIZED = QString::fromLatin1("minimized"); const QString FOCUS = QString::fromLatin1("focus"); const QString ATTENTION = QString::fromLatin1("attention"); const QString HOVER = QString::fromLatin1("hover"); const QString M = QString::fromLatin1("M"); const int DRAG_HOVER_DELAY = 500; QSizeF layoutText(QTextLayout &layout, const QSizeF &constraints) { QFontMetrics metrics(layout.font()); const qreal maxWidth = constraints.width(); const qreal maxHeight = constraints.height(); int leading = metrics.leading(); qreal height = 0; qreal widthUsed = 0; int lineSpacing = metrics.lineSpacing(); layout.beginLayout(); forever { QTextLine line(layout.createLine()); if (!line.isValid()) { break; } height += leading; // Make the last line that will fit infinitely long. // drawTextLayout() will handle this by fading the line out // if it won't fit in the constraints. if (height + 2 * lineSpacing > maxHeight) { line.setLineWidth(std::numeric_limits::infinity()); line.setPosition(QPointF(0, height)); height += line.height(); widthUsed = qMax(widthUsed, line.naturalTextWidth()); break; } line.setLineWidth(maxWidth); line.setPosition(QPointF(0, height)); height += line.height(); widthUsed = qMax(widthUsed, line.naturalTextWidth()); } layout.endLayout(); return QSizeF(widthUsed, height); } QSizeF preferredTextLayoutSize(const QString& text, const QFont& font, const qreal lineWidth) { QTextLayout layout(text, font); QTextOption textOption(layout.textOption()); textOption.setTextDirection(QApplication::layoutDirection()); layout.setTextOption(textOption); QFontMetrics metrics(layout.font()); int leading = metrics.leading(); qreal height = 0; qreal widthUsed = 0; layout.beginLayout(); for(;;) { QTextLine line = layout.createLine(); if (!line.isValid()) break; line.setLineWidth(lineWidth); height += leading; line.setPosition(QPointF(0, height)); height += line.height()+1; widthUsed = qMax(widthUsed, line.naturalTextWidth()); } layout.endLayout(); return QSizeF(widthUsed + 1.0, height + 1.0); // add 1.0 against rounding problems (e.g. font “Linux Biolinum”) } qreal squeezeWidths(QVector& widths, const qreal availableWidth) { const qreal epsilon = 0.1; if (availableWidth <= epsilon) { for (QVector::iterator w = widths.begin(); w != widths.end(); ++w) *w = 0.0; return 0.0; } qreal widthSum = 0.0; foreach (qreal w, widths) widthSum += w; // calculate fitting rdWidths qreal maxRdWidth = 0; while (widthSum > availableWidth) { // find biggest Button qreal nextSmallerRdWidth = 0; int maxCount = 0; foreach (qreal w, widths) { if (w == maxRdWidth) { ++maxCount; } else if (w > maxRdWidth) { nextSmallerRdWidth = maxRdWidth; maxRdWidth = w; maxCount = 1; } else if (w > nextSmallerRdWidth) { nextSmallerRdWidth = w; } } // make biggest buttons shorter qreal newMaxRdWidth = maxRdWidth - (widthSum - (availableWidth - epsilon/*against numeric problems*/)) / (qreal) maxCount; if (newMaxRdWidth < nextSmallerRdWidth) newMaxRdWidth = nextSmallerRdWidth; widthSum = 0.0; for (QVector::iterator w = widths.begin(); w != widths.end(); ++w) { if (*w == maxRdWidth) *w = newMaxRdWidth; widthSum += *w; } maxRdWidth = newMaxRdWidth; } return widthSum; } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/TaskbuttonFrameSvg.h000644 000765 000765 00000004252 11724514472 026312 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009-2010 Toni Dietze * * 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 TASKBUTTONFRAMESVG_H #define TASKBUTTONFRAMESVG_H #include class QRectF; namespace SmoothTasks { class TaskbuttonFrameSvg : public ::Plasma::FrameSvg { Q_OBJECT public: TaskbuttonFrameSvg(QObject *parent = 0); virtual ~TaskbuttonFrameSvg() {}; virtual void getMaximalMargins(qreal &left, qreal &top, qreal &right, qreal &bottom); virtual QRectF minimalContentsRect(); virtual void getMaximalMarginsCustom(qreal &left, qreal &top, qreal &right, qreal &bottom); virtual QRectF minimalContentsRectCustom(); virtual void setCustomMargins(const qreal &left, const qreal &top, const qreal &right, const qreal &bottom); virtual qreal customMarginSize(const Plasma::MarginEdge edge) const; virtual void enableCustomMargins(const bool &enable); virtual bool customMarginsEnabled() const { return m_customMargins; }; virtual QRectF contentsRectCustom() const; virtual void getMarginsCustom(qreal &left, qreal &top, qreal &right, qreal &bottom) const; virtual qreal marginSizeCustom(const Plasma::MarginEdge edge) const; private: bool m_customMargins; qreal m_customMarginLeft; qreal m_customMarginTop; qreal m_customMarginRight; qreal m_customMarginBottom; }; } #endif // TASKBUTTONFRAMESVG_H plasma-widget-smooth-tasks/applet/SmoothTasks/LimitSqueezeTaskbarLayout.h000644 000765 000765 00000004301 11724514472 027642 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Michal Odstrčil * Copyright (C) 2009-2010 Toni Dietze * * 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 SMOOTHTASKS_SQUEEZETASKBARLAYOUT_H #define SMOOTHTASKS_SQUEEZETASKBARLAYOUT_H #include "SmoothTasks/TaskbarLayout.h" namespace SmoothTasks { class LimitSqueezeTaskbarLayout : public TaskbarLayout { Q_OBJECT Q_PROPERTY(qreal squeezeRatio READ squeezeRatio WRITE setSqueezeRatio) Q_PROPERTY(bool preferGrouping READ preferGrouping WRITE setPreferGrouping) public: LimitSqueezeTaskbarLayout( // add preferGrouping qreal squeezeRatio, bool preferGrouping, Qt::Orientation orientation = Qt::Horizontal, QGraphicsLayoutItem *parent = NULL) : TaskbarLayout(orientation, parent), m_squeezeRatio(squeezeRatio), m_compression(1.0), m_preferGrouping(preferGrouping) {} qreal squeezeRatio() const { return m_squeezeRatio; } void setSqueezeRatio(qreal squeezeRatio); bool preferGrouping() const { return m_preferGrouping; } void setPreferGrouping(bool preferGrouping); virtual TaskbarLayoutType type() const { return LimitSqueeze; } virtual int optimumCapacity() const; protected: virtual void updateLayoutStatic(); private: qreal m_squeezeRatio; qreal m_compression; bool m_preferGrouping; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/WindowPreview.h000644 000765 000765 00000006672 11724514472 025342 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2010, 2012 Toni Dietze * * 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 SMOOTHTASKS_WINDOWPREVIEW_H #define SMOOTHTASKS_WINDOWPREVIEW_H #include "SmoothTasks/Applet.h" #include "SmoothTasks/SmoothToolTip.h" #include "SmoothTasks/FadedText.h" #include #include #include #include #include namespace SmoothTasks { class AnimationVariant; class WindowPreview : public QWidget { Q_OBJECT public: WindowPreview( TaskManager::TaskItem *task, int index, SmoothToolTip *toolTip); ~WindowPreview(); QRect previewRect(QPoint point) const { return previewRect(point.x(), point.y()); } QRect previewRect(int x, int y) const; SmoothToolTip *toolTip() const { return m_toolTip; } Task* task() const { return m_task; } int index() const { return m_index; } qreal highlight() const; void hoverEnter(); void hoverLeave(); protected: void paintEvent(QPaintEvent *event); void enterEvent(QEvent *event); void leaveEvent(QEvent *event); void mousePressEvent(QMouseEvent *event); // void mouseMoveEvent(QMouseEvent *event); void mouseReleaseEvent(QMouseEvent *event); void dragEnterEvent(QDragEnterEvent *event); void dragLeaveEvent(QDragLeaveEvent *event); void dragMoveEvent(QDragMoveEvent *event); void dropEvent(QDropEvent *event); signals: void sizeChanged(); void enter(WindowPreview *windowPreview); void leave(WindowPreview *windowPreview); public slots: void highlightTask(); void leftClickTask(); void closeTask(); void updateTheme(); private slots: void activateForDrop(); void updateTask(::TaskManager::TaskChanges changes); private: static const QSize BIG_ICON_SIZE; static const QSize SMALL_ICON_SIZE; QPixmap hoverIcon() const; void setPreviewSize(); void setClassicLayout(); void setNewLayout(); Plasma::FrameSvg *m_background; FadedText *m_taskNameLabel; QSpacerItem *m_iconSpace; QSpacerItem *m_previewSpace; AnimationVariant *m_highlight; Task *m_task; SmoothToolTip *m_toolTip; QSize m_previewSize; QPixmap m_icon; bool m_hover; int m_index; QTimer *m_activateTimer; bool m_didPress; QPoint m_dragStartPosition; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/FixedItemCountTaskbarLayout.cpp000644 000765 000765 00000004640 11724514472 030452 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 "SmoothTasks/FixedItemCountTaskbarLayout.h" #include #include namespace SmoothTasks { void FixedItemCountTaskbarLayout::setItemsPerRow(int itemsPerRow) { if (m_itemsPerRow != itemsPerRow) { m_itemsPerRow = itemsPerRow; invalidate(); } } int FixedItemCountTaskbarLayout::optimumCapacity() const { return m_itemsPerRow * maximumRows(); } void FixedItemCountTaskbarLayout::updateLayoutStatic() { const bool isVertical = orientation() == Qt::Vertical; const int N = items().size(); const QRectF effectiveRect(effectiveGeometry()); const qreal availableHeight = isVertical ? effectiveRect.width() : effectiveRect.height(); const qreal spacing = this->spacing(); #define CELL_HEIGHT(ROWS) (((availableHeight + spacing) / ((qreal) (ROWS))) - spacing) // if there is nothing to layout fill in some dummy data and leave if (N == 0) { m_rows = minimumRows(); m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos.clear(); return; } int itemsPerRow = m_itemsPerRow; int rows = maximumRows(); if (itemsPerRow * rows < N) { itemsPerRow = std::ceil(((qreal) N) / rows); } else { rows = std::ceil(((qreal) N) / itemsPerRow); } QList rowInfos; buildRows(itemsPerRow, rowInfos, rows); m_rows = rows; m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos = rowInfos; updateItemsRowCache(); #undef CELL_HEIGHT } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/MaxSqueezeTaskbarLayout.h000644 000765 000765 00000003126 11724514472 027315 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009 Toni Dietze * * 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 SMOOTHTASKS_MAXSQUEEZETASKBARLAYOUT_H #define SMOOTHTASKS_MAXSQUEEZETASKBARLAYOUT_H #include "SmoothTasks/TaskbarLayout.h" namespace SmoothTasks { class MaxSqueezeTaskbarLayout : public TaskbarLayout { Q_OBJECT public: MaxSqueezeTaskbarLayout( Qt::Orientation orientation = Qt::Horizontal, QGraphicsLayoutItem *parent = NULL) : TaskbarLayout(orientation, parent) {} virtual TaskbarLayoutType type() const { return MaxSqueeze; } virtual int optimumCapacity() const; protected: virtual void updateLayoutStatic(); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/FixedSizeTaskbarLayout.cpp000644 000765 000765 00000010341 11724514472 027450 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 "SmoothTasks/FixedSizeTaskbarLayout.h" #include #include namespace SmoothTasks { void FixedSizeTaskbarLayout::setFixedCellHeight(qreal fixedCellHeight) { if (fixedCellHeight < 1) { qWarning("FixedSizeTaskbarLayout::setFixedCellHeight: illegal fixedCellHeight: %g", fixedCellHeight); return; } if (m_fixedCellHeight != fixedCellHeight) { m_fixedCellHeight = fixedCellHeight; invalidate(); } } int FixedSizeTaskbarLayout::optimumCapacity() const { const QRectF effectiveRect(effectiveGeometry()); const bool isVertical = orientation() == Qt::Vertical; const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal spacing = this->spacing(); const int itemsPerRow = std::ceil((availableWidth + spacing) / (averagePreferredItemRdWidthStatic(m_cellHeight, true) + spacing)); return itemsPerRow * maximumRows(); } int FixedSizeTaskbarLayout::rowOf(const QPointF& pos) const { QRectF effectiveRect(effectiveGeometry()); qreal spacing = this->spacing(); if (orientation() == Qt::Vertical) { qreal x = pos.x(); qreal width = (m_fixedCellHeight + spacing) * m_rows - spacing; if (width > effectiveRect.width()) { width = effectiveRect.width(); } if (x <= effectiveRect.left()) { return 0; } else if (x >= effectiveRect.right() || width <= 0) { return m_rows - 1; } else { return (int) ((x - effectiveRect.left()) * m_rows / width); } } else { qreal y = pos.y(); qreal height = (m_fixedCellHeight + spacing) * m_rows - spacing; if (height > effectiveRect.height()) { height = effectiveRect.height(); } if (y <= effectiveRect.top()) { return 0; } else if (y >= effectiveRect.bottom() || height <= 0) { return m_rows - 1; } else { return (int) ((y - effectiveRect.top()) * m_rows / height); } } } void FixedSizeTaskbarLayout::updateLayoutStatic() { const bool isVertical = orientation() == Qt::Vertical; const QList& items = this->items(); const int N = items.size(); qreal left = 0, top = 0, right = 0, bottom = 0; getContentsMargins(&left, &top, &right, &bottom); const QRectF effectiveRect(effectiveGeometry()); const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal availableHeight = isVertical ? effectiveRect.width() : effectiveRect.height(); const qreal spacing = this->spacing(); #define CELL_HEIGHT(ROWS) (((availableHeight + spacing) / ((qreal) (ROWS))) - spacing) // if there is nothing to layout fill in some dummy data and leave if (N == 0) { m_rows = minimumRows(); m_cellHeight = qMin(m_fixedCellHeight, CELL_HEIGHT(m_rows)); m_rowInfos.clear(); return; } int itemsPerRow = N; int rows = maximumRows(); itemsPerRow = std::ceil((availableWidth + spacing) / (averagePreferredItemRdWidthStatic(qMin(m_fixedCellHeight, CELL_HEIGHT(rows))) + spacing)); if (itemsPerRow * rows < N) { itemsPerRow = std::ceil(((qreal) N) / rows); } QList rowInfos; buildRows(itemsPerRow, rowInfos, rows); m_rows = rows; m_cellHeight = qMin(m_fixedCellHeight, CELL_HEIGHT(m_rows)); m_rowInfos = rowInfos; updateItemsRowCache(); #undef CELL_HEIGHT } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/ToolTipBase.h000644 000765 000765 00000005146 11724514472 024711 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_TOOLTIPBASE_H #define SMOOTHTASKS_TOOLTIPBASE_H #include #include "SmoothTasks/TaskItem.h" namespace SmoothTasks { class ToolTipBase : public QObject { Q_OBJECT public: enum Kind { None = 0, Smooth = 1, Plasma = 2 }; enum Position { Left = 1, Center = 2, Right = 4, Top = 8, Middle = 16, Bottom = 32, HorizontalMask = Left | Center | Right, VerticalMask = Top | Middle | Bottom }; ToolTipBase(Applet *applet) : QObject(), m_applet(applet), m_shown(false), m_hoverItem(NULL) {} virtual ~ToolTipBase() {} virtual Kind kind() const { return None; } virtual void hide(); virtual void quickShow(TaskItem *item); Applet *applet() const { return m_applet; } TaskItem *hoverItem() const { return m_hoverItem; } bool isShown() const { return m_shown; } virtual void registerItem(TaskItem *item); virtual void unregisterItem(TaskItem *item); virtual void moveBesideTaskItem(bool forceAnimated) { Q_UNUSED(forceAnimated) } bool shows(const TaskItem *item) const { return m_shown && m_hoverItem == item; } public slots: // TODO: maybe use eventFilter on the items? virtual void itemUpdate(TaskItem *item) { Q_UNUSED(item) } virtual void itemDelete(TaskItem *item); virtual void popupMenuAboutToHide() { hide(); } protected slots: virtual void itemEnter(TaskItem *item); virtual void itemLeave(TaskItem *item); protected: bool eventFilter(QObject *obj, QEvent *event); Applet *m_applet; bool m_shown; QPointer m_hoverItem; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/Global.h000644 000765 000765 00000003575 11724514472 023730 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 SMOOTHTASKS_GLOBAL_H #define SMOOTHTASKS_GLOBAL_H #include #include class QFont; class QRectF; class QSizeF; class QString; class QTextLayout; template class QVector; namespace Plasma { class FrameSvg; } namespace SmoothTasks { // global "string table": extern const QString TASK_ITEM; extern const QString NORMAL; extern const QString ACTIVE; extern const QString MINIMIZED; extern const QString FOCUS; extern const QString ATTENTION; extern const QString HOVER; extern const QString M; extern const int DRAG_HOVER_DELAY; QSizeF layoutText(QTextLayout &layout, const QSizeF &constraints); QSizeF preferredTextLayoutSize(const QString& text, const QFont& font, const qreal lineWidth = std::numeric_limits::infinity()); qreal squeezeWidths(QVector& widths, const qreal availableWidth); } #endif plasma-widget-smooth-tasks/applet/SmoothTasks/FixedSizeTaskbarLayout.h000644 000765 000765 00000003657 11724514472 027131 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009 Toni Dietze * * 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 SMOOTHTASKS_FIXEDSIZETASKBARLAYOUT_H #define SMOOTHTASKS_FIXEDSIZETASKBARLAYOUT_H #include "SmoothTasks/TaskbarLayout.h" namespace SmoothTasks { class FixedSizeTaskbarLayout : public TaskbarLayout { Q_OBJECT Q_PROPERTY(qreal fixedCellHeight READ fixedCellHeight WRITE setFixedCellHeight) public: FixedSizeTaskbarLayout( qreal fixedCellHeight, Qt::Orientation orientation = Qt::Horizontal, QGraphicsLayoutItem *parent = NULL) : TaskbarLayout(orientation, parent), m_fixedCellHeight(fixedCellHeight) {} virtual TaskbarLayoutType type() const { return FixedSize; } qreal fixedCellHeight() const { return m_fixedCellHeight; } void setFixedCellHeight(qreal fixedCellHeight); virtual int optimumCapacity() const; protected: virtual int rowOf(const QPointF& pos) const; virtual void updateLayoutStatic(); private: qreal m_fixedCellHeight; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/DelayedToolTip.h000644 000765 000765 00000003420 11724514472 025377 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_DELAYEDTOOLTIP_H #define SMOOTHTASKS_DELAYEDTOOLTIP_H #include "SmoothTasks/ToolTipBase.h" namespace SmoothTasks { class DelayedToolTip : public ToolTipBase { Q_OBJECT public: DelayedToolTip(Applet *applet); virtual Kind kind() const = 0; virtual void hide(); virtual void quickShow(TaskItem *item); protected slots: virtual void itemDelete(TaskItem *item); virtual void itemEnter(TaskItem *item); virtual void itemLeave(TaskItem *item); protected: virtual void showAction(bool animate) = 0; virtual void hideAction() = 0; private slots: void timeout(); private: enum ActionType { NoAction, ShowAction, HideAction }; QTimer *m_delayTimer; ActionType m_action; QPointer m_newHoverItem; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/000755 000765 000765 00000000000 11765222347 024266 5ustar00salvosalvo000000 000000 plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationThrow.h000644 000765 000765 00000012414 11724514472 027402 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 ANIMATIONTHROW_H #define ANIMATIONTHROW_H // C++ #include // Qt #include #include // KDE #include namespace SmoothTasks { template class AnimationThrow : public QAbstractAnimation { // The moc cannot handle template classes, so the propertys may not work, // see http://doc.qt.nokia.com/qq/qq15-academic.html // Q_OBJECT Q_PROPERTY(qreal acceleration READ acceleration WRITE setAcceleration) Q_PROPERTY(CLASS startValue READ startValue WRITE setStartValue ) Q_PROPERTY(CLASS endValue READ endValue WRITE setEndValue ) Q_PROPERTY(QObject* targetObject READ targetObject WRITE setTargetObject) Q_PROPERTY(QByteArray propertyName READ propertyName WRITE setPropertyName) public: AnimationThrow(QObject* parent = 0); AnimationThrow(QObject* target, const QByteArray& propertyName, QObject* parent = 0); virtual ~AnimationThrow() {} void init(); /* implement */ virtual int duration() const { return -1; } // Getter const QObject* targetObject () const { return m_target ; } QObject* targetObject () { return m_target ; } QByteArray propertyName () const { return m_targetPropertyName ; } qreal acceleration () const { return m_acceleration ; } CLASS startValue () const { return convert(m_startValue); } CLASS endValue () const { return convert(m_endValue ); } // Setter void setTargetObject(QObject* target ) { m_target = target; } void setPropertyName(const QByteArray& propertyName) { m_targetPropertyName = propertyName; } void setAcceleration(qreal acceleration ) { m_cacheDirty = true; m_acceleration = acceleration; } void setStartValue (const CLASS& value ) { m_cacheDirty = true; convert(value, m_startValue) ; } void setEndValue (const CLASS& value ) { m_cacheDirty = true; convert(value, m_endValue ) ; } protected: virtual CLASS convert(const qreal src[]) const = 0; virtual void convert(const CLASS& src, qreal dst[]) const = 0; /* implement */ virtual void updateCurrentTime(int currentTime); private: void updateCache(); QObject* m_target; QByteArray m_targetPropertyName; qreal m_acceleration; qreal m_startValue[SIZE]; qreal m_endValue[SIZE]; bool m_cacheDirty; int m_cachedDuration; qreal m_cachedDurations[SIZE]; }; template AnimationThrow::AnimationThrow(QObject* parent) : QAbstractAnimation(parent) , m_target(0) , m_acceleration(1.0) , m_cacheDirty(true) { init(); } template AnimationThrow::AnimationThrow(QObject* target, const QByteArray& propertyName, QObject* parent) : QAbstractAnimation(parent) , m_target(target) , m_targetPropertyName(propertyName) , m_acceleration(1.0) , m_cacheDirty(true) { init(); } template void AnimationThrow::init() { for (int i = 0; i < SIZE; ++i) { m_startValue[i] = 0; m_endValue[i] = 0; } } template void AnimationThrow::updateCurrentTime(int currentTime) { if (!m_target || m_targetPropertyName.isEmpty()) { kWarning() << "target or property name not set"; stop(); return; } updateCache(); qreal current[SIZE]; qreal t = 0.001 * static_cast(currentTime); for (int i = 0; i < SIZE; ++i) { if (t < m_cachedDurations[i]) { qreal t2 = 1 - t / m_cachedDurations[i]; current[i] = m_startValue[i] + (1 - t2 * t2) * (m_endValue[i] - m_startValue[i]); } else { current[i] = m_endValue[i]; } } if (!m_target->setProperty(m_targetPropertyName.constData(), QVariant(convert(current)))) { kWarning() << "you're trying to animate a non-existing or wrong-typed property" << m_targetPropertyName.constData() << "of your QObject" << m_target; stop(); return; } if (currentTime >= m_cachedDuration) stop(); } template void AnimationThrow::updateCache() { if (!m_cacheDirty) return; qreal dur = 0.0; for (int i = 0; i < SIZE; ++i) { qreal delta = m_endValue[i] - m_startValue[i]; m_cachedDurations[i] = std::sqrt(std::abs(delta) / m_acceleration); if (m_cachedDurations[i] > dur) dur = m_cachedDurations[i]; } m_cachedDuration = static_cast(1000 * dur) + 1; m_cacheDirty = false; } } // namespace SmoothTasks #endif // ANIMATIONTHROW_H plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationThrowRect.cpp000644 000765 000765 00000003156 11724514472 030556 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 "AnimationThrowRect.h" #include namespace SmoothTasks { AnimationThrowRect::AnimationThrowRect(QObject* parent) : AnimationThrow<4, QRectF>(parent) {} AnimationThrowRect::AnimationThrowRect(QObject* target, const QByteArray& propertyName, QObject* parent) : AnimationThrow<4, QRectF>(target, propertyName, parent) {} AnimationThrowRect::~AnimationThrowRect() { } QRectF AnimationThrowRect::convert(const qreal src[]) const { QRectF rect; rect.setCoords(src[0], src[1], src[2], src[3]); return rect; } void AnimationThrowRect::convert(const QRectF& src, qreal dst[]) const { src.getCoords(dst, dst + 1, dst + 2, dst + 3); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationThrowPoint.h000644 000765 000765 00000003055 11724514472 030415 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 ANIMATIONTHROWPOINT_H #define ANIMATIONTHROWPOINT_H #include class QPointF; namespace SmoothTasks { class AnimationThrowPoint : public AnimationThrow<2, QPointF> { Q_OBJECT public: AnimationThrowPoint(QObject* parent = 0); AnimationThrowPoint(QObject* target, const QByteArray& propertyName, QObject* parent = 0); virtual ~AnimationThrowPoint(); /* implement */ virtual QPointF convert(const qreal src[]) const; /* implement */ virtual void convert(const QPointF& src, qreal dst[]) const; }; } // namespace SmoothTasks #endif // ANIMATIONTHROWPOINT_H plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationVariant.cpp000644 000765 000765 00000002303 11724514472 030232 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 "AnimationVariant.h" namespace SmoothTasks { AnimationVariant::AnimationVariant(QObject* parent) : QVariantAnimation(parent) {} void AnimationVariant::updateCurrentValue(const QVariant& value) { Q_UNUSED(value) } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationVariant.h000644 000765 000765 00000003047 11724514472 027705 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 ANIMATIONVARIANT_H #define ANIMATIONVARIANT_H #include namespace SmoothTasks { /** Actually, this class does not implement anything. Its only purpose is to * make QVariantAnimation intantiable, if a QPropertyAnimation is not needed. * To get informed about the ongoing animation, connect to the valueChanged * slot. */ class AnimationVariant : public QVariantAnimation { Q_OBJECT public: AnimationVariant(QObject* parent = 0); protected: /* implement */ virtual void updateCurrentValue(const QVariant& value); }; } // namespace SmoothTasks #endif // ANIMATIONVARIANT_H plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationThrowRect.h000644 000765 000765 00000003041 11724514472 030214 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 ANIMATIONTHROWRECT_H #define ANIMATIONTHROWRECT_H #include class QRectF; namespace SmoothTasks { class AnimationThrowRect : public AnimationThrow<4, QRectF> { Q_OBJECT public: AnimationThrowRect(QObject* parent = 0); AnimationThrowRect(QObject* target, const QByteArray& propertyName, QObject* parent = 0); virtual ~AnimationThrowRect(); /* implement */ virtual QRectF convert(const qreal src[]) const; /* implement */ virtual void convert(const QRectF& src, qreal dst[]) const; }; } // namespace SmoothTasks #endif // ANIMATIONTHROWRECT_H plasma-widget-smooth-tasks/applet/SmoothTasks/Animation/AnimationThrowPoint.cpp000644 000765 000765 00000003106 11724514472 030745 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2012 Toni Dietze * * 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 "AnimationThrowPoint.h" #include namespace SmoothTasks { AnimationThrowPoint::AnimationThrowPoint(QObject* parent) : AnimationThrow<2, QPointF>(parent) {} AnimationThrowPoint::AnimationThrowPoint(QObject* target, const QByteArray& propertyName, QObject* parent) : AnimationThrow<2, QPointF>(target, propertyName, parent) {} AnimationThrowPoint::~AnimationThrowPoint() { } QPointF AnimationThrowPoint::convert(const qreal src[]) const { return QPointF(src[0], src[1]); } void AnimationThrowPoint::convert(const QPointF& src, qreal dst[]) const { dst[0] = src.x(); dst[1] = src.y(); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/PlasmaToolTip.h000644 000765 000765 00000003156 11724514472 025253 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_PLASMATOOLTIP_H #define SMOOTHTASKS_PLASMATOOLTIP_H #include "SmoothTasks/DelayedToolTip.h" namespace SmoothTasks { class PlasmaToolTip : public DelayedToolTip { Q_OBJECT public: PlasmaToolTip(Applet *applet) : DelayedToolTip(applet) {} virtual Kind kind() const { return Plasma; } virtual void hide(); virtual void unregisterItem(TaskItem *item); protected: virtual void showAction(bool animated); virtual void hideAction(); public slots:; void itemUpdate(TaskItem *item); private: void updateToolTip(); private slots: void activateWindow(WId window, Qt::MouseButtons buttons); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/FadedText.cpp000644 000765 000765 00000024523 11724514472 024727 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 #include #include #include #include #include #include #include #include #include "SmoothTasks/FadedText.h" #include "SmoothTasks/Global.h" namespace SmoothTasks { const int FadedText::SCROLL_DURATION = 25; const int FadedText::SCROLL_STOP_DURATION = 4; const int FadedText::SCROLL_WAIT_AT_ENDS = 1000; const int FadedText::SCROLL_WAIT_AFTER_DRAG = 2000; void FadedText::init() { m_scrollAnimation = 0; m_fadeWidth = 30; m_animLeft = 0; m_scrollOffset = 0; m_dragState = NoDrag; m_mouseX = 0; m_textOption.setWrapMode(QTextOption::NoWrap); setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum); updateText(); } FadedText::~FadedText() { delete m_scrollAnimation; m_scrollAnimation = 0; } void FadedText::paintEvent(QPaintEvent* event) { QWidget::paintEvent(event); if (width() >= 1 && height() >= 1) { QPainter painter(this); QTextLayout layout; QSizeF textSize(layoutText(layout)); drawTextLayout(painter, layout, textSize); } } QSizeF FadedText::layoutText(QTextLayout &layout) const { layout.setFont(font()); layout.setText(m_text); layout.setTextOption(m_textOption); return ::SmoothTasks::layoutText(layout, maximumSize()); } QPointF FadedText::visualPos(Qt::LayoutDirection direction, const QRect& boundingRect, const QPointF& logicalPos) { if (direction == Qt::LeftToRight) { return logicalPos; } return QPointF(-(boundingRect.right() - logicalPos.x()), logicalPos.y()); } void FadedText::drawTextLayout(QPainter& painter, const QTextLayout& layout, const QSizeF& textSize) { const bool rtl = layout.textOption().textDirection() == Qt::RightToLeft; QPixmap pixmap(size()); pixmap.fill(Qt::transparent); QPainter p(&pixmap); p.setPen(painter.pen()); // Create the alpha gradient for the fade out effect QLinearGradient beginAlphaGradient(0, 0, 1, 0); QLinearGradient endAlphaGradient(0, 0, 1, 0); beginAlphaGradient.setCoordinateMode(QGradient::ObjectBoundingMode); endAlphaGradient.setCoordinateMode(QGradient::ObjectBoundingMode); endAlphaGradient.setColorAt(0, QColor(0, 0, 0, 255)); endAlphaGradient.setColorAt(1, QColor(0, 0, 0, 0)); beginAlphaGradient.setColorAt(0, QColor(0, 0, 0, 0)); beginAlphaGradient.setColorAt(1, QColor(0, 0, 0, 255)); QFontMetrics fm(layout.font()); QPointF position(m_animLeft, (height() - textSize.height()) * 0.5 + (fm.tightBoundingRect(M).height() - fm.xHeight()) * 0.5); QList fadeBeginRects; QList fadeEndRects; // Draw each line in the layout for (int i = 0; i < layout.lineCount(); ++ i) { QTextLine line(layout.lineAt(i)); QPointF linePos(position); qreal textWidth = line.naturalTextWidth(); if (rtl) { linePos.setX(m_animLeft + textSize.width() - textWidth); } line.draw(&p, linePos); // Add a fade out rect to the list if the line is too long int y = int(line.position().y() + linePos.y()); qreal lineLeft = linePos.x(); qreal lineRight = lineLeft + textWidth; if (lineRight > width()) { int dist = lineRight - width(); int fadeWidth = dist < m_fadeWidth ? dist : m_fadeWidth; int x = pixmap.width() - fadeWidth; fadeEndRects.append(QRect(x, y, fadeWidth, int(line.height()))); } if (lineLeft < 0) { int dist = -lineLeft; int fadeWidth = dist < m_fadeWidth ? dist : m_fadeWidth; fadeBeginRects.append(QRect(0, y, fadeWidth, int(line.height()))); } } // Reduce the alpha in each fade out rect using the alpha gradient if (!fadeBeginRects.isEmpty()) { p.setCompositionMode(QPainter::CompositionMode_DestinationIn); foreach (const QRect &rect, fadeBeginRects) { p.fillRect(rect, beginAlphaGradient); } } if (!fadeEndRects.isEmpty()) { if (fadeBeginRects.isEmpty()) { p.setCompositionMode(QPainter::CompositionMode_DestinationIn); } foreach (const QRect &rect, fadeEndRects) { p.fillRect(rect, endAlphaGradient); } } p.end(); QColor shadowColor; if (painter.pen().color().value() < 128) { shadowColor = Qt::white; } else { shadowColor = Qt::black; } if (m_shadow) { QImage shadow(pixmap.toImage()); Plasma::PaintUtils::shadowBlur(shadow, 2, shadowColor); painter.drawImage(1, 2, shadow); } painter.drawPixmap(0, 0, pixmap); } void FadedText::setText(const QString& text) { if (m_text != text) { m_text = text; updateText(); } } void FadedText::resizeEvent(QResizeEvent *event) { Q_UNUSED(event); updateText(); } void FadedText::changeEvent(QEvent *event) { QWidget::changeEvent(event); if (event->type() == QEvent::FontChange) { updateText(); } event->ignore(); } void FadedText::mousePressEvent(QMouseEvent *event) { if (m_sizeHint.width() > width()) { delete m_scrollAnimation; m_scrollAnimation = 0; m_mouseX = event->globalX(); m_scrollOffset = m_animLeft; m_dragState = BegunDrag; } event->ignore(); } void FadedText::mouseMoveEvent(QMouseEvent *event) { int dx = event->globalX() - m_mouseX; if (m_dragState == BegunDrag && dx == 0) { event->ignore(); } else if (m_dragState == BegunDrag || m_dragState == ConfirmedDrag) { int x = m_scrollOffset + dx; m_dragState = ConfirmedDrag; if (x > 0) { x = 0; } else if (x < width() - m_sizeHint.width()) { x = width() - m_sizeHint.width(); } if (x != m_animLeft) { m_animLeft = x; update(); } event->accept(); } else { event->ignore(); } } void FadedText::mouseReleaseEvent(QMouseEvent *event) { if (m_dragState == ConfirmedDrag) { if (event->x() < 0 || event->y() < 0 || event->x() >= width() || event->y() >= height()) { stopScrollAnimation(); } else { startScrollAnimation(SCROLL_WAIT_AFTER_DRAG); } event->accept(); } else { event->ignore(); } m_dragState = NoDrag; } void FadedText::setTextOption(const QTextOption& textOption) { m_textOption = textOption; updateText(); } void FadedText::setWrapMode(QTextOption::WrapMode wrapMode) { if (m_textOption.wrapMode() != wrapMode) { m_textOption.setWrapMode(wrapMode); updateText(); } } void FadedText::setAlignment(Qt::Alignment alignment) { if (m_textOption.alignment() != alignment) { m_textOption.setAlignment(alignment); updateText(); } } void FadedText::setScrollPosition(qreal position) { if (m_animLeft == position) return; m_animLeft = position; update(); } void FadedText::setFadeWidth(int fadeWidth) { if (fadeWidth < 0) { qDebug("FadedText::setFadeWidth: illegal fadeWidth: %d", fadeWidth); return; } if (m_fadeWidth != fadeWidth && fadeWidth >= 0) { m_fadeWidth = fadeWidth; update(); } } void FadedText::setShadow(bool shadow) { if (m_shadow != shadow) { m_shadow = shadow; update(); } } void FadedText::updateText() { QTextLayout layout; QSizeF realTextSize(layoutText(layout)); QSize textSize(std::ceil(realTextSize.width()), std::ceil(realTextSize.height())); if (m_sizeHint != textSize) { m_sizeHint = textSize; updateGeometry(); } if (m_textOption.textDirection() == Qt::RightToLeft) { if (m_scrollAnimation) { // TODO? } else { m_animLeft = width() - textSize.width(); } } } void FadedText::startScrollAnimation(int delay) { delete m_scrollAnimation; m_scrollAnimation = 0; if (m_sizeHint.width() <= width()) return; qreal startValue = 0.0; qreal endValue = 0.0; if (m_textOption.textDirection() == Qt::RightToLeft) startValue = -scrollDistance(); else endValue = -scrollDistance(); QPropertyAnimation* start = new QPropertyAnimation(this, "scrollPosition", this); start->setStartValue(m_animLeft); start->setEndValue(endValue); start->setDuration(SCROLL_DURATION * std::abs(endValue - m_animLeft)); QPropertyAnimation* forwards = new QPropertyAnimation(this, "scrollPosition", this); forwards->setStartValue(startValue); forwards->setEndValue(endValue); forwards->setDuration(SCROLL_DURATION * std::abs(endValue - startValue)); QPropertyAnimation* backwards = new QPropertyAnimation(this, "scrollPosition", this); backwards->setStartValue(forwards->endValue()); backwards->setEndValue(forwards->startValue()); backwards->setDuration(forwards->duration()); QSequentialAnimationGroup* loop = new QSequentialAnimationGroup(this); loop->addAnimation(backwards); loop->addPause(SCROLL_WAIT_AT_ENDS); loop->addAnimation(forwards); loop->addPause(SCROLL_WAIT_AT_ENDS); loop->setLoopCount(-1); QSequentialAnimationGroup* all = new QSequentialAnimationGroup(this); all->addPause(delay); all->addAnimation(start); all->addPause(SCROLL_WAIT_AT_ENDS); all->addAnimation(loop); m_scrollAnimation = all; m_scrollAnimation->start(QAbstractAnimation::DeleteWhenStopped); } void FadedText::stopScrollAnimation() { delete m_scrollAnimation; m_scrollAnimation = 0; if (m_sizeHint.width() <= width()) return; qreal startValue = 0.0; if (m_textOption.textDirection() == Qt::RightToLeft) startValue = -scrollDistance(); QPropertyAnimation* ani = new QPropertyAnimation(this, "scrollPosition", this); ani->setStartValue(m_animLeft); ani->setEndValue(startValue); ani->setDuration(SCROLL_STOP_DURATION * std::abs(m_animLeft - startValue)); m_scrollAnimation = ani; m_scrollAnimation->start(QAbstractAnimation::DeleteWhenStopped); } void FadedText::enterEvent(QEvent *event) { Q_UNUSED(event); startScrollAnimation(); } void FadedText::leaveEvent(QEvent *event) { Q_UNUSED(event); stopScrollAnimation(); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/TaskIcon.cpp000644 000765 000765 00000026770 11724514472 024600 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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. * ***********************************************************************************/ // Smooth Tasks #include "SmoothTasks/TaskIcon.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/Applet.h" // Qt #include #include #include #include #include // Plasma #include #include // KDE #include #include #include // Std C++ #include namespace SmoothTasks { TaskIcon::TaskIcon(TaskItem *item) : QObject(item) , m_item(item) , m_icon() , m_highlightColor(0) , m_contentsRdRect() , m_pixmap() , m_progress(0.0) , m_size(128.0, 128.0) , m_startupAnimation(0) {} QRgb TaskIcon::highlightColor() const { Applet *applet = m_item->applet(); if (m_highlightColor != 0 && applet->lightColorFromIcon()) { return m_highlightColor; } else { return applet->lightColor().rgb(); } } void TaskIcon::updatePos() { const qreal rdHeight = this->rdHeight(); const QSize iconRdSize = actualRdSize(QSize(m_contentsRdRect.width(), rdHeight)); const qreal maxRdWidth = qMin(m_contentsRdRect.width(), m_item->applet()->minIconSpace()); const qreal shift = iconRdSize.width() < maxRdWidth ? 0.5 * (maxRdWidth - iconRdSize.width()) : 0.0; if (m_item->orientation() == Qt::Vertical) { if (QApplication::isRightToLeft()) { m_pos.setX(m_contentsRdRect.center().y() - 0.5 * iconRdSize.height()); m_pos.setY(m_contentsRdRect.left() + shift); } else { m_pos.setX(m_contentsRdRect.center().y() - 0.5 * iconRdSize.height()); m_pos.setY(m_contentsRdRect.right() - iconRdSize.width() - shift); } m_size = QSize(rdHeight, m_contentsRdRect.width()); } else { if (QApplication::isRightToLeft()) { m_pos.setX(m_contentsRdRect.right() - iconRdSize.width() - shift); m_pos.setY(m_contentsRdRect.center().y() - 0.5 * iconRdSize.height()); } else { m_pos.setX(m_contentsRdRect.left() + shift); m_pos.setY(m_contentsRdRect.center().y() - 0.5 * iconRdSize.height()); } m_size = QSize(m_contentsRdRect.width(), rdHeight); } } QSizeF TaskIcon::preferredRdSize(const QIcon& qIcon, const Applet& applet, const Qt::Orientation& orientation, const qreal rdHeightContents, const qreal rdHeightMax) { qreal scaledRdHeight = applet.iconScale() * rdHeightContents; if (scaledRdHeight > rdHeightMax) scaledRdHeight = rdHeightMax; if (scaledRdHeight < 1.0) scaledRdHeight = 1.0; if (scaledRdHeight > 128.0) scaledRdHeight = 128.0; // std::numeric_limits::infinity() does not work QSizeF iconRdSize = actualRdSize(qIcon, orientation, QSize(128.0, scaledRdHeight)); return QSizeF( qMax(iconRdSize.width(), applet.minIconSpace()), iconRdSize.height() / applet.iconScale() ); } QSizeF TaskIcon::preferredRdSize(const qreal rdHeightContents, const qreal rdHeightMax) const { return preferredRdSize(m_icon, *m_item->applet(), m_item->orientation(), rdHeightContents, rdHeightMax); } void TaskIcon::paint(QPainter *p, qreal hover, bool isGroup) { m_pixmap = m_icon.pixmap(m_icon.actualSize(m_size)); // without m_icon.actualSize the jumping startup icon uses too much space on expanded buttons if (m_pixmap.isNull()) { kDebug() << "TaskIcon pixmap is null"; return; } if (m_startupAnimation) { animationStartup(m_progress); } if (hover > 0.0) { animationHover(hover); } p->drawPixmap(m_pos, m_pixmap); } void TaskIcon::setRects(const QRectF &contentsRdRect, const QRectF &maxRdRect) { if (m_contentsRdRect != contentsRdRect || m_maxRdRect != maxRdRect) { m_contentsRdRect = contentsRdRect; m_maxRdRect = maxRdRect; updatePos(); } } void TaskIcon::setIcon(const QIcon& icon) { m_icon = icon; m_highlightColor = dominantColor(); updatePos(); } qreal TaskIcon::rdHeight() const { QPointF center(m_contentsRdRect.center()); return qMax(1.0, qMin( m_item->applet()->iconScale() * m_contentsRdRect.height(), 2.0 * qMin(center.y() - m_maxRdRect.top(), m_maxRdRect.bottom() - center.y()) )); } QSize TaskIcon::actualRdSize(const QIcon& qIcon, const Qt::Orientation& orientation, const QSize &size, QIcon::Mode mode, QIcon::State state) { if (orientation == Qt::Vertical) { QSize iconSize = qIcon.actualSize(QSize(size.height(), size.width()), mode, state); return QSize(iconSize.height(), iconSize.width()); } else { return qIcon.actualSize(size, mode, state); } } QSize TaskIcon::actualRdSize(const QSize &size, QIcon::Mode mode, QIcon::State state) const { return actualRdSize(m_icon, m_item->orientation(), size, mode, state); } QSize TaskIcon::rdSize() { QSize iconRdSize = actualRdSize(QSize(m_contentsRdRect.width(), this->rdHeight())); const qreal maxRdWidth = qMin(m_contentsRdRect.width(), m_item->applet()->minIconSpace()); return QSize(iconRdSize.width() < maxRdWidth ? maxRdWidth : iconRdSize.width(), iconRdSize.height()); } void TaskIcon::startStartupAnimation(int duration) { if (!m_startupAnimation) { m_startupAnimation = new QPropertyAnimation(this, "startupAnimationProgress", this); m_startupAnimation->setEasingCurve(QEasingCurve::Linear); m_startupAnimation->setEndValue(1.0); m_startupAnimation->setLoopCount(-1); m_startupAnimation->setStartValue(0.0); } m_startupAnimation->setDuration(duration); m_startupAnimation->start(); } void TaskIcon::stopStartupAnimation() { delete m_startupAnimation; m_startupAnimation = 0; } void TaskIcon::setStartupAnimationProgress(qreal progress) { m_progress = progress; emit update(); } void TaskIcon::animationHover(qreal hover) { KIconEffect *effect = KIconLoader::global()->iconEffect(); if (effect->hasEffect(KIconLoader::Desktop, KIconLoader::ActiveState)) { if (qFuzzyCompare(qreal(1.0), hover)) { m_pixmap = effect->apply( m_pixmap, KIconLoader::Desktop, KIconLoader::ActiveState); } else if (hover != 0.0) { m_pixmap = Plasma::PaintUtils::transition( m_pixmap, effect->apply( m_pixmap, KIconLoader::Desktop, KIconLoader::ActiveState), hover); } } } void TaskIcon::animationStartup(qreal progress) { QPixmap pixmap = QPixmap(m_pixmap.width(), m_pixmap.height()); pixmap.fill(Qt::transparent); int width; int height; if (progress < 0.5) { width = m_pixmap.width() * (0.5 + progress * 0.5); height = m_pixmap.height() * (1.0 - progress * 0.5); } else { width = m_pixmap.width() * (1.0 - progress * 0.5); height = m_pixmap.height() * (0.5 + progress * 0.5); } QPixmap scaled = m_pixmap.scaled( width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); if (!scaled.isNull()) { QPainter pixmapPainter(&pixmap); pixmapPainter.drawPixmap( (m_pixmap.width() - width) / 2, (m_pixmap.height() - height) / 2, scaled); pixmapPainter.end(); } m_pixmap = pixmap; QPixmap transparentPixmap = QPixmap(m_pixmap.width(), m_pixmap.height()); transparentPixmap.fill(Qt::transparent); m_pixmap = Plasma::PaintUtils::transition(transparentPixmap, m_pixmap, 0.85); } QRgb TaskIcon::averageColor() const { // Computes, and returns average color of the icon image. // Added by harsh@harshj.com for color hot-tracking support. QImage image(m_icon.pixmap(m_size).toImage()); unsigned int r(0), g(0), b(0); unsigned int count = 0; for(int x = 0; x < image.width(); ++ x) { for(int y = 0; y < image.height(); ++ y) { QRgb color = image.pixel(x, y); if (qAlpha(color) != 0) { r += qRed(color); g += qGreen(color); b += qBlue(color); ++ count; } } } r /= count; g /= count; b /= count; return qRgb(r, g, b); } static bool hsvLess(const QColor& c1, const QColor& c2) { int h1, s1, v1, h2, s2, v2; c1.getHsv(&h1, &s1, &v1); c2.getHsv(&h2, &s2, &v2); return (h1 << 16 | s1 << 8 | v1) < (h2 << 16 | s2 << 8 | v2); /* * should be equivalent to this, but with less branches: int cmp = h1 - h2; if (cmp == 0) { cmp = s1 - s2; if (cmp == 0) { cmp = v1 - v2; } } return cmp < 0; */ } QRgb TaskIcon::meanColor() const { QImage image(m_icon.pixmap(m_size).toImage()); QVector colors(image.width() * image.height()); int count = 0; for(int x = 0; x < image.width(); ++ x) { for(int y = 0; y < image.height(); ++ y) { QRgb color = image.pixel(x, y); // only use non-(total-)transparent colors if (qAlpha(color) != 0) { colors[count] = color; ++ count; } } } if (count == 0) { return 0; } colors.resize(count); qSort(colors.begin(), colors.end(), hsvLess); int mid = count / 2; if (count & 1) { // odd case return colors[mid].rgb(); } else { // even case QColor color1(colors[mid]); QColor color2(colors[mid + 1]); int r = (color1.red() + color2.red()) / 2; int g = (color1.green() + color2.green()) / 2; int b = (color1.blue() + color2.blue()) / 2; return qRgb(r, g, b); } } static bool isNear(const QColor& c1, const QColor& c2) { int h1, s1, v1, h2, s2, v2; c1.getHsv(&h1, &s1, &v1); c2.getHsv(&h2, &s2, &v2); return qAbs(h1 - h2) <= 8 && qAbs(s1 - s2) <= 16 && qAbs(v1 - v2) <= 32; } QRgb TaskIcon::dominantColor() const { QImage image(m_icon.pixmap(m_size).toImage()); QVector colors(image.width() * image.height()); int count = 0; // find the mean color for(int x = 0; x < image.width(); ++ x) { for(int y = 0; y < image.height(); ++ y) { QRgb rgb = image.pixel(x, y); // only use non-(total-)transparent colors if (qAlpha(rgb) != 0) { QColor color(rgb); // only use colors that aren't too grey if (color.saturation() > 24) { colors[count] = color; ++ count; } } } } if (count == 0) { return 0; } colors.resize(count); qSort(colors.begin(), colors.end(), hsvLess); int mid = count / 2; QColor midColor(colors[mid]); QColor* begin = colors.begin() + mid; // find similar colors before the mean: if (mid != 0) { -- begin; while (begin != colors.begin()) { if (isNear(*(begin - 1), midColor)) { -- begin; } else { break; } } } QColor* end = colors.begin() + mid; // find similar colors after the mean: while (end != colors.end()) { if (isNear(*end, midColor)) { ++ end; } else { break; } } // average of similar colors: unsigned int r = 0, g = 0, b = 0; for (QColor* it = begin; it != end; ++ it) { r += it->red(); g += it->green(); b += it->blue(); } int similarCount = std::distance(begin, end); QColor color(r / similarCount, g / similarCount, b / similarCount); int h, s, v; color.getHsv(&h, &s, &v); if (v < 196) { v = 196; } if (s < 128) { s = 128; } color.setHsv(h, s, v); return color.rgb(); } } // namespace SmoothTasks #include "TaskIcon.moc" plasma-widget-smooth-tasks/applet/SmoothTasks/TaskStateAnimation.cpp000644 000765 000765 00000006436 11724514472 026625 0ustar00salvosalvo000000 000000 #include "SmoothTasks/TaskStateAnimation.h" #include namespace SmoothTasks { TaskStateAnimation::TaskStateAnimation() : QObject(), m_animation(0), m_fromState(Normal), m_toState(Normal), m_hover(0.0), m_minimized(0.0), m_attention(0.0), m_focus(0.0), m_lastProgress(0.0) { connect( Plasma::Animator::self(), SIGNAL(customAnimationFinished(int)), this, SLOT(animationFinished(int))); } void TaskStateAnimation::stop() { if (m_animation) { Plasma::Animator::self()->stopCustomAnimation(m_animation); m_animation = 0; } } void TaskStateAnimation::start(int fps, int duration) { int frames = fps * duration / 1000; m_lastProgress = 0.0; if (frames <= 0) { animate(1.0); animationFinished(m_animation); } else { m_animation = Plasma::Animator::self()->customAnimation( frames, duration, Plasma::Animator::LinearCurve, this, "animate"); } } void TaskStateAnimation::setState(int newState, int fps, int duration) { if (m_toState == newState) { return; } // from to newTo newFrom // 0 0 0 0 // 0 0 1 0 // 0 1 0 1 (m_fromState ^ m_toState) & ~newState // 0 1 1 0 (m_fromState ^ m_toState) & ~newState // 1 0 0 1 (m_fromState ^ m_toState) & ~newState // 1 0 1 0 (m_fromState ^ m_toState) & ~newState // 1 1 0 1 (m_fromState & m_toState) // 1 1 1 1 (m_fromState & m_toState) stop(); m_fromState = ((m_fromState ^ m_toState) & ~newState) | (m_fromState & m_toState); m_toState = newState; start(fps, duration); } void TaskStateAnimation::animate(qreal progress) { qreal delta = progress - m_lastProgress; m_lastProgress = progress; int animatedState = m_fromState ^ m_toState; if (animatedState & Hover) { if (m_toState & Hover) { m_hover += delta; if (m_hover >= 1.0) { m_hover = 1.0; m_fromState |= Hover; } } else { m_hover -= delta; if (m_hover <= 0.0) { m_hover = 0.0; m_fromState &= ~Hover; } } } if (animatedState & Minimized) { if (m_toState & Minimized) { m_minimized += delta; if (m_minimized >= 1.0) { m_minimized = 1.0; m_fromState |= Minimized; } } else { m_minimized -= delta; if (m_minimized <= 0.0) { m_minimized = 0.0; m_fromState &= ~Minimized; } } } if (animatedState & Attention) { if (m_toState & Attention) { m_attention += delta; if (m_attention >= 1.0) { m_attention = 1.0; m_fromState |= Attention; } } else { m_attention -= delta; if (m_attention <= 0.0) { m_attention = 0.0; m_fromState &= ~Attention; } } } if (animatedState & Focus) { if (m_toState & Focus) { m_focus += delta; if (m_focus >= 1.0) { m_focus = 1.0; m_fromState |= Focus; } } else { m_focus -= delta; if (m_focus <= 0.0) { m_focus = 0.0; m_fromState &= ~Focus; } } } emit update(); } void TaskStateAnimation::animationFinished(int animation) { if (m_animation == animation) { m_fromState = m_toState; m_animation = 0; m_hover = m_toState & Hover ? 1.0 : 0.0; m_minimized = m_toState & Minimized ? 1.0 : 0.0; m_attention = m_toState & Attention ? 1.0 : 0.0; m_focus = m_toState & Focus ? 1.0 : 0.0; } } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/CloseIcon.h000644 000765 000765 00000003313 11724514472 024374 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2012 Toni Dietze * * 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 SMOOTHTASKS_CLOSEICON_H #define SMOOTHTASKS_CLOSEICON_H #include #include "SmoothTasks/Applet.h" #include "SmoothTasks/WindowPreview.h" namespace SmoothTasks { class AnimationVariant; class CloseIcon : public QWidget { Q_OBJECT public: CloseIcon(WindowPreview *preview); ~CloseIcon() {} private: WindowPreview *m_preview; AnimationVariant *m_highlight; protected: void paintEvent(QPaintEvent *event); void mousePressEvent(QMouseEvent *event); void mouseDoubleClickEvent(QMouseEvent *event); void enterEvent(QEvent *event); void leaveEvent(QEvent *event); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/TaskbarLayout.h000644 000765 000765 00000020327 11724514472 025307 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 SMOOTHTASKS_TASKBARLAYOUT_H #define SMOOTHTASKS_TASKBARLAYOUT_H #include #include #include #include #include #include "SmoothTasks/ExpansionDirection.h" #include "SmoothTasks/TaskItem.h" // C++ #include namespace SmoothTasks { class TaskItem; class TaskbarLayout; class TaskbarItem; class RowInfo; class TaskbarLayout : public QObject, public QGraphicsLayout { Q_OBJECT Q_INTERFACES(QGraphicsLayout) Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation) Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing) Q_PROPERTY(int fps READ fps WRITE setFps) Q_PROPERTY(bool animationsEnabled READ animationsEnabled WRITE setAnimationsEnabled) Q_PROPERTY(QGraphicsLayoutItem* draggedItem READ draggedItem) Q_PROPERTY(int minimumRows READ minimumRows WRITE setMinimumRows) Q_PROPERTY(int maximumRows READ maximumRows WRITE setMaximumRows) Q_PROPERTY(int rows READ rows) Q_PROPERTY(qreal cellHeight READ cellHeight) Q_PROPERTY(qreal expandedWidth READ expandedWidth WRITE setExpandedWidth) Q_PROPERTY(qreal expandDuration READ expandDuration WRITE setExpandDuration) friend class TaskbarItem; public: enum TaskbarLayoutType { ByShape = 0, MaxSqueeze = 1, FixedItemCount = 2, FixedSize = 3, LimitSqueeze = 4 }; TaskbarLayout( Qt::Orientation orientation = Qt::Horizontal, QGraphicsLayoutItem *parent = NULL); ~TaskbarLayout(); void takeFrom(TaskbarLayout *other); int dragItem(TaskItem *item, QDrag *drag, const QPointF& pos); void moveDraggedItem(const QPointF& pos); void dragLeave(); QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const; void setGeometry(const QRectF& rect); void clear(bool forceDeleteItems = false); void startAnimation(); void stopAnimation(); void skipAnimation(); int count() const { return m_items.size(); } TaskItem *itemAt(int index) const; TaskItem *itemAt(const QPointF& pos) const; int addItem(SmoothTasks::TaskItem* item); void insertItem(int index, SmoothTasks::TaskItem* item); void move(int fromIndex, int toIndex); void removeAt(int index); void removeItem(TaskItem *item); int indexOf(TaskItem *item) const; int rowOf(TaskItem *item) const; int rowOf(int index) const; int currentDragIndex() const { return m_currentIndex; } bool isDragging() const { return m_draggedItem != NULL; } virtual int optimumCapacity() const = 0; virtual TaskbarLayoutType type() const = 0; TaskItem *draggedItem() const; Qt::Orientation orientation() const { return m_orientation; } void setOrientation(Qt::Orientation orientation); qreal spacing() const { return m_spacing; } void setSpacing(qreal spacing); int fps() const { return m_fps; } void setFps(int fps); qreal animationSpeed() const { return m_animationSpeed; } void setAnimationSpeed(qreal animationSpeed); bool animationsEnabled() const { return m_animationsEnabled; } void setAnimationsEnabled(bool animationsEnabled); int maximumRows() const { return m_maximumRows; } void setMaximumRows(int maximumRows); int minimumRows() const { return m_minimumRows; } void setMinimumRows(int minimumRows); void setRowBounds(int minimumRows, int maximumRows); int rows() const { return m_rows; } qreal cellHeight() const { return m_cellHeight; } qreal comulativePreferredItemRdWidthStatic(const qreal maxRdHeight = std::numeric_limits::infinity(), const bool decomposeGroups = false, int *const count = 0, qreal* maxItemRdHeight = 0) const; qreal averagePreferredItemRdWidthStatic(const qreal maxRdHeight = std::numeric_limits::infinity(), const bool decomposeGroups = false, int *const count = 0, qreal* maxItemRdHeight = 0) const; qreal expandedWidth() const { return m_expandedWidth; } void setExpandedWidth(qreal expandedWidth); int expandDuration() const { return m_expandDuration; } void setExpandDuration(int expandDuration); void rdToWorld(const QRectF& src, QRectF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const; void rdToWorld(const QPointF& src, QPointF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const; void worldToRd(const QRectF& src, QRectF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const; void worldToRd(const QPointF& src, QPointF& dst, const QRectF& effectiveRect, bool rtl, bool isVertical) const; void swapRdAndWorldSize(const QSizeF& src, QSizeF& dst, bool isVertical) const; signals: void sizeHintChanged(Qt::SizeHint which); public slots: void preferredItemSizeStaticChange(TaskItem* item); void preferredItemSizeDynamicChange(TaskItem* item); protected: const QList& items() const { return m_items; } QRectF effectiveGeometry() const; TaskbarItem *draggedTaskbarItem() const { return m_draggedItem; } virtual int rowOf(const QPointF& pos) const; void buildRows(const int itemsPerRow, QList& rowInfos, int& rows) const; void updateItemsRowCache(); /** * Distribute the items over the rows. * * This pure virtual function must be reimplemented in a subclass * and has to set m_cellHeight, m_rows, m_rowInfos and the row * of the items (e.g. by using updateItemsRowCache). * It can use TaskItem::preferredRdSizeStatic for layouting but * it must not use TaskItem::preferredRdWidthDynamic. * It must not change sizeHint because this could result * in endless cycles with changing geometry. */ virtual void updateLayoutStatic() = 0; /** * Layout the rows. * * This method uses m_cellHeight, m_rowInfos and * TaskItem::preferredRdWidthDynamic to set geometry of the items. * It starts the animation. */ virtual void updateLayoutDynamic(); private slots: void animate(); private: static const qreal PIXELS_PER_SECOND; int indexOf(const QPointF& pos, int *row = NULL, bool *overLeftPart = NULL) const; void connectItem(TaskItem *item); void disconnectItem(TaskItem *item); TaskbarItem *m_draggedItem; int m_currentIndex; bool m_mouseIn; QList m_items; Qt::Orientation m_orientation; qreal m_spacing; QTimer *m_animationTimer; QPointF m_grabPos; int m_fps; qreal m_animationSpeed; bool m_animationsEnabled; int m_minimumRows; int m_maximumRows; // use INT_MAX for "no" maximum qreal m_expandedWidth; int m_expandDuration; QTime m_animationFrameTimer; bool m_preferredSizeChanged; protected: qreal m_cellHeight; int m_rows; QList m_rowInfos; }; class TaskbarItem { public: TaskbarItem(TaskItem *item) : item(item), row(0) {} ~TaskbarItem(); TaskItem *item; int row; }; class RowInfo { public: RowInfo(int startIndex, int endIndex) : startIndex(startIndex), endIndex(endIndex) {} int startIndex; int endIndex; }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/Ui/000755 000765 000765 00000000000 11765222347 022724 5ustar00salvosalvo000000 000000 plasma-widget-smooth-tasks/applet/SmoothTasks/Ui/Workarounds.ui000644 000765 000765 00000011747 11724514472 025611 0ustar00salvosalvo000000 000000 Workarounds 0 0 359 200 Form 0 0 The margin sizes for task bar buttons are not designed for having a light effect in the middle of a button. If the light effect looks strange you can define custom button margins for the light here. true enable custom margin sizes false 3 false 3 false 3 false 3 Qt::Horizontal 40 20 Qt::Horizontal 40 20 Qt::Vertical 20 40 taskButtonMarginLeft taskButtonMarginTop taskButtonMarginRight taskButtonMarginBottom taskButtonMarginsCustom toggled(bool) taskButtonMarginRight setEnabled(bool) 199 71 261 130 taskButtonMarginsCustom toggled(bool) taskButtonMarginBottom setEnabled(bool) 199 71 199 160 taskButtonMarginsCustom toggled(bool) taskButtonMarginLeft setEnabled(bool) 199 71 137 130 taskButtonMarginsCustom toggled(bool) taskButtonMarginTop setEnabled(bool) 199 71 199 100 plasma-widget-smooth-tasks/applet/SmoothTasks/Ui/General.ui000644 000765 000765 00000017667 11724514472 024657 0ustar00salvosalvo000000 000000 General 0 0 544 316 General General QFormLayout::ExpandingFieldsGrow 15 10 15 10 75 true Grouping & Sorting &Grouping: 20 groupingStrategy true Qt::Horizontal QSizePolicy::Fixed 20 0 Only when the taskbar is &full &Sorting: 20 sortingStrategy Qt::Vertical QSizePolicy::Fixed 20 5 75 true Filters Qt::Horizontal QSizePolicy::Fixed 20 0 Only show tasks that are &minimized Qt::Horizontal QSizePolicy::Fixed 20 0 Only show tasks from the current &desktop Qt::Horizontal QSizePolicy::Fixed 20 0 Only show tasks from the current s&creen Qt::Vertical 20 5 Middle Click &Action: middleClickAction Action that should be performed when a task item is middle clicked. Qt::Horizontal QSizePolicy::Fixed 20 0 0 0 O&nly show tasks from the current activity groupingStrategy onlyGroupWhenFull sortingStrategy showOnlyMinimized showOnlyCurrentDesktop showOnlyCurrentScreen middleClickAction plasma-widget-smooth-tasks/applet/SmoothTasks/Ui/Appearance.ui000644 000765 000765 00000132727 11724514472 025334 0ustar00salvosalvo000000 000000 Appearance Appearance Appearance Task Items Space &Between Tasks: taskSpacing px 15 Minimal Icon Space: px 9999 16 Maximal Button Width: px 9999 175 &Icon Scale: iconScale <qt>The scale of the task icons in relation to the height/width (whatever is smaller) of the task item.</qt> % 10 999 100 <qt>For some plasma themes task items might look better when their frames are not rotated. This only concerns vertical layouts, e.g. when you place the taskbar at the left (or right) screen edge.</qt> Don't &Rotate Frames Draw &Text-Shadow true Switch Tasks using &Wheel true Qt::Vertical QSizePolicy::Fixed 20 5 75 true &Expand Tasks false E&xpanding Size: expandingSize false <qt>This is the width of a taskbar button which is expanded by hover or by attention demand. Keep in mind that the taskbar buttons might not be able to expand fully when there is not enough room.</qt> px 20 9999 175 false Expand on &Attention false Expand on &Hover true false &Keep Expanded: keepExpanded false 200 0 QComboBox::AdjustToContentsOnFirstShow false Minimal Button Width: false <qt>This is the minimal width of a taskbar button which stays expanded (see “Keep Expanded”). Keep in mind that the taskbar buttons might not be able to expand fully when there is not enough room.</qt> px 9999 Taskbar Layout 75 true Row Constraints &Minimum Rows: minimumRows <qt>This defines the minimum row count. Some layouts stretch the filled rows in order to fill any empty space. This way the displayed rows might be still fewer than this value.</qt> 1 128 Ma&ximum Rows: maximumRows This defines the maximum row count. 1 128 3 Qt::Vertical QSizePolicy::Fixed 20 5 75 true &Layout: taskbarLayout <p>The layout is responsible for the size and placement of the task items. Each of the provided layouts has other advantages and disadvantages. Because I can't decide which layouting strategy is best suited for this purpose I include several choices for now.</p> <h4>By Taskbar Shape</h4> <p>This layout creates as much rows as are needed so that following condition is met:</p> <pre>row height &times; row aspect ratio &le; row width</pre> <p>However, if this would yield empty rows the filled rows are scaled in height so that the whole task bar space is covered.</p> <h4>Maximum Squeeze</h4> <p>Because the width of the task items depends of their height the more rows there are the less room the items occupy. This layout sets the width of the task items always to the width they would have when the row count would have reached the maximally allowed value. <h4>Fixed Item Number per Row</h4> <p>This layout always put the configured number of task items into one row, unless there would not be enough room for all task items. Then the items are distributed evenly over the rows.</p> <h4>Limited Squeeze</h4> <p>This layout tries to squeeze the task items only up to a given maximum squeeze ratio. If it would have to squeeze them more than that it creates a new row. Currently this layout is the only one that respects the “Prefer Grouping” setting.</p> <h4>Fixed Maximum Item Height</h4> <p>This layout always assumes the configured height of the task items. Through the dependency between the width and height of the task items this leads to a specific distribution of the items. This layout does not fill empty space by up-scaling the rows.</p> Qt::Horizontal 0 0 false Row &Aspect Ratio: rowAspectRatio false <qt>The “By Taskbar Shape” layout uses this value to determine how many rows should be created.</qt> 1 0.100000000000000 0.100000000000000 1.500000000000000 false &Items per Row: itemsPerRow false <qt>The “Fixed Item Number per Row” layout uses this amount to fill the rows with task items.</qt> 14 false Maximum Item &Height: itemHeight false <qt>The “Fixed Maximum Item Height” layout uses this value to determine the size of the task items.</qt> px 60 false Maximum &Squeeze Ratio: squeezeRatio false <p>The “Limited Squeeze” layout tries not to squeeze items so that <tt>squeezed item width / item width &ge; maximum squeeze ratio</tt>.</p> 1 1.000000000000000 0.100000000000000 0.600000000000000 false <qt>Prefere grouping of tasks over the creation of new rows (currently only supported by the Limited Squeeze” layout).</qt> &Prefer Grouping Tool Tip Preview St&yle: previewLayout <h4>Classic</h4> <p><img src=":/imgs/imgs/classic-style.png" /></p> <h4>New</h4> <p><img src=":/imgs/imgs/new-style.png" /></p> Preview Si&ze: maxPreviewSize <qt>This value defines the maximum length of one side of window previews.</qt> px 5 500 200 0 0 75 true Tool Tip &Type: toolTipKind <h4>None</h4> <p>Don't display tool tips.</p> <h4>Smooth</h4> <p>Use advanced tool tips for the task items. These tool tips show window previews that can be clicked to activate the corresponding window. When you hover the preview the window gets highlighted. However, this kind of tool tip is not well integrated with plasma.</p> <h4>Plasma</h4> <p>Use native plasma tool tips. This kind of tool tips do not provide the features described above. Instead they integrate well with other applet's tool tips and move animated across applets.</p> Qt::Horizontal 0 0 ms 2000 500 Move &Duration: tooltipMoveDuration &Highlight Delay: highlightDelay ms 50 1000 Hide Tool Tip after Click true Animation &Frames per Second: fps fps 1 60 25 &Animation Duration: animationDuration <qt>This defines the duration of animations like the expansion of tasks and the delay for which a tool tip will be shown after you stopped hovering the task item or tool tip.</qt> ms 0 5000 250 Animation Speed: 0 1000000.000000000000000 100.000000000000000 2000.000000000000000 Lights 0 0 75 true <qt>When this is checked a blob of light is drawn on the task items when you hover them or when they demand attention.</qt> &Lights true true &Color: lightColor true 78 196 249 78 196 249 true <qt>When this is checked the dominant color of the task icon is used as the light color. When only an ugly (grayish) color could be extracted the color specified above is used instead.</qt> Color From &Icon true true <qt>Usually a different frame for hovered task items is used. But for some plasma themes this might look ugly in combination with the light effect. Using this option you can deactivate the usage of a different task item frame on hover.</qt> As &Only Hover Effect true true Anchor Light: false 100 50 50 Qt::Vertical Anchor horizontally at: false Anchor vertically at: false % 100 50 false % 100 50 false 100 50 Qt::Horizontal KColorButton QPushButton
kcolorbutton.h
 tabWidget taskSpacing minIconSpace maxButtonWidth iconScale dontRotateFrame textShadow scrollSwitchTasks expandTasks expandingSize expandOnAttention expandOnHover keepExpanded minButtonWidth minimumRows maximumRows taskbarLayout rowAspectRatio itemsPerRow itemHeight squeezeRatio preferGrouping toolTipKind previewLayout maxPreviewSize tooltipMoveDuration highlightDelay hideTooltipAfterClick fps animationDuration animationSpeed lights lightColor lightColorFromIcon onlyLights lightAnchorHorizontalEnabled lightAnchorHorizontal lightAnchorHorizontalSlider lightAnchorVerticalEnabled lightAnchorVertical lightAnchorVerticalSlider expandTasks toggled(bool) expandingSize setEnabled(bool) 134 254 230 272 expandTasks toggled(bool) keepExpanded setEnabled(bool) 150 255 354 380 expandTasks toggled(bool) keepExpandedLabel setEnabled(bool) 81 254 150 375 expandTasks toggled(bool) expandingSizeLabel setEnabled(bool) 61 254 125 286 expandTasks toggled(bool) expandOnHover setEnabled(bool) 87 254 215 351 expandTasks toggled(bool) expandOnAttention setEnabled(bool) 77 254 207 324 lightAnchorHorizontalEnabled toggled(bool) lightAnchorHorizontal setEnabled(bool) 198 168 330 179 lightAnchorVerticalEnabled toggled(bool) lightAnchorVertical setEnabled(bool) 215 206 276 213 lightAnchorHorizontal valueChanged(int) lightAnchorHorizontalSlider setValue(int) 307 161 247 244 lightAnchorVerticalSlider valueChanged(int) lightAnchorVertical setValue(int) 358 228 322 204 lightAnchorVertical valueChanged(int) lightAnchorVerticalSlider setValue(int) 281 199 358 218 lightAnchorHorizontalSlider valueChanged(int) lightAnchorHorizontal setValue(int) 315 244 322 166 lights toggled(bool) colorLabel setEnabled(bool) 57 47 71 79 lights toggled(bool) lightColor setEnabled(bool) 120 45 148 75 lights toggled(bool) lightColorFromIcon setEnabled(bool) 198 55 202 105 lights toggled(bool) onlyLights setEnabled(bool) 245 45 237 136 lights toggled(bool) label setEnabled(bool) 34 40 44 160 lightAnchorHorizontalEnabled toggled(bool) lightAnchorHorizontalSlider setEnabled(bool) 118 170 126 248 lightAnchorVerticalEnabled toggled(bool) lightAnchorVerticalSlider setEnabled(bool) 137 207 358 218 lights toggled(bool) lightAnchorHorizontalEnabled setEnabled(bool) 173 47 171 164 lights toggled(bool) lightAnchorVerticalEnabled setEnabled(bool) 182 46 184 208 lights toggled(bool) lightAnchorHorizontal setVisible(bool) 359 57 330 179 lights toggled(bool) lightAnchorVertical setVisible(bool) 346 49 330 217 lights toggled(bool) lightAnchorHorizontalSlider setVisible(bool) 310 42 313 243 lights toggled(bool) lightAnchorVerticalSlider setVisible(bool) 359 57 358 191 expandTasks toggled(bool) minButtonWidthLabel setEnabled(bool) 42 258 42 402 expandTasks toggled(bool) minButtonWidth setEnabled(bool) 52 254 204 401 plasma-widget-smooth-tasks/applet/SmoothTasks/LightAnchorConfig.cpp000644 000765 000765 00000002270 11724514472 026402 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Toni Dietze * * 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 "LightAnchorConfig.h" namespace SmoothTasks { LightAnchorConfig::LightAnchorConfig() : m_isAnchoredHorizontally(false), m_isAnchoredVertically(false), m_anchorHorizontal(50), m_anchorVertical(50) { } } // namespace SmoothTasksplasma-widget-smooth-tasks/applet/SmoothTasks/Task.h000644 000765 000765 00000007046 11724514472 023427 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_TASK_H #define SMOOTHTASKS_TASK_H // Qt #include #include #include #include // Plasma #include // KDE #include // Taskmanager #include #include #include #include #include #include #include namespace SmoothTasks { enum TaskFlag { TaskWantsAttention = 1, TaskHasFocus = 2, TaskIsMinimized = 4 }; Q_DECLARE_FLAGS(TaskFlags, TaskFlag) class Task : public QObject { Q_OBJECT public: Task(TaskManager::AbstractGroupableItem *abstractItem, QObject *parent = NULL); ~Task() {} bool isActive() const; bool isOnCurrentDesktop() const; bool isOnAllDesktops() const; bool isMinimized() const; bool demandsAttention() const; enum ItemType { OtherItem = 0, StartupItem, TaskItem, GroupItem, LauncherItem }; void setIcon(const QIcon icon); const QIcon& icon() const { return m_icon; } void setText(const QString &text); QString text() const; QString description() const; int desktop() const; TaskManager::Task* task() const; TaskManager::AbstractGroupableItem *abstractItem() { return m_abstractItem; } TaskManager::GroupPtr group() const { return m_group; } TaskManager::TaskItem *taskItem() const { return m_task; } TaskManager::LauncherItem *launcherItem() const { return m_launcher; } TaskManager::Startup* startup() const; TaskFlags flags() const { return m_flags; } ItemType type() const { return m_type; } void addMimeData(QMimeData* mimeData); int taskCount() const; bool isValid() const { return m_abstractItem != NULL; } private: void setWindowTask(TaskManager::TaskItem* taskItem); TaskManager::TaskItem *m_task; TaskManager::TaskGroup *m_group; TaskManager::LauncherItem *m_launcher; TaskManager::AbstractGroupableItem *m_abstractItem; TaskFlags m_flags; ItemType m_type; KIcon m_icon; private slots: void updateTask(::TaskManager::TaskChanges changes); void gotTaskPointer(); void itemDestroyed(); signals: void updateToolTip(); void updateState(); void textChanged(); void updateIcon(const QIcon& icon); void update(); void gotTask(); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/ExpansionDirection.h000644 000765 000765 00000002162 11724514472 026324 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 SMOOTHTASKS_EXPANSIONDIRECTION_H #define SMOOTHTASKS_EXPANSIONDIRECTION_H namespace SmoothTasks { enum ExpansionDirection { Expand, Collapse }; } #endif plasma-widget-smooth-tasks/applet/SmoothTasks/ToolTipBase.cpp000644 000765 000765 00000005637 11724514472 025251 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009 Toni Dietze * * 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 "SmoothTasks/ToolTipBase.h" #include namespace SmoothTasks { void ToolTipBase::hide() { if (!m_hoverItem.isNull() /*&& !m_hoverItem->isMouseIn()*/ /* commented out, because it is not clear which object gets events first */) { m_hoverItem->confirmLeave(); m_hoverItem = NULL; } m_shown = false; } void ToolTipBase::quickShow(TaskItem *item) { if (item != m_hoverItem && !m_hoverItem.isNull()) { m_hoverItem->confirmLeave(); } m_hoverItem = item; m_shown = true; } void ToolTipBase::itemEnter(TaskItem* item) { item->confirmEnter(); quickShow(item); } void ToolTipBase::itemLeave(TaskItem* item) { if (m_hoverItem == item) { hide(); } } void ToolTipBase::itemDelete(TaskItem* item) { if (m_hoverItem == item) { hide(); } } void ToolTipBase::registerItem(TaskItem *item) { item->installEventFilter(this); } void ToolTipBase::unregisterItem(TaskItem *item) { if (m_hoverItem == item) { m_hoverItem = NULL; hide(); } item->removeEventFilter(this); } bool ToolTipBase::eventFilter(QObject *obj, QEvent *event) { TaskItem *item = qobject_cast(obj); if (item) { switch (event->type()) { case QEvent::GraphicsSceneResize: case QEvent::GraphicsSceneMove: case QEvent::Resize: case QEvent::Move: if (item == m_hoverItem) { moveBesideTaskItem(false); } break; case QEvent::GraphicsSceneHoverEnter: case QEvent::GraphicsSceneDragEnter: case QEvent::Enter: itemEnter(item); break; case QEvent::GraphicsSceneHoverLeave: case QEvent::GraphicsSceneDragLeave: case QEvent::Leave: itemLeave(item); break; case QEvent::Hide: if (item == m_hoverItem) { hide(); } break; /* XXX: why does this not work case QEvent::DeferredDelete: case QEvent::Destroy: itemDelete(item); */ default: break; } } return QObject::eventFilter(obj, event); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/ByShapeTaskbarLayout.cpp000644 000765 000765 00000006464 11724514472 027124 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2010 Toni Dietze * * 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 "SmoothTasks/ByShapeTaskbarLayout.h" #include #include namespace SmoothTasks { int ByShapeTaskbarLayout::optimumCapacity() const { const QRectF effectiveRect(effectiveGeometry()); const bool isVertical = orientation() == Qt::Vertical; const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal spacing = this->spacing(); const int itemsPerRow = std::ceil((availableWidth + spacing) / (averagePreferredItemRdWidthStatic(m_cellHeight, true) + spacing)); return itemsPerRow * maximumRows(); } void ByShapeTaskbarLayout::setRowAspectRatio(qreal rowAspectRatio) { if (rowAspectRatio <= 0.0) { qWarning("ByShapeTaskbarLayout::setRowAspectRatio: illegal rowAspectRatio: %g", rowAspectRatio); } if (m_rowAspectRatio != rowAspectRatio) { m_rowAspectRatio = rowAspectRatio; invalidate(); } } void ByShapeTaskbarLayout::updateLayoutStatic() { const bool isVertical = orientation() == Qt::Vertical; const QList& items = this->items(); const int N = items.size(); const QRectF effectiveRect(effectiveGeometry()); const qreal availableWidth = isVertical ? effectiveRect.height() : effectiveRect.width(); const qreal availableHeight = isVertical ? effectiveRect.width() : effectiveRect.height(); const qreal spacing = this->spacing(); #define CELL_HEIGHT(ROWS) (((availableHeight + spacing) / ((qreal) (ROWS))) - spacing) // if there is nothing to layout fill in some dummy data and leave if (N == 0) { m_rows = minimumRows(); m_cellHeight = CELL_HEIGHT(m_rows); m_rowInfos.clear(); return; } qreal cellHeight; int rows = minimumRows(); // the row width has to be bigger than the row height for a nice looking layout while ((cellHeight = CELL_HEIGHT(rows)) * m_rowAspectRatio > availableWidth) { ++ rows; } if (rows > maximumRows()) { rows = maximumRows(); } int itemsPerRow = std::ceil((availableWidth + spacing) / (averagePreferredItemRdWidthStatic(cellHeight) + spacing)); if (itemsPerRow * rows < N) { itemsPerRow = std::ceil(((qreal) N) / rows); } QList rowInfos; buildRows(itemsPerRow, rowInfos, rows); m_rows = rows; m_cellHeight = cellHeight; m_rowInfos = rowInfos; updateItemsRowCache(); #undef CELL_HEIGHT } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/PlasmaToolTip.cpp000644 000765 000765 00000011254 11724514472 025604 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Mathias Panzenböck * * 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 #include #include #include #include #include #include #include "SmoothTasks/Applet.h" #include "SmoothTasks/Task.h" #include "SmoothTasks/TaskItem.h" #include "SmoothTasks/PlasmaToolTip.h" namespace SmoothTasks { void PlasmaToolTip::unregisterItem(TaskItem *item) { Plasma::ToolTipManager::self()->unregisterWidget(item); DelayedToolTip::unregisterItem(item); } void PlasmaToolTip::showAction(bool animate) { Q_UNUSED(animate); // qDebug("connect windowPreviewActivated"); connect(Plasma::ToolTipManager::self(), SIGNAL(windowPreviewActivated(WId,Qt::MouseButtons,Qt::KeyboardModifiers,QPoint)), this, SLOT(activateWindow(WId,Qt::MouseButtons))); updateToolTip(); Plasma::ToolTipManager::self()->show(m_hoverItem); } void PlasmaToolTip::hideAction() { hide(); } void PlasmaToolTip::hide() { // hides itself on leave even when autohide == false! // if (!m_hoverItem.isNull()) { // Plasma::ToolTipManager::self()->hide(m_hoverItem); // } /* disconnect(Plasma::ToolTipManager::self(), SIGNAL(windowPreviewActivated(WId,Qt::MouseButtons,Qt::KeyboardModifiers,QPoint)), this, SLOT(activateWindow(WId,Qt::MouseButtons))); */ DelayedToolTip::hide(); } // XXX: for some reason this is never called! why? void PlasmaToolTip::activateWindow(WId window, Qt::MouseButtons buttons) { qDebug("activate window: 0x%lx", (unsigned long) window); if (buttons & Qt::LeftButton) { qDebug("do it!"); KWindowSystem::activateWindow(window); } } void PlasmaToolTip::itemUpdate(TaskItem *item) { if (m_hoverItem == item && !m_hoverItem.isNull()) { updateToolTip(); } } void PlasmaToolTip::updateToolTip() { Task *task = m_hoverItem->task(); if (task == NULL || !task->isValid()) { return; } Plasma::ToolTipContent data; TaskManager::Task* taskPtr(task->task()); QList windows; int desktop = -1; data.setAutohide(false); data.setClickable(true); data.setHighlightWindows(true); switch (task->type()) { case Task::TaskItem: data.setMainText(taskPtr->name()); data.setSubText(taskPtr->isOnAllDesktops() ? i18n("On all desktops") : i18nc("Which virtual desktop a window is currently on", "On %1", KWindowSystem::desktopName(taskPtr->desktop()))); data.setImage(taskPtr->icon()); windows.append(taskPtr->window()); break; case Task::GroupItem: data.setMainText(task->group()->name()); data.setImage(task->group()->icon()); foreach (TaskManager::AbstractGroupableItem *item, task->group()->members()) { TaskManager::TaskItem* taskItem = dynamic_cast(item); if (taskItem && taskItem->task()) { windows.append(taskItem->task()->window()); if (!taskItem->task()->isOnAllDesktops()) { if (desktop == -1) { desktop = taskItem->task()->desktop(); } else if (desktop != taskItem->task()->desktop()) { desktop = -2; } } } } data.setSubText(desktop == -1 ? i18n("On all desktops") : desktop == -2 ? i18n("On various desktops") : i18nc("Which virtual desktop a window is currently on", "On %1", KWindowSystem::desktopName(desktop))); break; case Task::StartupItem: data.setMainText(task->startup()->text()); data.setImage(task->startup()->icon()); data.setSubText(i18n("Starting application...")); break; case Task::LauncherItem: data.setMainText(task->launcherItem()->name()); data.setImage(task->launcherItem()->icon()); data.setSubText(task->launcherItem()->genericName()); break; default: break; } data.setWindowsToPreview(windows); Plasma::ToolTipManager::self()->setContent(m_hoverItem, data); } } // namespace SmoothTasks plasma-widget-smooth-tasks/applet/SmoothTasks/TaskIcon.h000644 000765 000765 00000006162 11724514472 024236 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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 SMOOTHTASKS_TASKICON_H #define SMOOTHTASKS_TASKICON_H // Qt #include #include #include // C++ #include class QPropertyAnimation; class QStyleOptionGraphicsItem; namespace SmoothTasks { class Applet; class TaskItem; class TaskIcon : public QObject { Q_OBJECT Q_PROPERTY(qreal startupAnimationProgress READ startupAnimationProgress WRITE setStartupAnimationProgress) public: TaskIcon(TaskItem *item); void paint(QPainter *p, qreal hover, bool isGroup); void setRects(const QRectF& contentsRdRect, const QRectF& maxRdRect); QRgb highlightColor() const; QSize rdSize(); QPointF pos() const { return m_pos; } QSizeF preferredRdSize(const qreal rdHeightContents = std::numeric_limits::infinity(), const qreal rdHeightMax = std::numeric_limits::infinity()) const; static QSizeF preferredRdSize(const QIcon& qIcon, const Applet& applet, const Qt::Orientation& orientation, const qreal rdHeightContents, const qreal rdHeightMax); public slots: void setIcon(const QIcon& icon); void startStartupAnimation(int duration = 300); void stopStartupAnimation(); private: qreal rdHeight() const; QSize actualRdSize(const QSize &size, QIcon::Mode mode = QIcon::Normal, QIcon::State state = QIcon::Off) const; static QSize actualRdSize(const QIcon& qIcon, const Qt::Orientation& orientation, const QSize &size, QIcon::Mode mode = QIcon::Normal, QIcon::State state = QIcon::Off); QRgb averageColor() const; QRgb meanColor() const; QRgb dominantColor() const; TaskItem *m_item; QIcon m_icon; QRgb m_highlightColor; QRectF m_contentsRdRect; QRectF m_maxRdRect; QPixmap m_pixmap; qreal m_progress; QPointF m_pos; QSize m_size; QPropertyAnimation* m_startupAnimation; void updatePos(); void animationHover(qreal hover); void animationStartup(qreal progress); qreal startupAnimationProgress() const { return m_progress; } void setStartupAnimationProgress(qreal progress); signals: void update(); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/SmoothTasks/TaskItem.h000644 000765 000765 00000014755 11724514472 024253 0ustar00salvosalvo000000 000000 /*********************************************************************************** * Smooth Tasks * Copyright (C) 2009 Marcin Baszczewski * Copyright (C) 2009 Mathias Panzenböck * Copyright (C) 2009-2012 Toni Dietze * * 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 SMOOTHTASKS_TASKITEM_H #define SMOOTHTASKS_TASKITEM_H // Smooth Tasks #include "SmoothTasks/Task.h" #include "SmoothTasks/TaskStateAnimation.h" #include "SmoothTasks/ExpansionDirection.h" // Qt #include #include #include #include #include // Plasma #include // Taskmanager #include #include #include #include #include #include // C++ #include class QPainter; class QStyleOptionGraphicsItem; class PeachyApplet; class QRectF; class QSizeF; class QGraphicsSceneHoverEvent; class QTextOption; class QTextLayout; namespace Plasma { class FrameSvg; } namespace SmoothTasks { class Applet; class Light; class TaskbarLayout; class TaskbuttonFrameSvg; class TaskIcon; class TaskItem : public QGraphicsWidget { Q_OBJECT public: TaskItem(TaskManager::AbstractGroupableItem *abstractItem, Applet *parent); ~TaskItem(); Task *task() const { return m_task; } bool isExpandedStatic() const; bool isExpanded() const; Applet *applet() const { return m_applet; } TaskIcon *icon() const { return m_icon; } const TaskManager::AbstractGroupableItem* abstractGroupableItem() const { return m_abstractItem; } Qt::Orientation orientation() const { return m_orientation; } bool isMouseIn() const { return m_mouseIn; } bool isExpandedByHover() const; void setAnimationTargetGeometry(const QRectF& rect); QRectF animationTargetGeometry() const { return m_animationDestinationGeometry; } QPointF mapFromGlobal(const QPoint& point, bool *contained = NULL) const; QSizeF preferredRdSizeStatic(const qreal maxRdHeight = std::numeric_limits::infinity()) const; qreal preferredRdWidthDynamic(const qreal& rdHeight) const; static bool isExpandedStatic(const TaskManager::AbstractGroupableItem& abstractGroupableItem, const Applet& applet); static QSizeF preferredRdSizeStatic(const TaskManager::AbstractGroupableItem& abstractGroupableItem, const Applet& applet, TaskbuttonFrameSvg& taskbuttonFrameSvg, const Qt::Orientation& orientation, const qreal maxRdHeight = std::numeric_limits::infinity(), const TaskIcon* taskIcon = 0, const QSizeF* preferredTextLayoutSize = 0); static QPointF pointAnimationStep(const QPointF& current, const QPointF& target, const qreal v, const qreal dt); public slots: void setOrientation(Qt::Orientation orientation); void activate(); void settingsChanged(); void update(); void updateState(); void updateText(); void confirmLeave(); void confirmEnter(); bool animateStep(const qreal v, qreal dt); void skipAnimation(); signals: void itemActive(TaskItem* item); void preferredSizeStaticChange(TaskItem* item); void preferredSizeDynamicChange(TaskItem* item); protected: void dropEvent(QGraphicsSceneDragDropEvent *event); void contextMenuEvent(QGraphicsSceneContextMenuEvent *event); void paint(QPainter *p, const QStyleOptionGraphicsItem *option, QWidget *widget); void hoverEnterEvent(QGraphicsSceneHoverEvent *event); void hoverLeaveEvent(QGraphicsSceneHoverEvent *event); void hoverMoveEvent(QGraphicsSceneHoverEvent* event); void mousePressEvent(QGraphicsSceneMouseEvent *event); void mouseMoveEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void dragEnterEvent(QGraphicsSceneDragDropEvent *event); void dragMoveEvent(QGraphicsSceneDragDropEvent *event); void dragLeaveEvent(QGraphicsSceneDragDropEvent *event); // text QColor textColor() const; private: static const qreal MINIMIZED_TEXT_ALPHA; // "string table" static const QString GROUP_EXPANDER_TOP; static const QString GROUP_EXPANDER_RIGHT; static const QString GROUP_EXPANDER_LEFT; static const QString GROUP_EXPANDER_BOTTOM; void activateOrIconifyGroup(); void drawText(QPainter *p, const QRectF& contentsRect); void drawFrame(QPainter *p, Plasma::FrameSvg *frame); QRect iconGeometry() const; QRectF expanderRect(const QRectF &bounds) const; const QString& expanderElement() const; void drawExpander(QPainter *painter, const QRectF& expRect) const; static QRectF expanderRect(const TaskManager::AbstractGroupableItem& abstractGroupableItem, const SmoothTasks::Applet& applet, const Qt::Orientation& orientation, const QRectF& bounds); static const QString& expanderElement(const Plasma::Location& location, const Qt::Orientation& orientation); void hoverEnterEvent(); void hoverLeaveEvent(); void drawTextLayout( QPainter *painter, const QTextLayout& layout, const QRectF& rect, const QSizeF& textSize, const QColor& color) const; KUrl launcherUrl(TaskManager::AbstractGroupableItem* item); Applet *m_applet; TaskIcon *m_icon; Task *m_task; Light *m_light; TaskManager::AbstractGroupableItem *m_abstractItem; QTimer *m_activateTimer; QTimer *m_updateTimer; bool m_mouseIn; bool m_delayedMouseIn; TaskStateAnimation m_stateAnimation; Qt::Orientation m_orientation; bool m_updateScheduled; bool m_staticallyExpanded; bool m_dynamicallyExpanded; QSizeF m_preferredTextLayoutSize; QRectF m_animationDestinationGeometry; private slots: void updateTimerTick(); void updateToolTip(); void publishIconGeometry(); void updateExpansion(); }; } // namespace SmoothTasks #endif plasma-widget-smooth-tasks/applet/CMakeLists.txt000644 000765 000765 00000003454 11724514472 022634 0ustar00salvosalvo000000 000000 project(smooth-tasks) find_package(Qt4 REQUIRED) find_package(KDE4 REQUIRED) find_package(KDE4Workspace REQUIRED) include(KDE4Defaults) add_definitions(${QT_DEFINITIONS} ${KDE4_DEFINITIONS}) include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${KDE4_INCLUDES}) set(smoothtasks_SRCS SmoothTasks/Animation/AnimationThrowPoint.cpp SmoothTasks/Animation/AnimationThrowRect.cpp SmoothTasks/Animation/AnimationVariant.cpp SmoothTasks/Applet.cpp SmoothTasks/Task.cpp SmoothTasks/TaskItem.cpp SmoothTasks/TaskIcon.cpp SmoothTasks/Light.cpp SmoothTasks/LightAnchorConfig.cpp SmoothTasks/ToolTipBase.cpp SmoothTasks/DelayedToolTip.cpp SmoothTasks/SmoothToolTip.cpp SmoothTasks/PlasmaToolTip.cpp SmoothTasks/ToolTipWidget.cpp SmoothTasks/WindowPreview.cpp SmoothTasks/FadedText.cpp SmoothTasks/Global.cpp SmoothTasks/CloseIcon.cpp SmoothTasks/TaskStateAnimation.cpp SmoothTasks/TaskbarLayout.cpp SmoothTasks/TaskbuttonFrameSvg.cpp SmoothTasks/ByShapeTaskbarLayout.cpp SmoothTasks/FixedSizeTaskbarLayout.cpp SmoothTasks/FixedItemCountTaskbarLayout.cpp SmoothTasks/MaxSqueezeTaskbarLayout.cpp SmoothTasks/LimitSqueezeTaskbarLayout.cpp) set(smoothtasks_RCCS resources.qrc) qt4_add_resources(smoothtasks_SRCS ${smoothtasks_RCCS}) kde4_add_ui_files(smoothtasks_SRCS SmoothTasks/Ui/General.ui SmoothTasks/Ui/Appearance.ui SmoothTasks/Ui/Workarounds.ui) kde4_add_plugin(plasma_applet_smooth-tasks ${smoothtasks_SRCS}) target_link_libraries(plasma_applet_smooth-tasks ${KDE4_PLASMA_LIBS} ${KDE4_KDEUI_LIBS} ${KDE4_KIO_LIBS} taskmanager) if(X11_FOUND) target_link_libraries(plasma_applet_smooth-tasks ${X11_LIBRARIES}) endif(X11_FOUND) install(TARGETS plasma_applet_smooth-tasks DESTINATION ${PLUGIN_INSTALL_DIR}) install(FILES plasma-applet-smooth-tasks.desktop DESTINATION ${SERVICES_INSTALL_DIR}) plasma-widget-smooth-tasks/applet/imgs/000755 000765 000765 00000000000 11765222347 021027 5ustar00salvosalvo000000 000000 plasma-widget-smooth-tasks/applet/imgs/new-style.png000644 000765 000765 00000261464 11724514472 023477 0ustar00salvosalvo000000 000000 PNG  IHDR 4msRGBbKGD pHYsu(xtIME As IDATx}y%Uuv9 42 Q jLC>ETq@ FT4g 8߅DdC ?`of?de-O{]nT̠@j>Dܿ _3D i[x( !@B` !P AajP,eAQ`P @( Js|b{/sv7gch^Ϡ~TTF2C20 TKƈ%*ɨc,dJ1*IJ2J dPJQW`4A*3YTk7sB oGxuZ3v~69=zKORH\'&W(;;=n"ۮ??`z}N WHsmw^w9Op4D۹nzqMJ4DֲZo0s/E(',}# 6,rm)Pn*ؿؙ㺃FF}̸~lQJ{!(0P2(*Aa   쥳B%ZA@QYJߎ$mƹ &87KVFQ TJA2Tl=׊~TIحgTRb@*赒7<kPxYt y9kW/Ŭs;OCڝZYl,RE1Mr}D]FYk<ۜÔz%|=P9ee fT({XŗYzIi]Fx&h0]ʩk#j"+%L o,jazo"jHU0sm$/0& #;+ .JT,  d&%`fHQAR\? }TJOh.g^~on=.m,0v:M(Vrϵo6pas}yzR 3,h'Hc3 1 A00^pf Y/ړP0A `/XQ{EF54-Xd7̵Ʈݟ ػT b3^RMFs X+t:V_)Sj? G mD(׈g4h#$e*"J*IrY5UC #CSd!`[I憷 J@]9NfLzLN$9Ӣ :V_N]Rs^,yRF 3 6GB 2^[gC!9dA5P485ʞp=S^' b"8BNqSV 1ŧh}f%阼jj!I'&]<Xс 3R0H+n`JhO %Z  QRB@Сu<_1}2+YA,1a_@"I+ړWLRmTp`{gaJj&)$ծдǣzgynL *Z=<嬰sn5~\7W9CJme.K.ך O%fNzHkCC`cR/gfdLL6jJ8r"6!f%(XhF)$О7J*' W@bJ@DT [UƺKe!>4-OjbֳXJ(P^C֫ I쳉~/({1B5m=N"0„}DrB+=ENCYVku(<1Ԯ֙>E-/bs2߯sbH#tr$co# [Έlh"Mcm*L1ȉ\ߊHON25v컳xef*?f,hp ) J=l\]ue{tk 3K ԯa T„X J 1*bL"/`?P$ Za F Άoj@JQ9 K:v_)*Q/L:OX6/wd ONϣ&_FpJF=e꺻MJ)~):~}pC yb2Щr=TY;}S28-pf3'70s P$arRȓ$^)# T/Xj6\ b31oۉLekI)H&N.B$I9$Ժs)ooL6"P,IK%!JR_2 D& _ (LRix* A:N Хy%:-Q Xy$Cϳ]xM1u ^JTJBֵl9l{؋+n:N0ѡ씅U\:g=#]N uL) 2N(/( >&øAq9 |;kBHDXRej'߬Kxu\|LܗpKmT, <?gd.x=rQ.L%dm5/2#s-rƩ 7?KD‚R9ᰶ "2U FɊ+#AZ!TwkTR5d'.P.˗')$bkt:"_Q;G%k)"$1FCf-bQ_7BY;QSƂI! 1FB 0.  (PT@) @QR'$׊PhG| RP Uvu@+ŵ^R{mi1Z:vԎsH25LjA@d=p^a'-&;0x]#Ll[ 0z[aX!9N"G,pǸ'@-ZȎZ=T2#YGn&U@"ϔ*yi1LzHa^mEi=dQʍEИ%h,8b}[Z J-r}RȢrT'!c3mP| IALHQuvHb?{ )ϵ'HC zJ(RJ*Wh_a+2a0>pTWf E2fk6u5Ư CS:瞒0x*ugP3pCYzl8'< )#f$lCĺ$2 8rn8P-BAB@S pe Xe50&HC|ME[<~!&S7n#YŜgK'rkt@=Oet":wC|m8aSu:˶斈YxRƻBf5{dMM(X&j ,5Y~VR*]&p =- BE.PPa~ P!/ Da$N,:F)c`[aij56YO즉7R3k%_caqHȎO`Xk'uq5B&^8Vw,B;ǐ:%WQmYz|D|#RIϽ y:rBB#[YfZxU%K&[6㝗iڑs0+d q1OhrLԅGw'=h0aPfV`tɚ8PD0Ud0~:;3IEq,eo/ߵ!dYJo]P`8#k)䌥0wT<ζr7|(4\Hh^``(j|A(ah bxuM&6 aMA *@dj~ fadЇ h ]tp@C;iP%eFL \0SSIar48xM̨kCћKrIDʄ2$Qr'!!tgqV #1ʾuC2CO^UF+ Y{{Qn}qJ(]TٝirN*/^xZ1:Lr}3ȒD8KdΔ߻kJ2bIFuK17%u5 ||s( 4YPKIe)>>26%ur&7ͣn`n#>7DdB Q@F pQUq9E'{+Q(Y[LPRj,CU*YtLБꟲCScv\WXEb3v$LpKnrBAܔ ' "  ~J 45^qy Ԕ;8(QQ{DpݐӺe(=f;&&4c@,ȹUgGTVVĉOnbpPKń)j& 8ʴNpǧ dJdƎc;Rp[;q2ӹ5?f-t0$| }b91:ZqY@f\T9B>靑\AK<ܜ"djj`od p D"0E InLߵڟ[ZQM) UUPx5cb!v *kw6Cƈ:5 2Q\ +>6>cȐǂU=tJ!5b DOۍ'&DlLfuX@ar.YOE=LyM/ꠑ Q")s-;O>9s܊#@:CX ϑ"L$EYHߩBpk~4N\>B!g/A=ALκE7DU䮧gu5HGӝ|y,~#\<OZ&ÝZ\ AJ-&gEOƳ'@&!\=*Yjȟʾ;k(jne;7P1T5*T11xOǣVp-ۖm˶e۲mٶl۸M?>;l6n't2J߳W$X}5a< |܇:~;*[FiOFԞY=5ҒRQVF|R6V q4`(03! e퍐JvIm )@ KPU= nҴNiֹS?-$*`2:._We(TyPSipNh0[_E! iFPAZ҅ _l"PwBs_^ T;,tIuN6/KϞ*4n!dJ̺dg,r % ;GR&.rϘ,g$֭'m49T;s>Ep83h-'54pGcܜ֮9꬈Kg*t'8) iȦZ!a&SʬDưS-?ʽo.%ܣ%mZ_š^wuϞFWҊ<7'ZV6o\49@I %+@B`6kΘj\%ϭG+(@sv'U%e"x :i_1Ii \cQ"HZkYzu[BRT'PC0Ti\+tgc=Ebe{C '7^۴])> 9\8WRiT` $P3w5sϳUy269!0ꄼ}%?ؽIc"4Ҧ\ٙGɕ~us&ژTЌ)x 3Xbz@LSհL"3BVR֓WU'lTIe`+ H`0, {w>B!ems͈机R8c,TiKm(D36k8aZ! g6fBő'ʢ@%U>ѷ* I.$bڀyP+q'L1nň[ZcmgK'C m{{"ONx8f1x1܌DYf"~Lӳ5&IkrzQG@}vr#r!RwdS<&a_'_4w)/A2> $9pB_>ᶷx,Ko"1&H~]֙iߑn_'D C*SUrk-6\)О(f{Ho긾'U+t@xIs8Q2-0HhrWR90, ,z4u(rpn2^Wݎv5Y-h w^,o\Z.AdH\xͿJ1D)L (av"ZgԊ!9}L|_uL: 5i˕A T,.oȾ9"T)[G<:O.=:V̈́ܰMг|%h$5RBP0 (6[%mc"5R4 1z0/oʤkVRzN~iˀsd,>k/>%gI=>蹱)ڥkڒ{w z2ȊhB8-_%_9BF.6\JMKZ dy9'D0X) }Õt1yX:E6`oKuUhԝLBI3)Olg96\-TRfOy{s^%o<0ȗEaj1rst^9^hC Rdd@tQѣ}+U9KdB\rP\UT_ \w4lQũ O47H~Q* Y>)UjF87FF"Ɍ24GNUR(KQ("٥kHCaX r=I*>Xڳvx7?Ʋ9).ǘ;ns{ rʀITZ|%AU$3^0 qRCxyA$ƃ`Fj`.}1`??+\e&_q8%hL,9ss uskEZzQ,y K:+9b~ƢT S!fQPR{ P r]HTS1C1MWR[c]Y} ǃr$4ۂt\ib'M=X}c 9;,VdIuE|Jʤ<#1]ؔ:g >Qz英j뭱n:kn +W{ŪU;5yѡP6̀zZkq?- ~5~x3 Xbnv+( ^"3-!rL5`N_]nkʱ12 HBl5(Bw e <;#Q,+L ʨBaTl׬{9GA dI !ڦ>kx8ߛpz|FwN`ގ};Gq׫Oxb;OzR8^"K#V\7ay-y;<;;pjg=S+᭶ګ>`Pb] fVo 4j;T{ rr/~:l6 "~?֞>>6l f`wpJ (6 e˗a9V=AJ5TK;H4`G?|>իKe^o8bJ򕯆4HaqJQHȢ\NRm9V4 U.?)djFiN+}B+29URc G<=FPRb'0cL u 6[PbO)--\A,4yn}Re𓢌\fT WE9XPO =]_X~ěu2zSRQXSBĝ55nx)Z,}q/}mXWAB)OI ؄(~>%[\]&HLl}*oNV2x^<n\iU$PP+zfupo=#VgQ.cR}?9 nu2g{\뎁§Lfzq$ xpɒli~~$|"l7+OvJ=T^qfo~[dTG>0+qT!1lYѺ=Fc@u;J^0& r(ddA.}GH S(sGU>9Y(͇w"c+̲XQ^OuY-a$5mǸ&hl Gqo\% u ~X(ڒlB>~JjZ]oY$H0$zKH\۾]XG_p3 S X zXIJ˗@cap3OR[Rxq83iy6"lu®|/߆|Մ,,ʝ㤬# #B\cļbbjJ(iƺԈ .(Xꏰ~^NO;|ɏ ftϦMp%yφ[ IDAT{J/SSSS>_p_;ls ve E׿ 8SsO~+@Q8nǘƽދnO~N|}믻B*o|cn: __߉kON8餓G[o޿n 7ބ/|xcE]i(>^xgczz˖-q?O}җ7x#{QXvx>c=sssg?U{ԧ?WcիqS`w0-^ᜬ:d6&` (wjn~)*V:+E &&P"Yu6ۄ^[(D/yHKHBt!ΞDovKe7&zSzYn #"9i}+)1?EK]!|+\P^M5Z ȮSAr/ƭ&f ,&[sNC`lŲ胞mNYgc_ k/j+6urж1tєC͛{!>w߿˿7{'g(}sOzo|1==wx3F!0;;|xӞ7-oy3v};O=i('(|sG񒗼{<@} |'n^g}p뭷5z?{8bC7߂o~[β,q‰'O|"0cr!zU曱O&[>rcO?I)rU@czZN:ߞl~Ų*TyȅyQb0 g~;joF]BJn[:]6lj B7r)3& bZB̛>[{PP)P:Z>=Uhj Rf^dv_{Iu-Gm2(=RY(MgCfeoPѧ,ܝ&=^,,cà >'jX~[Ml[EoີcmVWpj é~p S;nٔVI{xџ#`j0 4S@1yB=ֶ崏t^Lp'i sHJ̏ƝL*OƔ0:TXB8M*/5-|6+s=nJ(نYI*I(gV NR5X S2"r^/8ᄏn𞙙o|G'>x":le/]c'o~NO]?%9__}{/OG?r-{7?Vo-=CML}?gO=(LOO/s=/ᱏ},^☣E9kp{\Nu0M[ ܣiv7x+ d8BU1gl^#RJ i,^apQSO9B\)`\URvgKᜏbTr}+Tj!N_dÅ'4CDiz::wyc͛SJ1*Eq I+ AA(Q(`ߓfSįy\+|xe%$vXv-=CK>K/k~7O<+yvx9߻%9'>q039hu_%9}UUU|%`?ĵb=^ۨ"PIIK|x混OuѺKMkL6lIEƊP UJ`N,C)pW X5B( ̢QEΙøR)(NȢ@Q'<6 'QoI '\d ̕S!؊UU}Y3J0!7-Je´b Z{ 0t!&]q]1 G}gq&^WzIGy|OλjZo?~_^s ~1==7qO|^y;Kw@]|r|}zqy&?q.2"26<'/ffgj˼uزm~khmvvݻ>RW%V é) Þi'ҕITNc~_ rpN(`כBiw ETU }>!CV$_(V-ǓwŠ!x\פ ܝ7"q6 ed& =FGr㨡e˾^BC<8/rbϔ3}>vINwh3jb 4/Ca%Gwt  X h3;xɖ(# v1v.፝#.yUɰ9gTB`j0gX VcL@)p!\C7}zNR!F XGl*[ԧ?gy&~+nR1RP'%k[n2.}<椱W9U-lJU%2&Oo saV*9¶O,gyOto,L[֦|bN|WgmOfdBRNYHBk'@9Nfn饐;WH+e.wf5|-zd0܆8ܙ#K4:mD,pd@LsW7sZaPh,5KnZ!\ǫn՘S7}WOqWkw܁[n'p-x/;v{pfggqě{J)|;N>R)\p1i^n6}>.̌~ѥb ԧ?s=wuW6l_38|3jo۝T*e{R})}~*t,5M*ץ/=5t\#c133GcӦӎoCYx+^~x͹Wո暫q {쎏|8C}^qaFsԘK'>ƞ?-d;{ST{w{ex 2j\We;_^zKɗZHnoghAQh"KC)굽`yYk}N; 333{C#<\p:UW;n`fƅ^!>| __uᦛn³lN_zwy8Cַk^^'$X 83a>{ރ5Xyw܇+V6Y;SVXOyS]wŃ5(fl w>X+lW2iq4iȐ=c5W:w4v9,@vK8 MBs?ʿgw}X6=MλXxӛބ/:Oɸ;, ☣/֬ӟzx_^}5o+.ǁL2G:kW ,2(Dx[-祥BT~sk,w:AŘJ>AO'TXj=Y GE97cY x"M{km~<<8.vwm+X†(In>9"nR? 7oϫ ͈1ޒnDm<݅);O/ c Eg‚eK30==˖->2n!m£V.`cl=%{rYq'`YZ*kJR^{m&[vѵ 0xpfr|g6DxvVgW+1pj*w " S&^_#xnx҉ z0 2vȲvAY`\i6 0ja&e055o2: v:]wN %A_bV|yL~0j-O>z~ALe۲=%1k%*β !"oXhIV]Y)VTN@'yҴ;nA:?HwR71unٶl;0s3hqzmU}sOt)nN,1 _¯;5\J1h@v9au0 G4hF0(@Qq@aR 7p8gSg+p%N?}+_jbffW]u?7ߌyr)޾p\tF8pছn9o 6n)%/333޾/~K½ދw\s nVTUUwgB)Ex{N8;R <{x;߅k⮻?ƍN;-oy+#qW[o;cp]w _<W_}5տŻsN=Tlذm^~ַxo;II&}^hMƉ]%k˶e{[DWW"SŖIy-n8Q6>)>Q[ @] vS{ 2.<>̦?{o'UﭪfhK-˶d˻M``L; ! & $@ ,/c0*[d-m4koUu}vWf,[>*hs εT* QJ}a&&&x%.+W.z!?M^Or8<|CW^h0jZ֚N=Js92x{|ӼWغLw%/9y.o#8CwU<Åe/m᪫x;0 ͽOG\uէpN9d^^+`ٲeފ\t Xs1Tk5.~K7}hy{ޛ{駟NZ92>wS#᫜gF {gbzz׻# ֓jGMz: Mf jV|]jwJ!6 -go4 דּs=k92y IDAT ߹9zo|w-]+p'1ƬStm>O{SA0FbҨNGmhڰman)W^!VZŃE^1OLL~g?Qgxx7^vY!׾'%[g!D7~_sl^m/~H)yӛ{}?7pyx;g|hO]]o?1,Ye]^C&a̤; Xy܈f9æd: PE &T ZD0DiEA$J+&zB eϥ}Nχx)_o4hth,'IyZ ҊPYP+2}O!a*1 D׌"0ar UTh$>J(F Ў U&蜡O!}Psi;QJhmk QB <*q頇Y@WT͜ZXg- f@(oų?FEy|]СQD8WAzzcmȴ1UstZ~WnV.x3%_׮>i^xEg<{k26>¡>}RĮݻXl9> 'tr \p߹Z^𵫯w_*~s ^:͛7s2>1ЂÛh۔eFvb<l8i7|3zֳw%/})_7x+^1/q睜ulٲ5k011 뽴Z-* ###XSN><[6^r ;\wu\xy]h4qRD/|U}$goƓX_niLOMq)''Y eTo1 kvդ@BDCX_! VKKF%)0J^˪,u\)m8H$i2:(42rb l6}vN5 B6`6 kS6GF 9ާ"#I^;zwuZh=F*Rr+P+kDi&L^E6yFAѽ1l|S=Ń{S:smi{6O3z(؜}jTǝu>qd* 5D 8 WL6!z\3ۏt-yA)Ň>t%W\9'P?t>^h6|ze_#G/>;k{p8(C([wA+Hg#&#ʵZ+*%P١-4 a5aL,tFSv)Cx,&cibT(Wtkh@M(XÛFY!jPg C+? /"cY$06z~-HQ@th $n`{IZeغ6udnv @{kP-MF]C`` +G#|;1Ow irxfRM|r_0"AJS~ltV4@ַͮ4D,~Q.|ޙ(Y''0PFQ͵6i<)ZQ+ rŊBtgB6x,)ZC}zJň],&mŠ\w$m̏@)<Ǎ$keU ' fu҉Sۙ,]|gIᅵ"}&MJQrBX1wT?`vĘ9>GoO[]œܯKd*qg /. 9Gˀ6m*e6_`j:B'i r>6k+ѣTBD$NI|.?V*|?a_ [2|ŕŦɫJ!_C6tfקY40M1nk{;<+D{9gR9FY5AhIkw:ckf5_{\z[tM~< .˛ u `<N*{:tg{4yC{8rsߡ g}?Nr crrx֓n12W`!LR*D.0[S)pBAs8O#鵩B3BAGrZ͜(Υ ~h *jG3® ޠLt/YUB!61 BylCզR.'Y 2c*m!q&Qm;"̊_X=t'83 &Qȳ tmZhgױDe0iE^TY98d; &j;[lgj<~!D2+jCA/wz=Uya4c 1ILʛ1G}p)26t{!QAa fuG=ݎ#m1\֤EzB $nEgMv(ew[Ŋ46eϋC :Djb!N5\V\o\o^ÈgzsEaR`J:gƶf 状{*m=kK <(6G«o,#Ǒc-ܪ{2;һ^{!?8 :EĀwU%P )%KbG@J'1\D&Rz~Ԡ%QڞS"U\)U0q$EH Ŏ)ْ`/ux\?._MB)u:D{U#CaQ3-f# 혙1[KlİĬ*nMf> $"B֓I Aq׌P"V̥V;_)$L"[Nb1S% )Yu!,ܕHՙ:?GpץU\jK(ύi>IMihfh+mZv@3CmF"0'nU$H`S&S_G_!330\~iǤ:2\hW"t/^^xS|W?tIoaVnnut:yM&.CAB u'/?TL$hcEFMut5`;o |3.͆"Fº$j I#lNZ K.7\XY~晵\2kڜ nnzԖ9yٓuy0 ,溶:?M_}Nj/~ '8묳՞9: Z+;cijC"2 M[Hs~%ST"v‘PH|GҖ!FcB锾_y\PbLԨcCF&%:` -&*ccy=B} /;T~)' JߔIIaj V'ıqub9(fs@Et2[ R5Ž8Bjn792Q!iPl"5Z)yyԧ*^R`k,6IaHp.a"+2%n:i7G_ҁQ#sŹ"{{wϷ}L,:*ENA4:=&Wd%,ȴeɍ7ˍ\NKPPTE1 "t3LT遰%fr)L@.XcQq+! L#oRW-rWt}v;R.MX=MT__/zQ(V8Je=Ol%+-A"HlQQ7 [ wmWvo&вpܻ񊗇7+/ Ƙ\T,H+N? {.ڃvvMF/"H_:m&/g"S̋ !73:~o:9 &CNRĤN@g|罣4- }zs:L&].V+0(\"O]Ktc$ue;22H?XtBݰuǀf"WO BbI6 rL 4Zm7߾KOZ>r%ɦ6jlӣ{"W6?\BS]|o>~Ҥz_}<͉gm{y/󟡴 ug93;nRO[kw_K64}'`P[^8R痿؏w !붟dRQlRF"D7\l?{ c?gЊx㰡hP"Njeܹd<*.WxM\y 3QyAHW~|^݇>߻y J? 7o+|rx۾v#ox;xۿ^۾mG ttL .pz4㶫Ĉ 4HAˍkm8ja-ِ}J2+m:miǁNm-6etB3㢿8@))9Lj5elbٓzo>8seћzVFƹMb-B<d:>WzHfqDK_K+.1 &'h>cvCS\ڭǗc#=xH!7 МSNac8 ~|WȞXrU5܍纄J19:ʞMR;e=S߽4'%g dA㟢V.\~O.ˏ=*RJnTVT'ú)fÇqX^]) Sո,*<@WxR6CiJ[WfMݶd8Mts!lҚ_x``˃lػ.}}-sA-_G|>uN|_قYi'':ݨC&4Hc6s}159$֟uw&hINK \qTZSkhh/z߳+=CSFuȤ"%9y&/vGaprJ(1w^ND벶SRV)\y~5t|'ʧ,Y$"ˀWq]zi ֟tI+_FFv" sc˻?175ǷnR1lX!} Wmܵ./y~CͼԵ 6(A nRukVFaV|p".Ui"z)Kqp3-}YF'5FXդ2y@qљW6".ˠVFz;Q8!lwQ>UYYR4YQlB(#{bV}Zc:8Zor3ɀvJqO@!1 #v|-8yB0H cNj% X:Ǒh%*`ѣ>gPJ`pe?q`,!"DYWw2~uf'1:alf~]plUtTX2c=M2imPED)ޮzs ǦItŌMpVxF]Жr €}0>x1s=® ZMRи ul=V VTJjFZ# C!t=2Fһ_ƹ-1I&+7;5 "Qk5Y:.0Z800̢#ؘKt>%t.N !G:tFT/ZTQRVK3;埙wqէ>96u項B%PfJV T["C8u,Zzm300+V$jZx.H&ʯ0'h?k{ntx~D`2V3[3}ABB) ] YT|P lv0/*lsgW) -2^4/Fq,wf6МFaط_ 5!gfcS-J>Z{wQ[ xF)2%r_j Vfʥcרr B6ͿCMڟ1 Y 3Tq;(I6F+ԹTkLČ9I]'2nF3(m7H.OswdRKƶ3G1g~ۣȩw L`{#Um!^✽ȝ+P.9O>d%B&>jc '|2}=<9`ƍ['sdELQV{95Z-JxGVfڵTUlš5kr=\V,_Ίbmp@t˗/O&41)HN3<ݭi?29OONBE^B{BRWQh1 `N-Dh_2?PorK_JlqD/]76=0_n`EGT8c90bi(<)@MBJtbrѕC7xJ*ge[ĬØtHadr GK/MqEH&XP2l!dК˗m#;n*`Ւ%H` YFm/aK jnev@'Uy^d4,r-x&S {qڭl؅vx_?Bk #"9U$5)VXv8R Lt?散6ꝎVa~3piPs &Ur >)E2i:M.P,XC.d>z98kede#JZކm۶q'6ù: =}1pRQ|ZhʌDʿ0|ToϺLT.xG9f1oل.{S ?U(˸Wl4\Ys{(J98} YJs( 'خ51M̧c@/@>)򙍼]勞W[EF/k^b|tm;Qp؅`TQ12y[1Ę;}3uZY&C$];k?·i?gg qφ < =@'PCRÕVRv~٠="%%$oځ!LgB-°FFM{zO66|~2Ǜ4LOO he&*e,^ݻmd+A#n`^ r^|c6J/{8OH7{r5\NEŢVm6L (9S1hG^07ExQQuꬭzbiuwo$51<[{Rٺk Gu4 O6=6. |{e֭?)qRJ >K73v|Qy l2n^7q3s?SNeQ."qi-J C 0e$35Gսam (Dz2WHk8cYZ.^+W(J}*#%"K|z61{o"^;o6vejhھtZ`cqڵ]~,ծW kxTC3 6wAV+ _^@)Bceeh)RWsJ ?T-Yx1kUG>f퀕Ë \T{@0- '.Gvqbd{:K6 ѡ !P!SH1ɚc"%~Bٴsn--3̲i4ۅ\e^4Fưx?SGK 01f;Ze.7_%9u74} :nMsa2x4˗/՜d(CCI͐)XTͻ6xgvI))eHl$^2&gcG!K|sDMrȴ# @w@iK]4ȶo(niE`Ml_3+c~\rF^[n6G{?B|CU HVNSWm<ץ\2I&q/^n>Ë6Ea,4<!$G4(kpK3:jQ;Nҟ5;{Nt aPD~ǝIm>*4;Zh CD};v_*ُ!t26C6<0[@)}}VB h4%`c7)zLz9QE@j[k !x4k`ךA($*y\ևoc!79z2N_AL] 3\Q /⨥ 93[,^n-,XBK Hc8fjU ѐ5Bwl+rXV(D3h5Y04dםR7 1[cҜQc6:'ŋ~MްJ_=5e4*1xŅ3y'P1?pl8v!匍o?{ ʽ6hZ$i \z$q6Z>M' UÜk̻Rm ?@i8Sݎ[(!$VmߧaİjA!> c%03$3C>@TtYk]#ݤ?#|uilӠ,_hk4'@?(eϣT>V#De#mwwd}٧ ys^<1J.1IdF)aT15+8cҡl8p*Ú5Ǡ1Tw*QXL/z# FƧj2W̶]{m/fD̀̀1Íy(Sacb|"o ȓR*M]nF2Ft&n0)bh~"irmi)p0BtI)D l!x/ׯ\A9LHj zEb'6r;(cJ*ϸQ<ިSZ4*( 3L !Liםz"cMXX3$P<}dv8ܸm3_× A[pbPaU+dٲr,] FB$f W9X(5Y˸A޾jj4ٻP7߽.=iV)?-USrL7 j DO1HBYJDIպIITw^${PwƩUo$:59A,[E CܳꍯQF?vPgc-"׍W]^c#)xԝ*}y'#u9~a5Զ3NY{-Z>dfhA,๮/TD:} * "WWoh=}\`Ԫ|"`dn>zu!G$h,ZHg=[n5B+ehL;2څM\q? !Pxj5VdiV:VłijlO}N/_HѠ95oKo"`gBdq㺸KZK6X4cwcCsH)mDlA\bVMO!Iz}?)ֲG;VxF[M7~?W[?j=>r|7ah;ddPitk5s{ECdT0#9vJ~p|i?d+Dž) T=l|95a5SxUDv&n!{ϣ!ڭf99&yJWt~^^טL Ol'}z'Q Z pdSy~V<ʞGP zQxs/K^zmBHS:ސdp3~Bg),gÚU쾇oʮ| Pql?KtK IDATǭ-*'=`"OUDBJx`/Xz)/:C5tu+.f}j9]kٺk5IB&4M? ӺV %E`1K7ccYgMH6ر9iVg7S`TMDTe2̢CKT?}@ڸHȨ[^W~Mf ֮ Q|F>1RJ=#-]njD/Z#71Vu #T<(q ['>'oWnjtٴNcY_9=SPi~&t#,=TC-"G?+|?vvP!zYo;2K)'^w?gW쨮ⱡeOPrbQ2ƧZcVᅧϭw{6hy/9~e?zt/jJvns.zؾq箻b0a !1yZpe4ImKWM^5g1ѽ!C_G /rY"hU, LkIIJzh#|_FѰ+s [0*h%Jh# Rc[?UKUqlT8 KQ/@xؗ9`#@ͦ3qД"}5&n D\}Ee:H\yptt^ _TOAm`'g#e9s-μXI ;V++t"ʩOv5ƢPƀh1D"d_#co;)n"oh8Qi2b3l) ⃖zEG>w0-cTړl/Sꀣ{7Udӷv#SAHЬCcb [N7qheJ^tjvO_EF2^1K $MMchLNH tD$ GtGw.ZRp+ֳVdj)lgZ6i+0ٙHWM"[*3(\L 0ّ";pM`3 ?~dDk #DP?;ΒLyOU{;LO!#` .Q̀"*I]1kXêkXπ+ "APdɝު~T:ԩt{twݪSy<'sxpІ 턊,VEs/Dz~AH WH߃^xw/"xڙX?6 Džd !{蟷[+nva + Eb 57uăw#= C~`DM#xӳ/GpVѻn<>4le}\DCI'׿=(֯_ f7e^$Gƪ(gOGDWfUsES羊0[^[.[Âcp"A֟i֧uB<πyXv V\A\uOpq9]>A[/le?v,PaBGedR)#C*EcJ);'zN %Y"5c@4fUGaxx8iI^P\5/4$zo}E&x}6g~UzJ <h'\kDه^ w)IECP2)T'>ADOL~'4‘\ku y%w=w&Y`zy˟ V^7}.$Z}}/~nK0vyuB-lqhC̃ϗ9`ݱj-㏍`k06Ɗ#Z;)9c[鹐T&03ŸA8 ~)D 4Zx_L ~(JIPJ6bO^ }43#Tc< "La0{l9Z!2A$ ^_j'pbhba/V?V#_ &.yteȹtǥ0y*m,CJ ޳)N9vBpDґmcT#c#a/'-xBW@?1, >8Ŧ۔DѪ̜8#*#3R=w\({ <I)RvHa~|b*R\G&fBl>_x6E%c[/IPQ!}$F|`ďID9P(CK/5{Oc/X2)} 'WbϥXd gw>öq0@ú E{Xh{x 8DņѝU=e5ee,kfX`MC 6䱤Ł^f$'֬ ϙ@QJ( sa, dUŅGvij E#ʫ˘\ϑ`cM-щ@pBVe*ۙBr +5ET# ºkK綯Oi1WΩT8 }])hbyjcfޒ )2[[y+gmL_sxQ.b#G_oڽ pU ^?ϫ ej p\/Ic$p4 祊^8}O<~E¿c݁$=*MrX4lÄ.Eu5_KX|W\qͫ PQI`x/|P `t5@B U+NQw`}&|"MSIV,Q$QQ"!`dP o~ ֹ8 ;`c$s}xӷV`B8hh6ۋ 4E SL }"“HYTRDyRiVlnnA.őI˜m4 ۳nsΡ0U6l ̴=eXy2 Ԡ׍+۸"<3GV4GQ4 uDɫ- ("VQk?Uo$HF'p%01 nr (ЬL>/{X|,ƿ7Bcp /\CCŻbhZЃc53-Mrh\;vI<8&=ZXQlXCT$[v'06gwQLؼBw'SP^ZgU^_p"3M`(58R C)]':)HUHuɞ+Lh{anBP_2>>|zZ4n!Fms,RSUѮ+p_{ʀ*}qD%4n+i*-)D"(buȉ-ҺJ( .yhO3-ڊK@rlпf%~>ܵ}`Iɪ0iɾHQD ,BA4:`v!eJ @O5=mx1QCAu L H ޞfXe\qƝh ,K J+11>%!6xn߁: E(VccqmObѢE?beh4p}!{; c{ŋ4;0\Ot:%e*sŏIX7TCV0qY[RysЙêccm081nR,j+ yx7~G&]l Z]=Y  LXa#HE?GI - X;G qWӲrF=mIXl84,^EE>5ksDDjW9Ui=}x%.YR *:zwH깉GO"$ÙQ'NYN2kb}9iV3hՌ|5E&؆?$(DF 4~.~b#`A*y$uq1\BˢmRhJP{>7`(%O?#3wE?gr,[?⮻K_|a5{@ hE}%I"G_XM])-F1JuJ2JJaݺuaʧf.ܔU>a 7iJH^0~ \Ij Lw".d=̕JRV>e^'$'9*m&9E(O#t(TU;#}S':h8yMƼ>>q-`ɉ hl Vۦ82(%G'ΈY'@^=eJ-'K~~9x;uѢcOCҊFrHL#x/;֬p+Wuc^^+t>g@2>u;~~/GWG:8X~9.e,Xp=v>.%Ѽ؃߆}(B=Gp(&SEgx/</!8S#|z|µW|;o>DSu4^]w zV?t/4p?y.ݼ,[850_H|ǣw݊oc"jebB8I}x?'aJs7%duSՈC8hx}p0W/~{~͉1oYh9S151J[)C+𝋾mâ;qEKGsx ݷ܈]rkWE[`>b ~Q ezx1z9r |<m/ '_p&F1:25+ѿp1s0!G\LQUʦ=)>AoC<\-ׁ6u,?;"F΀Zh Qǚ5kx&;w"hUDh6뺛t~6C[@JAp#Y.ҀUCdJiE)O1y) pܽr=^2= *( hml߃V<]w,Dhd";<c"al`V6+ln{`86cX Fj;FDZfd-aD2`XZF\8z;pk^}v]p(9y $bC9Z=v| Ě8' cɮ{ nbK'VLj[Lt:X3>m|>83G!lG֌&^D:.ݟ!&;;7ČE wyOc+nԀqa|żE rBA+<A02Ze/@! `_<p=i~AD?,XA ̛J٫!xŋVPXгPjƊoL40(~FgЁ oY埸ɵX;)]m dc>gMxĘ&;m?H :)H*5R p|N$$GURF7l.p'~0U_4/f`U[&@)e<'W{ǜv|(ujׇ~$y/2Tc*8]M+| g&ηr+꩹=Jg>6szc+??kX?N(5WEbw [߈jb=PիpߟnGgj"ρ:a{DQM~s!Žg'2ujX"m\M|kf]voA_x d{21G֯w܆XO|纡LB8 œ; &`B8Hk3k 9H61$SH0f)- kypոD;un(\7#ERWvDQѡ4d(#/*Eݓi5Q嚔<z+E{Pgr=3?ۡ)Z\~ ,_I?,#g``1 ]Sh 'yx:pȡkt,8x/e |1X4ЇN9Bl58KCge=ǛoDO7?M}9j=ۡP40ٻ}L|50>:_t(~oal1 x8焗C' W,?ep̗maw`woz F>& _gH7hdS)g HSL&A!4^}CP~ 0\f|Po.ZQVM >AnI:V"8-XFG$Mp,Z&o+&\ß! Jf/  .^y N;#}F g+y`}棧-|> S_&azr~+W W{ V ?#;.QvXgDȔ) b a79)%+se"$=5f+yV@hKq&ugdZh&~O9".8Pza,p-hNv]W [|GTy0w=#{ 9+*؈' MQhZ)LӑB> \jqqTX@d=pj5cywH;-rMP䭇@3G]諅c4/.x0րJ̉W#x(!*&-k#BQ:Vn(o:C ph5H8!3Et(kh;0ʔqsz2vG¨Aq3JѸ.!B*jWt@ _0[s='8J _oY>l).^n"j٘^/C4(U()B9Y9! 1Y0NJRcGSc^auެ`L#7v 0#Bd# E$K4=|uE1rflջÛLK7rFGG;cqsʾ+=m88yKq]piĵ_9Id,bjTzYV qHa@$֔nW,ت(Ge_)Ӱ uƓ+V`]vE)M@'lskU! )BH}QcL8Ir)+,g46R7HPUNlZ^s#w]ιIQ/})>x_:- 1yʖH#i@:V& UZHp<ǩ{j1`_{kww Ds') V!)0Xgd%2G;j8YflZU?/Ւ_ԔتhB^XMY֫'81+q$@` m~-&G[Nt:ƺVO`{i9 R癍I\y W\p/"˯? '0>I3N8p!\q%|u% O}mo˗>+0.g2W~X xIoD:+]]qpYWRXSN n\_>Ts%\C' [|+_Y*n2 ~:(#gQw:|G&''0>6ёQ Go_h4B#H[뿌$Ϻ'G<6±͇76xɒi?/~s 'e~?4[nT5hq{J7%}Xr%?[x[a1(8joe۷#TѯQޡ=5Ia}ēkkj9K}Cn~;j _T։[p>nn llhWWTE,`S}w -m8V2ND)YGC3*zy(MXj TY`G3s\.o~׿uq9 ?~n~;/v\tBBc;\rIrܱ 60}bVj{˦NYZY0|R\* ' 0$.¹=wla9yNsA#xT$OU:k=U_FbBv0 a _ .3>֛TSw߅O|=&''099 099,arr"k:(\uUs9S..S{,Xv-o§?8'm˗?o p㢋.J߾Dwg~cf4ͺȒzfSgj@jj!]Tթj{[ |RzjnV ^ܱ)8 ";6sUϞ!@lTTģO<|E[=*NvsDqۘDO&f%Kh' x{ރN )+|k_tR:xы^me˶u߮7xy%O=z)I`NoF΃o6jY'UJ@%E}jH}Z🳀}^N+ _L(2ws%bG>#'bMdOUcID΍rop[gV11&{ ̇nkŋnv ִ;)K4ɏl ` UuG莆J2ޤ54]J7կ}}[hz66"7_7ʀ*{&Tu8ˎ,Ql@^)jɀP8{[, 5kbExb 'O 4wd"y*vb*uTx m\x ^}{TZ@l2qx[N(?wl=\ v>MIkns]č*>ADJBeJǝ1911#zI4|ѹM4=<$y-UMQ* wz%OP (?rv"Q&;q5%|cAu掹c&Qb/jl^ A̒Cp'B!&U(|]K= %A8X30oZPބ4KEqDVMiWan[<栳4`7]|UDtv6WO:M3)$Lk̔@ՍQ\+ܙi(^*1MqĠ&hcR/Qڌt5[Ju]tܱy/h:"άoIfGaH6:㉅u}LLۄәLSQ-e̖ *1 k6%=`QC5l! e0QU҅WZE,ku `)+,Kp}~{$+Kĉ8F'#W 3%`3sоYCs;8=Y^$[mTae@gpD3kg#f1dOke& _m\Qx^Ӄ OHiԭ$6j +\! 掹cs+e]]T֗BNڥ ETx8+h`xU//5 ̤"8Wwb$N&!‚v ̕ס( F$ t&c$B2QQ&#|zD\ eP 2;:]׭;gi;HhDEz&A1آD#g`FΏfó7H mCcxlLrd KƳ'TGۏI]җڥcI+X3\m9aM-£bdHqx 9m2wl2GOIσ FPR@kG΢vEH~wU^NJXX/ZB`\v0q@Qa9l~eK(衷K d `@r~Rd23jZ6Z&D%ț 1c zh8$%q+ⱷ!⸘}k'4P[~8hn"8ɉ {q~p=g%x]OBM !W("^U H ҳ/S$ԕlq\lZ }! ETDQYYn\Q% BqrZwaM0oL'd<+@$wVv(愬%Rİ|oDOO :sʾúyh5|֘AC0~mVAQ];

[_] 2Ⱥ>QX !M`Dڙj ~c[4T:k7TCvvWnӴUj(+TCZ2O{ֈ=o~/{+Ԛ=u111>-;%Nﳷ,∟&Mt&px2"x)%$4UM:;ڶüa5Kg0`)?":= -.F%3TMu"AU^rR/|e=S9M{YSqQRTݫ0cpZ=[-zZ[oƮ6&I(m!R^2W!9 X"$VU_L+ d;!~ )!{a2E$e,EcVY~7>%\;1ո4ݹp~kAw!vlm)e+_Jnz,ׯͷRk(˗?_WW_}MMM~_R Z\dWcRYoIwT6)$G/CK@Br -"*:b0DUIxX8 D2YuJ#h1i˰KETEs/ƯVHIWR:+`t!5F=\|g>F(y晅'x".y䑉R=q=$z뭸馛k\wo?݉s}7&&&>}1H)>~aLMM _/_nэe˶6˖%sݰjtt?gk_9{+i7 b'8>Lw]'b ZF_/OZrr$b>)\6U\(G"\-ZPIZ ;^eJtsDqX|[Scݱ>{'׸۰|rp8SADx(y꫱alt xzzz3LF@qYg%? 5Fk&6V[Wa*괱OrI` ü^݆h>SSF12<޾~6<6b 9q1Z 1:щd(UfƾQYlLc9bsY7`Q'Uڜ}aWCUI]*]0!'ḱq=F{j cw=Īu\҇Kl=nkGGGЎ_ݞ9%48V\Leҁ zhmx \y~yN@ f/z!< q:qmdQZ3Uk)zs!nQrRHzSTo9צ{ue]{\{߇B2w\9Xn UP1¹rTZyq 7J6 pAʁ/X@˳vs9cOTIv+wb[oE4[8UL5 6Phtq`t[ӞʷH7!M7JFz%jJrUo&bD>Lu}|}~)g=W`Z|jhrF) mj(:z*=G [_TK%^nĠ/cz{@Ze.d~,*흉m*i.&*Ӈ5m&,݃ e˼jA'朥UmicQ>`Y5=e42^~)⺮M˰ Rg>ζ]j$LwVt7.bҊ55^l_r5j9*^tE7m v kڵ.8:Krg(命29dRϘC3/Wh)dʚnEU?֕9JJ|-Fu2;"me.:τ2݉<Ƙd~B@P+֍wPJg/<?YCBeS =]V_en28םgVZB=.uGtª'*YAsRC5uLNadވ/9bU .HHu>[G=\}X\a6x^QnbE&v,m_WJ ߥT9O@5/uP:ntDռRoゥD]V<[@16z%xeB.J^4[i~9Y}!2W [N䦡y۽وNtxURtt^7IO_QxHkö˰vd ?PKم&XX;ϼcO śwoU.ln~b(0:>lt+, cM,ɒkW83?V#(JMA7CjۿcKdB=XO%/ (Gchrߴ@Xφ'o^ctR۳9݃}0J#8jAԴUj{P]%|jĘMC~yHJ(#2eBu.("8V/^{\͌Yo`RP "aU78p3cbj Atm&rC&BAȍ\̸<̞GV/zt"Iit&U4vAr/^ek(L6Ϙǚ[]A4Wav[,j"[rYM8HpQT_%e#TeobUhԬ&,!sFSi!&Z3`Ng 54ąb?]#:T*- "82{-G^[U3xu̴ٝB[Jp]W-γy` s"GB'zzVY˂oKsy[]S.ΈJUed"yjF'Vy;.j*7ק-89w6;:B1,nmGЦ^p\sٓnM46**(B"uOʴRT \ʴ ^f+RK[Ղ:X /[ҍ0c̸];#㘉*+wMd("NC{Jq ֨A V)yG/(Bfx rz89p(Cc0qGByQEޚs# sүW ϊѨܴB'D51|Ơ`?s͐hEXIYV;>||*TX{G&}U"_E9g"껯<[nVOxlV~ 6#OnIYQZC2$UzEB \KYrT 1sBEU\9V1zD>G*}`\~ =uV|&P녲G.g-WYTȒ'9OA\Mkk\oYNrHh((4:pؙCP׀B$(j;N41c08NBc_3'Bk5-PDQ[lEBFz ogUxhވ{ hL7짏 K^+'Zt]R8Ҫ}Gunɽrgu8zաZkV^y(z!_ujt '+*zAʞRNoޅ`yHda ]({ʉ >ܓ>fB*9g_:\FO(|OWm qtkYfPS9u8O4+뒒P1NxhDX.x)?d8N;}8舗@\zoPm\ѱp;ד@qԱpv S_uDr )9S\xHn?\4 36\'Ny 9ZR]AxqI0`Dtz/xqg7w{6  K^E03yy9#gl4jٶxɱ'/:D2wpϮCN~l8Gcj^f@O?\-=`ġ|Ga<#FV hC8v$[d+J}p4Nz2 fkG>_/@\7~p7i~;RFQ$ ebU%;$Ѹ?x"lICoyp/96K#p}d#հ(ԕ:uR[^~c%v+T~ݞW =G B#e~s`fSptEtq~ @$2*+Ǔ?Nl3pȫ^:Hx^3ܛf7~?(WlxsxчᷧB5h5?=w=.<ȩ-HqYuZ(*g]f3'HI,iO,#^ԉy͕+ fhq/s8(U熊]y-ddXؔ}Rf4\ ׁN @L}Lu:Rf\0ӃщI2HƢ {q" ]d|D3Dѯ]:s~.m=֯[CChҌk|o  7\{[3:g䨎hffrBh9gs0clcd &s2`6F HBBBaW;=aw[43=nݪ:uNwdY +k[R hƷS³A^k.5vF3SL|q emSm "_ӧLΫ.e`Ȩ .?v n&Æ[lW|'oΦlLߐ+Y=c:/>(#VZFA 4kү?-!Tq6/|4TRW2W, ޞ?QOxhew^~I9xs:{6jk72onA;Δ/>g/:|VJ) Q[[&w3vٍ#vڡF*{wm0o^s>xΎZpcihjF){oo!Fp3j5hNܣR_u)JQ>?.{pL"{e2|Խy~3wh ܆=\cJk|7^O8"w-)e _ۉ{>/G*TYȗ'y0{l\vṼ?STj࿯ ƛoAC6,8icXn֚E?b埭A)<=v -mXicI*ӦҐ0l6cYxdG d]/UMk[[w{*bj0v]u ^2\q5E0k\0e>$Ye247 g϶c@C64l.lfoK:@Jv@l֬$:=8|ܼ˭XaUlƉN*p93gLV^m 6z;~%> 3MLO?oNxͰf̣%cꑆоӧL]w+y=z=ƞy6#V^\M(ڶ7_|nLS.K %cߐ7^z>DsCF${mb7X}5 KL&:X>i> Zw``5D*)ʪR||f3\k-mdJp) ukχԃXK+/>L7;b*C'e%e\Zr`;i.%7c3{zpӝJ1!B[Bڌq!GS"!`~lB9kٶ;0yO3kT.qJ>%ߧPLM,MwEϧXJee sfD 6 Ͱޘ 6kNLfյG/˃aY2)p5 7 L;=T,no೉㮻19ﴱc7jugNZZRQ(,]qJ$uе֖VU\.O]`2. VYetv0jJK 8'>_y'5'~f2dYZ[( dx5Д_ʬ|W]ds dsDjS:ίݛ]iUh +[pIvtՌ9 0cۆ ft )wч+۩5('/ Zf:7 oS}lFJkhi"}q 5q?Y{ZZ #=L6[jB Rm J?pɣ%7>nZɟE4f3/\J6ʪK8 ~> SewwX>$͝^?ߖŋ$FoUx-\w,[ZA!G*/%]]]&hmŵ2+6̅4ѹB>ewqr ~ug2ÀAaL| ⟯3oϳo3oOs.KqXs1jU6u~~W,ĭ3k^O?/Ԑx6ܘdUejkeJӦրM]_s>wSl=RVuQ< O)>~B^7㯧|8y*zM>d݄m~?)SOO3gޝL1h\ H OPR IS6Cƶ ͞W,b6ZDŽG~NhT뛕(m~[O/;gW^ѹàeXOf)fS:#ʪ0Q< Z2=}3wˬE}cΏGaZBܗ9/uzȞ֐nbٌOc* 8Tϋ_Y}bvvNM3;S CĒn|cyO#⻩pBW2''= 6ysfsg(ѧ^33SϨb.sۭ̚9C%#oL>具?,vewx>A/bU=gK06BxÎdGοӧa_a$m]O: ( !ﰣmn{Tf>C>_LxqhĜ3$̌=` 8"uOcG35rԉc%6Ssh Pwۓ6>]un;>iSa㭶_rԶR^7S!y䭼\{3L-w݋Q?[tm/?ĶYma[\Hԅr.>#ky'T\h2x}_ K k:dig<|^w`R)V_k6c<ZkFo';5YB1qD*l̚=N\jΗ< SOO`|l446q'o _?f;vi'CxM<>D6߁hY)oD_a A]̈́lE^Wn"H ilndF1H:;n|@ROW&[JK4pq ̺"^D=)߶6:eq!66>Ɍj搣{˶`ɽ$'y.Wf͘Ӎ}YUn4[nx٨JQZd2ypƫ< #ǴGMIj<%9踓mNͱsݟ.6JA@1lSxJk&>cBe5bWNїyk(Ymux[7mn 'v:kMWCJ'nIAwؙ>p3ΧUFO "_2(ɱ_믲>3?+/>omn;\'~!)\ aFvQۢm6- !m.lˢEgq23g#XwUg&Fl>u-ֱQT8{b|w7]]t-V_|j/|ªlLL*ZUDЋб|m @Kcwv8&_,U,a F.)zCc.Rı,4=ƱBX+_XĶ,57 b c lmƱm4岸m!a "Zks4e4& gQgCe":56ֹu8̢yts|/z|`ZmK0,!B8_@J⮶e˸|\|橬&\|x$8 jkGa[mQ|: Hɹ-)QS1+o9-M89]&_6m:x~F"| B'tQ y"gqqm}o3瓅FXl7L@)sӨ0ti,t2E-rJ)` uHTDLF$sklG06{YWѣa ڌ%`89R@)b@S# Y?ĽOǶ܈%%Ƕ@5=Ϡc nm±-K~he8QcZN; JkZ4 K%4:&XKJ-!hfhʸh µ 뽫89vcliڐŶ6 /AP#_h-k3s\46dS~mxĵ-4a[%f.fBfơ%1G80BZP %К͍9H8y7]9}?Oj<)JtMI Wc]~S G=/W&6B,8.X)N2{tzN֮L8{E=j *7%ښ#GFƑF)H/" 0*imFUu (=4A MVؖEc xQ)ɌeFR- ֔~ LiR4xRJ%˲(xfC "aigfHOE/H3;l6ȺNSB[2s$G]:?g\u{6!kCs6fw _TXR1C]kk$ G%0{Lwd);-q* ao%_^^P~R/&~P&*5SS귄iQ*Q":b۴DL:-c,dg] JidD0r/a2k״- IDAT!Wa *E{t, w?9KF2_J%?<'X&0*O#y? ގͶߑm{V8c>ݵ=ZWuRm U $B+[4Z WK.k>qsŞ#Z~xbm"Q34X :̚  ,,;QSusw (\׉wEZ.NwAYNl#gqb4BT~F0wtŴT7X(OrsӖN(z^YkıRB814ZޖicJ˴~v2J׍֔|@ZqmZj54.{֐\߶Ogk ȌFy?ŽN1`q;|t"(!*Rti6V_iլ LʩGAMuY26j5Կ35hHL9#u*l$R*+mSJ&>+^KbG[9F'F}RS'dUXWCN)Q @ЗWa DU`ZM9LfU}f ƪ-}ڼz=ч˜Uƶ4pihNm% fuj->86--2֣UYEI)r,vWI1;V*5 $`ctZ0Z.(!X$"ZzDY*N~tB&Z %&a+ɦ8 ^',\,,>Tݵ{N$^vQtCI3E&Vk),ҙ7r>hG%Md#Kd20ckY~ 7k>";=HEH8A",eU#SW+#{1gA.RbIr&GkjhNj ]u-8phM>VUuR T92*J!2:{H"@:$(D$Edĕ U^R/&,J(iE *~Y}Nm'm"^ܥ&//!\Rr-$,6dcvJ%f^H[%ZNH(BmBIH *-f C+݆,xXD+5ڜcF{@aWїk4U=QK):]wMN,b6*: @UWݒY0IʌAWRΰGkԫTE;S3zzur@S*~I&WG? 7JgXNjxqY^:[ KΒēfU?MA,81 d`g_Ϛnjk fk6̝=A455Zr\k #)}f΃۝Jv%<7USi:rfG2H*HKW!IITqBSfy]I(W DTJϯ, +3/)<Ѷ/S2(5dGmȄ$Mm5/[60Mehu_op ^b2,|l8_$o}1U/(d@sClIO.ZT"(~kdP<م4%Ɠë NKG4D\TNS vINU[{R[͢UVOWu{h9yhQu_⌏")RwL%;, a}/à7cQ+ocA7k!mClAH!*bHV21_)]Κc>mԗ䭾>TCXV^cZ/Uڏ{NՂhMz`Q#+1jd& qKS`Kf}wt"P}VopQWƖZ۾}Hy)XU496֦::_" sBIL!kYm9hO4d],6׏a[jT B7'~MCHm!49)97'Pp}F}d})Ō5^үU3y~vrn Ϩav444<3LG ;@3Lǐ5J%t".g˶Mq} {EݠZXK+O3ZD>|=PD?5\e륾oKg~w _Kf rD(HBhg~MMdYo@bR@ty1Ȑym M&\L5Gs.P31Ck7昙/ٕgPK3؎Fkڬ~bIùUk,J+ݻ Hsݯ>bIiI-t 2',bzZkdC~ rMt,.𵍛ɑlo,򏩝_kܐ(mz慈ຮiL"H횎gKpk^G f6_8JxC6SƻR5PBvvۻ/i?j)$IXBrd MDPoB E|׆8ZaA)$Ⱳ:}x%/_<<rBIJ :J5nŖvYakbm8 Й_CZC-\6mىq:o+RfN_r"=@;_%zK]/{;Rzް,;eGV==Gpt26[=ݓ5 E.'iaLjq,S/*ض!BCƲm)g_K(/\O%l.ieou-' YeE{=Oϐ#'|~a:?u(I1-$'4P-QA %=]}gG ruY];OX@!PBdp2N:?N)uAl62pE˶p.m 3ES{%6T:J.zE46{7_s9㸙pb QxKmNA}p )%5U CP4g1DKӉQ,s)Pgc; :UԬ*ȘRaOވzu3ek5Wq"7?2)Y[XR%zyd6/|_klTn"JQ@RP ,lAHl!P+ؚ4ĸܞy 8N\95ꮫK¢k=VڟvOҔqM.pf|P >WؖEe@&MiS,5GNb+Zdj*oӯǒCACƛ/#:m/$FVfM@C6]ԯqqk 9W'_f[ΟffrX[gzBkKUr!WMުK=o,K`~8A-Lt4{u%4dyǙggjp7e/'(c[ɓ>هeX2l䨘'lE;op' [M6c߀򼉊*QG*a17vJ|oO`_rrum'w,j!wX\27ٜCO=~qF檾٭/ EX`xN{)M1|EޗmA p _fU.HFhЊ>:{X0z}ǡ]6IJAvvp2n(*` 1+vx~ਬxUH&ĦFD+KebGp땗p™a {q.=t.y<r{p3ZuiGx /2`谪kI*obf}7Жx c=|6mE/ں >~GU.)TDǹdڂ.o.dO|%f|9ɬ-0{qJv@!-iz0[ ,fu䙹8Y]%tX^l3QQcKd]LnO>l̠V>WLkctj{4x %ZZ\͏|cN;0t@~u1ʋF?˶Y:`A:4'Kʿ;Ӝːs טqiRbu ߏQ+ N)!{x32@cŵԾ ۔|<胜rBսjVXƌGcԗ5O}πu>XR5`B,=ؑR  4Z~`S o l MFA-KPX"(VNKVuQկ zf=WdRs$JeFE]Հ7>֢eK6:6hH,[ vÐ!Q<)ʶږJ9V?4RZk.X@sKcӾ`>Zk;Z{>m1h ν<߹Yi8ıކ~q=$l%*#`<F0da/ZH.+,J~h_D. P.TJk>z-ι \gݪb=frcP곭{%%Ed語Q]ێDYB܄4<:TJ]L 25I"]:e$L^ DKO,W?L LIZYTYd,3  +W^&UmlRxA[ۖ3E.o4 758x>4mIJ/[n;bG?s8wXr\ IDAT 9;PJHI %`\\@*ΙCpޏs8l̝3~BI;cwʹ1mn\{]c3}&-$dְz`(]-敜1#Kʺ Kq2|D$d˳`F8^}=uxJ0^f6!H|ۦ'0u%zy6tspo C8 =%N|wt{ʉ448q!riX8oCF/%~Cp,Can[6hgy?P:^w?lpWSqfb`OpL4Ϋ)N97_V+̣{osIT=D#m $ 5\X9~:_w%_M#Ok6| 4d3;"̛|Buinnƶ,r7n|ˌZR4̙9zmJX}O=t?;g*Q(Xv-ѲUBʿ;n+cFvX qӺoݬ2+豷6_9:zqṱ߰*2zd kragKZ:^yy#uc29S㎛dY)`Od^~nw^{9'Mȱ7p o=wx=^KO?|g1)Km6t>rx땗U(hjm-fX7`m)vBx{$Uf" wn{Ucyڛ&B ϒB疢trrɐ 887H^,gaBY2{8,lNJ$ QX:>NQN"7QR`DM d_YHt ~"MIѴNG6UN6b~w$Ӫ{3X#=aY)ݮ7{3; @lYbw`{]R O׋3*zâ~f=ʢ޿,M8٢,Do~3|g?Dxlc|,xo`DDd35x =ڝ-mdiڢ~RַW7‰dLr{'lm@Yo?{>{Bw,jp+K6c??/ݽE)|x;Vg+"\wcrݛ(0j("7>sx_x7W1XoB8. ?~Uj^niF'yZc+*>9SH{ XJ0m3' o~<<6RJ\z)mv&dc@+w ZWo7G`I ,6[Yk'=-A+mh\Eۂse:UچB$Vav_6VMcQ⋍yDzuq NPܴS> O.QKw+W[|Y\\2ݸ:/;^c+#nk {tj,Z$yuFv/Fh|V>Eaq}hi΄|/ƕ{7m<lZnA]Nh`u9~Dܣ$\gyX6xxrk݆3m2ƲZ reg^AoU2x^quƵ!ؒOX A+E(k|x&LkxqFa{Bx"<].9u/ƁW~įO+ o!3V( Yyb 2k,A zh>QpPec05f@X/ޔ]lm4GNY2qwcc *As2It䚤kh65g5n)oՅ0bv ^zl 뚐YLI|y5An~r[CbR:yۺṉ޵vv"]ͬ@kWqgږ>KEm~ީװ 3V'0 ssopY9(h:6n8(S3`jHd㚢W7i{OjxRش7؞ .vׁEWk]~Oe>W(uu2a6 cU";J6@we-Mk[/*X7. n7Xo+Օ\&D6@wlj(6r+>!Ka e_b}2{LX:նAÇaْ&|2NOcJ"Z2E"q-ܹ4DaaVCQ" `֡d8j[c a$تS( MelJ^x%>*Cn?_+в~{%"FQLc0`Cڱ*lkÓ"I{|L n"?2QX!糷HbDbBa"p&ya8lk!\؛gLWwsWS p|T=Ma_.^lKvs@,ΒNtgw;dQ/{fX%Sr0h 2[b5Bxsc(vOm (M#d4AxnP0T#uԥB\qm<@IpGK~ PkHdDl^J@Y ,L8O+ 5 i}[S̽w4$@paɮ ,ܖT>BaCC猗+3!GQH׻LNۄ 0HV ʳP`3*fChQ *TFP1ǾXVX,[~OB%dYMC{%kSs$Qƒ+QB^z9\_ ?C#K <@u;21ł!ab^ȑ@B9w`wiixTdnKђleB2Ŗw`* ZR%R)i$U{­~%$hޫÂ(/3GޟAs !E'>~[⪓QE?삗'C5Hn 2Os̙J~ q%) TϡGʧڤ[5\]@TN5ې]X9I#e"}uCΓ/hx4S4%:%x[9;y*8Eqn &*"*Gs<+/=R(Gxg^0фZ<ɋN$fodCGMBPhxDO$<^;ɴy?5eO\!o !O\EKěZΘƅBZ|~&|P@ТY?ң$3 (zQ׶ kfT>>>^EY?bBS=ύox߭NBw( ]hr\{L+PU<,{OSuT(nlM%bn[,(A<2M; iK}o> {9 ,bBt|C8aRlP6WLϾ5c)='a jƔlHpJ0=GNdC1GՅ`J>At qg(y^ii)̣=}BEߌ~LE:4JO]59Nk'Oq[c9BD"* F,yc]x[ϝx/1Jl>ikwHD@+ÊѽEMQPPaAQ52Q?JA;_o>qdҶe֖~iB)&WQ抺4 ۨ"|I_w uMYnQ\wPeԄ&3JreMJV5+]W@7PO5(t.{@3(T|Z|IEo3vG2WaU># ]"'7=1R4TNHKS_kxDϫpD{=rKBX.Jg[-0@Rjkm5oxOmϲSi~@-ŨǍ4ʵat=o.^G)3;ܵsy^|H&1h% WQ}araɳwUY @9.4RJA cJ͔땎:1R* iB HH9t co@U4Q2VJXP_1& !hSDzaM.4o< umKƑ1L4%"G)jqM`Llr!3q8 USZ4]/D^A!ElrLĆV*IZ{tbk]d ӊ} tKh Oh,w{9㤶g<)519VGsx 6$=V]1 e5xsqs0 f2ƿύUF!'1R:ԼR_[RV@n ՐK?3 bs  xr.6~@%CVå$BnWdսk|"xƤ u]]Xj\l_}?_py_vT!Ndfh@kw`I';買嘡IQ'<y瑘sC=0/#{ZSO~> 8+2FR>hʺo}hEǨo2}&ƗN}Ap{rӳW5~g$3ZQVmʢ<اGLf}|̧m|HσⓅG̓ =v@d4J8sMك-_xu`o9)|:E"X} DŽݮsM~'M!=Є%9c2ת526}foR[50sǗ: _> =y< jA굿uIENDB`plasma-widget-smooth-tasks/applet/imgs/classic-style.png000644 000765 000765 00000255232 11724514472 024323 0ustar00salvosalvo000000 000000 PNG  IHDRݪ+sRGBbKGD pHYsu(xtIME - IDATx}w%Esٝ q A2 Ax3 E3Xvمlpow;~xU'<9^W|9!GJ#X"Bч 6wyܵȜˢ~+spc+ܹ1T,_@s"N6Orp 3yfd_jqe n,Ipw_} @ bAGHyHYxaf߈;{wc.3{szIkP)}4W`=^JW$+0$3 PJA0WJ߃"8{z\gj'[Z:9a/KQ5ZK^Q{>o#{!k &1  B)@NBHi74̚:fg6럈a_w$7Rm!J(3xeXT#&r@>QL"6 L.RpMi#{(˜UzJdvక稕QKKNKLѿ&0{ 5n̑%EVu'֢?EsJa-1^.;2˚m\d=ȴN!BJ6㙦T\豂sl\$5wcyB`|  g*F,4.D kH13C#fE2-yvYE^cI[$ 3Q.ő"@#;V;ݟhcLcwFNv2~P0E!e=j`$9ozLnLF`ؘ"L,} @*{&%w8-|MhSB @`"mʐ5U&%OA5d"`?3k׃(끢Xiz)UН–-Ncٰ;ᅮYw ӯy-;\S[*Q c8eH@fr/c3tS2QYM*[ ¨TtSpSĊ3,ѥ`cZlҐ 㸜RCe)xGycbuX,Zwr'ޝɅߤjf~ R !4HxP 4&# Oi*!Ŏ%F^`y#rFA;OrLsh*FzX+3X?+f+e)]bww1 z^"[l׻Q8պTEY*@N{cSBC>]0;E7eSYr^KBKkӭ,%1hBd'FQɌv!O6U"&&߉:B)aOVbĄS}>dO81D2 `C8)rUReX+/r^@t;nVʦu߉bHYѹ\;T3o[koy-3Z3V)QTBȰ-0*I ̷$]ScjKW[ ̗Uz1nE +S6Y,g^3(7o鷆s!̅eޠ-+VF2 U{U T)XB1BySmrH[: SF9?8>W-͖! I$ZaJT/:Ӊhk0Lfuʢ%-\_ @ !ZkcENU(z[6leR`xJM|.9c|]7IH+tI=Q"tk!S@^l`<ր6LI 07&P"X(\Y갨D|P[7 Xs hr^,AJTL܌:g>J,Ĵ є>T0uRJĶ fS+Z ׺ 3u2eCj 7Ny龦݇7:g5wrZ4˒G"6Wݽx|ܲ<ӎ93^Ncsos*&+,Ga=ޚLB;JjEAZFKN.n""4 0w"Bߔ]Y-B)`8Fu-?@ g, .&];R@}=WT*Z0@K CS(+_,;K u=)Qpfl5Rnf|ôn> k]ӏ oW$qEg%j N2m+4vtb:syioSFZȥXJVbTbiFP]7Am;B뵢r~>1NSYQUv'?j<|%޳&=ped +.3L̠S%lN&SmhLxS*S ònUO&B$;9#` `!vb)Yp0T5qMaq۔[&!H^ê!ckp9o?68kp)ЎcH=ZEuyyag;^Si@.C\(fʫz$e>@#6(Ah `LTcRp1*#"/)#Hvk%ԵG sR*VL+k/YS;Vb6eȻS.7ÑzRG ՜KVk9^ ʅ n8)(ʼn)LjqU&X{ұOkH[*{L"]RWҹ@g].Dy?Ѣْcmw汢P_PMv *o|gKien4 Xx^:^T0)(X2㝜_;ãS{XqABqlY"/f_`F 3EH{M Rdst*S(k4'jZ%=9s)Q6 OG::!KZL0֋/  R/Ӥ3S1tJ `ެMIm(7nQ8iZ:U4m=C$){`太B9z5"~Hd:ұo9-V)8 8uA $(nkI¯hYl\?۶#\4mbPnQcq :D -i]0 YJ?m[ZPiml[@<, #p}ω \{{^}{Rۭxx)'a`[6mɹN=ܞ-{\Lkr/?ٞ][(nO`u߈wN=+K P܍lON[ҷDK$7DTjwm+](fjI76ī*KQD%}$eN%f_GA LJJbI 32E[˔w&BjI0o~]OɨVB4(Ӭ8%]2ݔt*Ft xtc4JmD5L֨ݸxaAnpV /]Ǐ9 =˗cϯ_?y$fxh7o3C6e(s]^%żl4uOV%~m"ɻkϹE! ewmJYN]3e$P/ְjQ(,P>\t=] SSȪT<dVyX`YMNrSLN=?5qfC&Q(&V'R""4fų,׊Iega|DgnҦ̭bbs^~5LgL*d=oJ;eOBҋ[n1az'ԴaQTʕ-7AVR8=&q|}$zp/Y>F6Vd&+&;4렕`VRɓNĨ{O4|4|_Ы`6;@l8e2^8x .\Bz ꬷ$99[mǔBi3[p`KoϽ2{}:fE{ٳfbqs:< L;4ț:?w3-]K.4 эDfߤ^mBQ(W[>Eyo_չ#qD{-ܶ5)V.%[WVK}Y IDATX 3*}E2B~bLH`SQ] ˇ_=)'dDJ!R _:&Պr^2S;Ch ,wƧqӝV!4 Y3q)'p {s^3O>w?6bKR^©?,BOاM1!P* κ#T,Uɦ05{LO^_*ﾗ ÚaGFRO>KR*GD<!f4qԻͶg?.6hhQxW~ VcAgϝt|nK p?O<ŋVbcǎ+kkz 6mT9.g( lhB@AJ墟fWoOa}X͎; swj+b2ӟ0qm?{6f\l粗VGZҏ@,184JOA._pX|%ESyXhR(aΜ1'w }y^3_;?J/| 'w ~ p"#/3'{)t[skÝ> u,:kwqXAb >{qX`cWF?b<# ?0{)떣w_~ g%BfSOD,0[m>w6`T⍹fBZǦ[n= xND^wd-)g6!>ٜK+I~gۋZaw'N;nj{f#Jz>>p2AQvNc&"lkAƒg7uc!Xa1=dhU@J"`ƘJD` yx^gl7y 鮸>k;nţ<;A|#oahF_y tAbZs+^@&fJW)w{ja wxpx{|d_}1~z/\6\}o]wnMVT)'U箇Ou2=L8]*Ə}}㛨z5Ӌ:ojՊH" eN'@ kknx{1<8)%}O<  +:KlfP?/xy4+]w}*t+̺P[8brt7z5y |4W@ #\ow2W ]:S Ӄ.geAA_c.T +=*Jٳfb>>yǰO澂iȁ{v M lRe?x]q;o)QPCCo˿-DͦAKgC>y4f=T TP򎉀}~ǟr^*0Y+1Nw7~_w]q̱[b~n쨮:Fu1izؑxVce8p'O]o8|dqWz-zcAb[o^:E6ɦ%"v̉`BOS&cfh9}3_<#M zz)Tyi 03(j`\%;CrE1ϲxϲ&Vij^ǿ_ WoPR n2n^! 6"DcJfZ/yJz%t,+G&=Ň[ď06xc1cSg^GwhcO <(HIS14NZ{aRN HHi";~zT:gL{t .SmV7A`ccS1.ZIk*1MǗ]Ճ3w/ z=Ƕ4ZY!X<\L0czG3_BVEJJ)^CxUjj%DXv\: 7}ᄓN=wމj%Ċescbԩ8ēeRu7У+wQCk8FV a ZQzyqw.{!p?t+/L4 >a#b)>t;GyV B,Hc`SJ)1y_r* |-1~|A5m/Z!JN] h`JQhw!y'P@P1K`y<~`w}o-x P. 9^3:Q'Qj0]z+yC44sD3!VF1[Q8t}O>X!Џ  ǣw(~19cjՊCdjƃU*~V*W:tgVX|}ƏC߸8O{F%ry?s8sga16e >d96{␣[nW'CST  yQ #{7p%;{ &L%w>8t]:$.8h=wS=s BRˣ6a3>|#NH^0S&aqzG¶o/F(j&N 0z%F!JC:pSd?"$cWIXYr_,DiAm4"X_T0btONUMǬdcTBQ${xzs'NB#1k5C7UtI'괕8FV!4Mi*T;/R*0ŋq1G2"|R뼼 x]wrǵ; z83gsFBd&*BWO لRQ{G50Jڈ=4Ouioig "/[Sc{`8>~t%q/~՚Mj*O<0.||+V[X㹺5s) VP\]c:`֌V[cժ ch_CCC녴ir`^}<>xٽx[`]~/?oo[H&LӅ700 71uxtOYzM`@`I\C֋"#U9#QV1YZj8SKdDyC+w"r59x1~ ˗=&!{~Gp-7cp`|S:E)fv$DPIPWw Qc\('4h AYvSOa>~\Tvuw,}w<(.?E$Ry xqWs16bo)#Wſ?PRA.3u0F``JbttCT0*ZQ||Pa)2"TT2n3B 'e&Ijt_q]U8Bw?؀b8klpH+QK B0d*AMt-/@фT &hz<ŽEc>d{+R4 >G)(.}'+@R`P"!!fλ1o[V9O4xBRb{#Ob*e>ݔiݍWfƻ `+sɦie$QwI;n 98'Cl߽[8숣0z8L<o) NVBMZyap>sҧ䌂T* GD\]~%{VJ c+W-7߈y6l A pc݃e˖b3v ^#jza?fF^Gׇ?~  4zz#C͎:"s&gscA +]XDX]-ǜU RԱhEJPACұr+sl蛨yz}̛ )H[l%XPG1#VlHbɺ7q"ގ&pc0EXgK[|,U%'9}]q{퓢L: ]]xel`f6g6lL]f-7O1c]mz@*am=>{9ÏDר^M 6s7L¥xX% pO Z}w׿{)޳#a˃MX w{!`MV*X`~ab݋Z˰jJ3 T mKkDVߑq]Sf!1gmZ8bU+1r!4@Z xc24WC녔)tn4u\q}O\aE ^ tK7Sܳ ^핽:(8Uw8Svv2&L]w\a`y2<ԓ}WCX޿ Ẕ$@RA@D?" /v5vmwZdپq d"pG,>܌L ZwO?dnqJЌb4L:7\Kw9}^Sry?ČzVw܁ 6}?{L쳓,ErM]>L3j `!#0]]ݨժ¿哧N7c *)z>RbɟFʪX~2'01~Gx2Z9כkq30wJsrTCآ6MEׄI' L4y]ӹ2XLjD3tz7qGK|2罅7B@᜵oțo=6~&avǕ^իP Z?VX}}x~C )_g3AQ U+8[7܊_| ͋ᦛ۞{X@#!p5%K?܄>zhȉ9ȇv =g`M)4{p &Mu[cg%p5oU+WBC>U*F#bjsXo ],ٳp J_}%yxz&PE:@FU943m Sy)Xp>Vĸ BD:[Vm\1tY6<vn7BO}1iBIOG9r2 0}@w7dQXA 4PӇ(5&`aIRD,I^y /g?)!;}dt`snY uYG} >qcO>jw9=e4|ȣcYgcmu ]+/aL4 y4޻. .wm:Yw=|ccƿKJޔRx٧qӰbϝsny_i˽V߻G0){g4]*?8sɧA%+ \|goN8ǎ75?ïFZ [k[\zU} ~Kpshl^CmS \u%gv tIkݗX7{7n/Lۼ |yLż7„ PrQLDQ3K?};SOC꫰bcAT ^TFik@NZG,X:ʂ!6q<^^܏ZJXhNYƸ 9h Ү[aQs.ŏx8 71f{AgsmS `i8쨣qGϞ-ӦcGO}\gbI/;+p~hoD|#{w@,%o}3.:0]R*3J)_6m l41{L|3wߋZS>w6~rqCv$)B=#s IDATO>U r[-L)H ^N .8'{h{p/ 7paT5l6"Jc{}N1m.NK-FnzRg |U?DYgJ_oI3n<>x; @I|m²D1oΛ1cƢZ&|޾T̞ m<3J)9,jHF?G"sҫ,æ6+8GPCjusܬW]>ȭgmZ} 5!FgP ?W)6=:C&b)A tPT\kA6 L9܌@DV9BM0DilN-1뵪= Azp8)ʐA lC 0bPQ*H9c5 7L' .lfgT5T0G0yBNxlBV E=+f(݇eűD#@AJҵ9 BrGADRjAc~1Kl ㍎WRjPӕpO.! &7 hD1*a M,؈"Avɭ@ In3E$S1yGZ`I)rDXRJg+f}W\}xTfCB;HF/*oT6qDc͘,YXJu$a-^v5yNp={߯!.E㈣0#AOϨZ:mQZn:feo*)FHiNpHXQqbFKT)c Ntc Ն%'E1 P6E *N AfJ^ZOl7R*j3$X'S2gDE- !"`s൓iX)q9_rB3B WR[+؆L@0u S:]GJѽc=W6m3 'gOaNR3}^~fY]bV SꖌakQz+fH"4-:?ʼnj ͯy8\ ЛI!Qde Z}̚I镝K>*J.ьcpildy'Lf!i"4$,g$NW9XuN$ z`Tڔ1X%Ie%b 7r:u^+iWI2IV1K%r>fCߏz)D (lʛÔbgWkULC|{b qZ_znjAwOCj>e}-(r/#[+LX0JX+LE9#%sl OtA ?[6%y%~=YVrcS~> n؆! Mu,B^:C{JjSʶ7VP0ˡV  %cyX=AlM)=xm,xK?ԓJAVƛoKqSMR8R-pX0N(S*R-"2RK>LM!&f-Jr"{I5%WFIp'%՟(d%%XODqVƳjqD !_4؍W`O%pʮ/4̓E:eYK%0z +DPũ"KrMH!")eN)R'Gg2S5B{,OM =i#Rl#U .-b Qb"NS٤"X* )%ig%kۭI:~=TJ S}Ȯe(HRgЗLL*U㓰G씰4=:I7w g?D*ĦSb{ߥgqRP/'>%ېgra~@k8NqтKl/j!ppy]"Z<# Qٜ,ej '1#]T \ubFzB3Baj!|-V։ÉuHVclMxlQgPl3bԷ_(^05=ЕHjAk[R( p^˾G%ϸ"o'P?eưqq{ Ȧ9NE2Y1o$z 4$vH~9l(S\BD&-ܞi%{nG%6& Yc4s++ĩ`Ý;'̝:c4#U!c9.- ͬ9Iy9CYx=`?aX¹XL`iO*XcBu*#JT%\媗*D,]:73Ffn,$3'ǬPT!ZZ(D@3*D}O)agn~a]ƉVy ί\=N„Zh8u5 N  %FUcYbTq,ԉZfChlr_s! B AZ(Ѭ̮31z)%sf0;'UgJ)"?K1't)XV#/zT *iu #]]{ӎ)N{@H 'c+ox9Vpi(2Ye5S%XS!a95~U,VNųwOdyigefl2=7HJ9⒵uSH Z []l4 3FXbPЈCh*9%Vl'DP_&F /ih%rria78Pkkl=ˑ*̢ܣJ6G8KH&E4N+Qx1)YxL*;cCBb$X`UTq +hP Ra-< ;Ifx<;FŬ*qvcc7qlbg:hguqgYߛ'PKd5ibMF\x.>(Ӧ4÷Xca3ɾ[Ej'u`HfV+C41ks1SGIN x"Sܱ|wtɈY{liR&&sK! uH}!eý1ո1Pc"f.~JgS[FNp&ƗK]ԤQ,)gp LjBPc-{X\s~{/߽|9W&g}oG\8`||u111eNT*OfX,R)JY&n`L`I rV0ev u)6,-i6Ak"BӔuC=M]ۨzf8w;⹳-+oy.`n:3jR6X΂i 9G-S{|ۓOc$1mLK,F4V$48+Ib uWVl]gF+A?0 y^Ͻ [G3Doժtwws衇qM7rک&"2 7|"FF{}X0,[0'tr`=95,\.AǪU8qIlJ˰{s7׽x#8u׳m(Ϯ[)5Vx%]]w=3)öz*v}w|Gbq!6hDi6d-ƭ)S6k[<ifY1 816>kOy= O#'f)k׮avO.{rs)Yŋml1@wW7O<FF7o>BVZ{,aŊp2^.َ~X9n+\t!uR85uK~>1Ro0+QZa(Ą1A]-f&iQn!&L.K.å,n<# ˿ cL+(Xa{mS^o=unll}} 1є RC,U$2MM1 #l/mE:6)IR53%ا4@O"$@ хڜ' JD3AH)Ft5jw}yfn|g1m !}|87Cc-ϙW]I'ܡlڿ200ȩ?^g7bozߣ~x-J%vW2 10 ȥR5H5$THF ~^m⥩|:b\4MuJ=MlO"n  jc XgմkOJh\2(}ֱqfoHf#@DG" tPEĈy0:NF`k&?z106wZ:XDMHv!sm:]:ىyvhsTtd=Dn0n{N*7i瘉vXh2`d \w_E]Y4Eqh"D+łybaD̆WhL'E``j0³,3ktJ휺m,:٧~vuʳ*glOEYx8k@8V"-c25/{1\jD]X 0U>%YbjqI'1ڢ3e_ܥr5_fd+Vb`p/J/| Fz+-ϜK<%KmyuCBE8Qph`DI/1jS3<Kkpӫ 5]fp|[v-HvRz.3L:Dg8.vP L'ϻM]֒T!i')&W:}!)$ nM>uT^w&ōcdE35Bv~ͤDSz0gKORJ>s暫nOn)K.[n o|`\䩧c>5\gzsǯg~#,YzRJ,r|q,>||k xǹ뮻ÐL^_y'WYWc dYjvb9%lq;86y2HmZUZaDJ9-_tooJج1ӨC6$QL! /oFFYWl0 lTb)q}}}nٵ/|[n+; Ð..ܥ|OO_c=ε^1nF֮] =/}KyO༏ˏ<7MKկ>c9w]cֲ5’ 66OReZr2,F{ocX;zm^w$1 Ϗ~#?xw@Zx7?0@&.G6'描-%3Tx/1a"׋Yu 0mf>mDV1ohfɇF)uF A)(jȋhQĩN6|ѭgjjjhsẍ$sfeD2}n_͈NNLpЁ0Q*W z oE_<18~RHr27'y)SYTBt{ӂgNo>oݪռi#*AEM>~{Kڶ'מp2n rܱEQZ);+-{H~~䧼_sɯwOi06?BE6ÍMVޢb_AwQ-4QdlDk[m:d1R`9r x(p$ҕuX=@zK4NsL55ojIno Bn6N:$>KO=.<55E6v|Fy\|%\tt͜vک;W]u5~+ wWr3,|KO}UV>ne`.;嶤Nn6."ꫯaŜvک|s-p8d*j{zИǙZk?_ٯs镊PLѫOx5ix d8cfk'Y=ݦ$I (sƌzʒ}Bd6zdzt2R{ѓt2sG>R2IUeu$3n,ԥ։S/!45kٸq#gyy4.BFGG?v9$s/'aǾOs%+j7'?y>W^uoy?c_rc9ū:z{DQě& SO<3wni$AXR5hw W)SO=R<(XfMGQR7|0 QJ3SO'S[;}Tն us%ٹ%ai74mRۜӼ 'if]GO.CO.Coޣ77eNg/d{=zsvytg]c"3͆a1u8d]kg^N\zRCnulڴ峵k睗WȲ>~emtRs{]q{˯6 4fּr ag{7XHu9_':gLha`pzrR.CJIP;6s7`";;}?.]]6)=Lz.SY@V mbDCB<7[v Y0~G?} ǟ%gAad7pW\y%\paG}{h.KnƢE ZsEY-砃.8x jw}(_ϲe׿|K.4Apu[lT*eVpءq}q_Iݹ#D f((zT#HJD*;|=NWzo#mƭ#l,H+kDV(B>Q+թI\yI ՛L.nvH)0bwT)xݸ|MИYx7DvvD;k֕Lz d |IuU[D-HٞbU|ߧ45xZS`gZ&;BjRMNO+0.lXԆTT hmw{`B1Q0͆H,p)#=I'J!UJEDCI|U74B6 qCƕRQ }Z$ _rg|rN;ԝOi? /;LMMr~btm#vSPs=ٞ^rECLv~=_­?e?O;* ;|_sR>(.ԧv1mFoo/RJ6lvرsUW| 222LE{ғ8WmYp+ڒM$T~IP{fAvm,fPtifs *0+Ǽzj,)0'ς { ,y=3ЕeeN!r)q1w;IloE\xE>.,Ǔe%2:W6zI 4XRuϥ+YnϕBJW#$BZ)%ҀB҄*DB4Eej|d[ LHe&R c0\ûpcZ'PKL-_{Ƚ`z$xk )!S[`a¼BDO * &m_%&''8(WZ>ٌ8d/o =nG6*-S +lܸe˖!w{- N0@Pl7n} , ;T9 :6.Y]˷ BhR_9p52L~]Y=Q_6Ev,419id< |Qڢ乩=Chh.)Y7}e'wc R @ 6-@RuJ1) JP #uy&8e1d@dud,;w]ݱ87=)Z(MM6$ЦvlΈ7A)'$.č=$A( ZJB4h!ﺶFԼOR am18BPf< 䦩v; CƧf{;T67˚Fy{/MG-xٍ8fL?4H[?=w\~e-[s-K~7r;/bnXm'б諎:vM@G8IHk1TOJבؠ˝|;tkW֪uՂ6XEcm6& 1*"<&aYT[vloZell >Zjx !PBż"p 'x㋊/D I2eEȺ6X߷UV'1 #0qfR)Wf Z)STU0oeĞ\*C{zz9nr%&_r & cX7 @!2K)nb4"h*" CǶ>(\oaDJ߯qutR-[`||qnBiDi8SSR)^*2Akm YHHDXOȷAkɟgC)<-xT^!NJJ>2~hpckx>'H J:`It RČHAdVu7;6:ӧMћf&1xPKK,[GH!x ǟ.Y/m$JGKl?44|o6Cx  2B|>G^QNݗ:nY ? q %tvTT" ZCFEIPڌ҉Q.];W=7QG?@"( Da[n29rzr(;d0KM.G_@:Ij#>/ lah BcZ)a\GB Ffɹ+%=/vs8D`۾޾z rd\Ƒ]. ƓL6~pm.8IqBH6ӬG-*F"VxSkI9;S# ̐: XLLd)E4PG -+kji5[lf;)imil4MitmJ6\B'itb!_D΃H &7Sq\XhQÈϿYv7@p駒?yc[hzںZ4c~"fdp)CHI\q 2U'P1 BY!A)Rm\vz麃up <}( x쌎_>)%DS d-`: դ<غi3#AM(\iLsiwzc Bʤ[&mNXjHoQ*pgbWg@MYtR?pŴpң hSԘƽҗH1 dÆ>9C9n!nxQ5u9"q6IT]gabey:>,kߍ ͓By+]9PF癑Bdq^CW.0NLPvr|V`c ֬S=-dgyBsG;Pqa-u |2~gbb ehǖ"@Jf\(TD9{m*FE A- A8N[+mq\0)D2F '1n6[u]wxDyjhRr+^d1ut'T x^&F)E~ rg۴ht IDATn  uֳ}03#Z粙2N9N($,Fh4FPKA7I td+բ_/~{ 5 Vtg덉uCN&MH|a#g686;X++vdDtc(;hOI4Jӆږy4g04E]]ƿ`fik_R+t5V^l^ijk%ZYgL[7 u j mwNN͛7D`aRͪ7Z2ЕCځř|!OF͵qeJ`ϡA2eT#%Brǣe1"ZfH5e Q`חïV-%]0' %jEszc.@PXTHWgBVe#Ef<E8 &NBLt D)h?B96SHcd\׆N>lQL\cR$πq)0e2~@6A Fː(V X(⿯?&''=$<סT*#@)M!'R!fc`ƍYC9c/m: +6iav6WVZ)8^6aZHA4ld`g^':{:6 ּP!d;vL׉XK̼ʌ@HlQZ Bz`j|ц'u{ChG0^2حR }-CRbzz6>JWW}}P3mlU$0ڐ2TJ%Yq&}{ͽYJL.alݺbZS_Z2^&w\pJQ8ۉm^2|3կw晼㖇Q$]:$8 :PH1C(;0/i9z=UTزy C8Rmb 88E⒔Aȓdhh 9uфQ@C ..ֽb!';IONŖTe!1/Xtgdzz{,vN63^vƫm?K%%U")f>7;79R \2S('l̆! `Vd-%xjIGK?sdj g[O֊YE0Lk-5:^ױ70֮_$x kׯ! ŬHw>ocG rn2&sУ) $"}H!*"DPBiCVi NBth5 es≂+$Qqqء đv>80& ̙ YvCcU1 &'g %Q纭4ix),h~:cZiM ne:Nqwf,a!Btd  bb3mgktHѮ!xj]?qVg . vA.]R1`'BE7~ nxQ`]zSOeYQ`llL4|5*!TYd90G&QeVa,Jbr^ױzdJ)\{x𡇸o_K~EnByrlIfAiI] %/aO/_e,ޯN'I_Q )RL|"\z2./ˆq7"' C<9x].ZYA"܌WT+e. `t6 z֪T GGY`}^0)PR!.9kpdjrK=r+ {&e㆑əAե5,Y3Mzk%#AIǹրqP,-AKsm'UJY)ql,D+av|15>_q%<1U#fIcm7$dP`xnb]YEOB2#pđji[LX(#l1DhHfSʺ 6OV!BٻTg/@(ĪƠAkJه1Bj5RBoc6j'5?;hUvocJIըh6 #jm҄vc)BB QXu{&VRie"OEIkǏVesF(HGD*Bc}B#TJi3K)0PCcFQ+Ti=?J)B~Qc2@5 5 hbƓp.5֧IKxwҷOR XxGijG } 5 ^Fe6lmжD(P;2?W!j [pS͢ļ~ט C G䪼_9mеH's|v >t/6ؔ6c2 _m\>^(l34f9=w&[V8=!}/8O~[wfpW C_azu+h?!&0~aP )GXAcmS ZFTeD-䗨d\KnU )Z?vq]u\\ٴ0)UʱJ}^e\.M"5k]gddBXrqql6;ڈH֘T 3W_ȶD5Ks7:nMKػLB.ttM̻V{FU\c9yX/Knz~IAiIh%GpAwH.jh͂ okѣL^"@ EHA_yJ F|"( pOB:0Q}*;?D0ZA+RC=yDŽxP c^?wLY;dw?ڐ%4ۢeP3O &c,ѕ,'|O3<:.|vF9 AQ!,X4ǒɣ b[ض%1VkCє6QRؔBkC <"MU$Wk|xx%H5b>: ?? xB>×[/b3,I㌁r޾^4BHs5BǑ)ΞhPH-Z4ˆGI hkj*ᖎjtʠJn{\ƘhIY²vd=ziŬM B:PQc^|\r$ɻR$BfbZitez.}YcpF v*@F5!kbCFuBxD&?ڭTG.&:1hc кVt&gM6)ߩiYC+D ؈fp^8--BFP ~z=z˛FqFbxY8E4P,4cM t04.㒋/nIBXB8 :G y`J3%%"%Jx_"cVY Ϯߊ(R8F#6Uz?[L!c'aDo㶧Gppò-6hKXLHP@1'z%XؗmMk 7嶵!{3[?@!aAj-twCE^+ zUkumBAJAh"n~.bA{ne԰Y-/$,^cwyϾ_-Jk5\_W9Ɨr2^ ūyMw դщ׽2pӝ;:FYF%X( IM,,MGa)UkVнXkIV`) ݑ%P%nҲj13=5rUpir(2NG]Za˰{Y@}+S ;.0q#BN(~zz;GakWm:QG,"o/'VS Ѯ,5֤D4e={FeL<[}<ϩxO/N!qG9PtE&Jh/-hu4+eZUڢ +."I0<wݼ^a\ N%q 倹6$ͶA)$I3wlaevj q®6s4)oN#Aȴ2vpnF΄f;—KeF9kT"+H,0$Ir \11I,5QBN&>V Ûv5ԃv̵^e=N/Y"F7\яw^?2VP'&iV0vGXj51q?ΉsB-/@42X^Iƴd-Z盆ת S]Tmnn3߿V~ ?w^|%/6X\@y>*ee_PԘ#}ޓOo"X?HkX7DO*n1{CVW!ݦID}7Vz@A%X_$59fލSvmZq X2u̠^̮ͪ["'pxVmoUǎ+&N(@! ~Rȱ~+"Nblva(DƉ+!yY3X*CW߹^_p8q9\n9+R_O,.kk.?˚u Ľ| (%}cAXߊ M?%'<~O!x_@ϳD.VxG5>TvCJe"C&}zfKPm$i"dH"Sq -t;J|{34HNKBxe&sOֺCcQi;aB/P 7B:UP+p-v,SUİs$CMlcƺ^I.4vurY G1 Lm1֩(CF/ 1dm61)$^o0n;>YsL\p6rdGtiy)&ilvNXCəwf_fA@~/Mzt0NTh(| Wv9c:O2P+yN/ߵt٧j|ծw<I.o9{.'/9+0CV-pC'yLmFg/?Ir2y. 3m[&X''?ŕ.E je̫X&g҈Vgl9!ر4TurMfWD>71=9ggعm3bislfn,a(N6UJ3ШKs3rͣ\|(R()|~P =_RaxQ3==E> ۶mh05Mevjf]JkMN1N67t:;nK4/x2 mcDqcNB}Q2t)t?S e*M)%ы|tcbZ9Ę)aTa" YՖdG54,̾ՀEi-WP3*9g4׾5^/o—8 w&;RYFob$G'+HPN8f; 'QYҰwK>\ͬX|HEP3ַ???Owr'M팞ܨR|CAqJp|Bn|x\㡮%|hZ&Uڭ.6Rxi}H|#N@= Kڿ1bMؽ;{ ?Ep=9Lp|Q aB;Dk=Y%<@ ײ0HZAF8F8#W ?瞙q#ׁm.XI2z6%0YZ6q^4>=2Bu(sd":E88O2f#+zi?33gnn_q57|V.ܳCx yun?xGC)qa~U3;'xpvD'IVz}ڍ|抋95g?̞nJj HbMMJS[r[S¥gJ7]7g]wD~vC{5ΟQ|^ j!%pTvYYZ~ wR483ؾ}/8LtDSS"e$yvST㈅hq>~:j )>^XI[cM`RuLKRнZ$]f2rӞ:B &9r۷k+/:""<#KLLW K'0uVE-uY 50nONQ* p|b#xe>:* 7bU __֓' ҨTCAS T.0z`w;s@!By JthOfwHǺRqG{kZsvȄEb+Z|%k^8%Uh3JŀHe3Nd#Rǡ-`xt%;[cGoo~[לOM*ണ>w!B: zCB^}H9"柸XJ~fI=Q:?\K!C-5H?7/>x0?#+ixJG$ h ^rCTbHeJz{uU_w@EFI4]FԷjā%~"x*dY!432pd+2LV&X4^Dj;g`!% ʝ_iYCV]HD3=5g~͜6X߱ߓ,,,23;T&l"SB7P1FՌ-Sb ûF vɕϻvk`mT*W}eFAA(rB(tJfZtHERtl;<&ka\˿+H_~8.%N *+8^?ߏIl&~R;s!Nc#!cY?N^C!Yiw <(PY;B4}9IU qqKdg*o3{ێ@Y:ǘ(xmN;SO) N/PTVN0VIX {=*XN -(JgRBkez8Vav_|/tNF|S"\KyW"RjInk#-Ň&pІv%hc|U,\s!L)Y?Fv phGoV~?u;>IxhZSd·fӻFm(S̙0@=?\gO-@Ľҡ,݄^ <Ð+쟇\|Mgjj*iz<_q%j[p\ z]I7FV(IqMo%RJ~_ lp?W?ؑYs18!V՗LG|tN֥R9=\I|)\GtsBBK7pALOM0HRFD^H^J)¦U MC (jaN* n?P()j ^* ]Xn6dG4>Pя g=FDk,{k4ƭ*y~JTAd˩SQB֮Q/@aUOmO4Kk~Є2J)"ΚVF 3KGE2IwLLLj5VĦ~4?(`uf0{KeG 8znv^׮93v;B`?2Q/_ڤ=vHRO©&Œŵ2(&3G2 v|aع3sgu~Vm6ns)`<S@7?}%1'_Ĥ([{VLOMq[X R ơOƦ h&zd}%Hǁdd# +&259E*#)邍LJaX)](D BIŠP)x~@ףiSl2d439>N@As#XrXrSV5V'>cka R0=9I &{xC kd\2f-r!Miu֮Wf!|V w!u՚qn|<ݻvAGs7އ0Ά}0+ L ;vЮ-jiLNMw08Pc-E*i_JS \\),Ti`UO#=!z)IQ^SN}ڭq}VsZc'4Mmĉ')!* 0ƙsN€I7ܲKVu?}U1CjIkOt%X]x.YW:Ŗ 2^w,S0 -tzR2Cp{֥3yë$&MV mL |o_ėR ß_*S[o.\rМ| 1*7A&l̀%}ڑVy鳷g͹N4o)@Gɐ3}:3Ǚ<T;O9aX T!ŀ]kk~Dž_|XXgfvS$tUg_~TF@˫zϾ2>õX$^ [LXgE}z.:|f{]ڭRj C aNK/g?x{^-~k? d8r{6jr g.pdǂPU'$Bj4ZQ#j}(ẟyKHr'4WWj4ԫyLN4X$hm9A>#,`H>JIv<]pqzMM &] 9czGG@F|{CON67 *o;itVWiK;m|)IА12oe}hg }ιk1dC֌y+[D-Ckȸ/={谣hry'04U 0Y3dor2W}+}I3Jr3b#u$QDV#Z(dERu脶^e^_ $~[&2O,Dp-s#L'':sg>YŔK')XY]I!-333DQ*ZҨ՘DIOE/$Ry4˕+%=~ 8qPJJHۥVJDR055Aݥjyn^?O*'U*'$:hÖͅV!鈸ҦsEX*eg,x\*U[RHMNѦ:_UJLJR>qgXkdQ7Fzi'78y0 9 {ϻ̟<$V iUcUWsyA wr@!&.W4 oآ+|;y{j[fT7¶:8$&IT_Jt?B*AP 6M[A)W ze/ppwyї)l .OPc OhQ(d oL֢O1bTgA03?:m1{.bנJJ3^]lWn."'d0-U!7dID}:O9qYwsNEL:x_,v((y^!DM Z6^ADq_+|dX=$01G4W#J*^oE:R!EV'NP}rr4Px%z枫T'' m䉧bFDx[dmHd:)ח;[/ѩ5 GLGHZn N#5||Cw{}}kk ws4I=6%<ӥUнK#L SSJ]r%Ng2Ir!6!cī$YM̨{mj=>,T]fhF(ҍXS';µc^'fe[[TZ$TXkO Z=MC[P̓V8dyw;'cACIg5n$Ik11HC{3j-SID[ʴ#Y/o|<|5sEή 6MMip#{%e*kS$HP65Oτ0Ja_B'>—*hk^>W^sO*j;C IDATRPKvQ~Jͮ];v:N )cHAJRHpI6(rGI!B0̽ ,jM'+N81,r)3;fXK)͑:B9 FELK}5^UrhCNJ-Ia7~7$DkJԽ_=ID}ZY< 7o+ul!yY{{.w/?}O<ȱH\.]B ^\F4eJ\PJ˕ BV[,VEV ϛ攡KM<$OLB-+F2C-=XT|2 .:Yj $gbݹ'i":^JS8wٔK>;/]@Gn7P.;8'&*ʡE9}`f-h'J_oG ՔCaKë9e^buupI&I9Z>҂?1C#md.v8q}3jP+-xqbiXZfM,311 XV9ʦjZ4 jKKKLMM1!8,-2xقcy<*#z(;:v0L'r%;!=9|X\\5;+aw#f-ފ>yͱBdaWXϏϣRZKky|Qpp,)k!_Maȉi4 *P®raz)#vVh`=[^}~ΌY#i)Y p6{*2N6M*a%!mȉf]2pB8% Bѣ0DSX)j!wߓRЎ5 G\V 𜳩wO{:AeSdZK}NG%@!aQwRIę]Dc$e 8FkǓB /}"# $yivJ⤏@L^UKCsey.:51]b2-@71ܷc9PQs&CM"RI<)3I0 kٹr,+7|hV%i3qҭKhkbM Q/|<"Ov"+lԤF-bf3fvl =XGXGv;unE2.0vLΌ!дAT~01:"iL O2* {(qHo(NٛtۦG7_y5aYv4|kBĕ`+9k.|`mT5A*o|w=;WJkiǒOos }Rp<7+?Q<Ib>(60:Y;>ǫuM0nύH T.WzJ) 6Ѯ*56L ͩEeV_kJ%&V+:=ʕ ˭UZaLӣT 7˯tk:<\ fkR$QɤXe>!vrA5*Jr_Nt~?"qRuNۙTt?  F.CFkE} FhJ'硍끉7`7ȳrM_/IT` V]uJa2n5y ?,.kVҬ2Q*2Ai[6qh̓GN'x:fۦM,//Qelnś$Fz~~ s+hm."%)XʁGh$w~[Wu䪟sPՉ845?s#DS N0O @*!plzrf}̳=ǔ0 4rXMuXfC92 ~B:魺MPM"YbmA"nWnc+\_ LT_oZ)c )a筗NrGB»7Y[V @JI%)d)CJTC?tn̒*vTHePgԛA!AY{ O傭H,Vwr:Iu1qD9,{>Z'N8mcp.:Q9e+8Q!Zn~b."QzԾ͵D>|W>ɗ8Mﾙ\PvVӈ-psx$6^ ټyK2P.SXn4\%:U  " <2Y?t[r=? OdmƛU~W~OW48b!`JC뮻YXX;x$W5ORPWo\Ͻz٧+OMg{= .o󷟢R0=;뮘 Ac4:x-bQk?#,1UuO4514 9$/JJmR)yfSUz.OI#aˤ`nJ27=' SQˏ<<#'RUꨢ`T#:\!RJXjnRL‰cKL5:zx^\$=lzFM33{}qrH\",J{X.J2aXT*C<ߧj! A>JPH_TN\RR*WS_B3`&#>2\'^b~p},/-rnr2ys0ƲLxJn(%V/hScߍG1sЏςe~.Iqfd )Մ,ǤB^K(j̎Χ<AJ:;ۑ}vX2P{zdK7=깗7_}rKqkk0[jH8Z&>9sǩ"P*==5?ǹc~ȁ؇]] ,y XrʟY>|9Ej*ޝz&PMdK|-p8lsw3OH}RObLZ-Z7bȷ{[QʝOz}P(iJW ]9Cqm4C_Qb6 Lj$!sU0& D[ mS3nnwBNEx @zZR6(&J5DӋ"ĒT .Bj,*GϜ~-oKu5;wfiN̎]ݮpO!r8tQ!02XơazzjmZnByZx74ݤ/6;;"S,*[kc Pa({k ~MMcfj*Rv J9s+{[\x4{)5ve&zU=#`1dk7<}qnP8Ž0si6ͺM!XۈAX*]mA?1åox3k dq:M6{P :wr.*#tRŚٵisOſ!O.:ҍ9v􏿐==J/b&KWҷC| 'mAl]C8 _IZup((!ewӏ$nX1؍1$ur Se։}tHQ% E~IRoC[%^CZ$ӦYa9D'^Ћ%ƉaGn$F)<0DQi-F0!\všS9Q["ޡB<6qP863;a5LWJ= 禸Y<=mNl'Ii-JX[Q!Q>r]$h/fB TyqzpNEnmO6 ؄)?*׿C IZeɭH' srNL&N XRy$qM@AЖDύ,.-n6E/BJYg=cMRD>v *oR SYm_>JywN?RwޏPjLA>T6ኬOY<'F`u<4 =IyzKȦKQݓIB$X&(rFrv3ɌEYq-)ZCRq" IDJR$tNM$ͨf$h ԗ45@dt6?{8I}ymzzvap%\=crѫ1ĸ5/s1xoƨ`0*00ì=<9qS==tuUu-YR8 7[*FֻU_8ڜuąJ&+_`AzN^[oYITO6ZoQauFݝNtѪqlXFKeNLa񴓘n\}V-[)6ଓI|=4;. уu|Obot]\ W ZiFtazXfCjQIR[Q3 )=k@QXetfg99lC罏(dj-=&r~Iʾ)k={c語$pLeH7NI{@;xg*,$BZ%x Gi ͬ@w(Da; X(gjKv4d|(I鴚5oMR!e9Y*$hX(ݎӆB)AZpkI@XH y{Z:Z#4HLP I"U4n- 2"FVM23;Ch( BײՆVIU̶l3 Z!I #\Q+Tcg`|F*R.>+UʨPxp|&' jn1Ti,)W"vq'!qR*ӘoQhn bz8Xot ]̠Rጇ2h}% kǧؾ{U@;a6Hݡ9n',fZ9 SpPĺS781RN25uRoKm+񆣱X_L~[7%w* cTN$_E[L-q!#I+t?1P!܌s|1߼|}f0ı$0` G?ϯx䦯eh4F*NKuR h]M!@jЭm iv,ǯYM'5\v˯@P)]WIiĊ U0tf.|[*j7Jff\3p=vís9 h2IB7+J^vn5?{9Kn"uCqV6ňʢ ߋ]Qtd8R^A}UWq h,qm7);#5|"n^lSᨍL0l`3MZsv0l<tz|-fMY0nw} -ʣw$$syvb&eV; Mw߻)3u'6SLhGm> Gu`6 IDAT<"{j;$h9)^c@_ M<`Z$t{. 8 Vx+9Xo}۶=&Qso*-o>BGķ!J)@3?S333;L*Z 4.eL ~Z@ v\"(G%J;|Η9  \˃˷K~DߥP>R`-TԫaZktb%zJ5Tv %rHǴb0UIfv>jډ3U0wm SDNзxHo WC*CNL*Ii:0-I!Rc0yFf۱4 7XBɳO<#ud,ƟV(SӺ`TVJReTf8c%Wldù<sxCVTuf̷CP#6< ɾ#zĦ(>gfoß4j'9a5?NV*웊3{IS暤` =k[E[Kb|#$[&s-w; nAmAUҵ`Rd VDҊ>nNr>@Y5W)BĻ (144Ȫ9Aٙir֓`oH!K^Ld4Ǹa&fڇ7[ [ۓ8Y|ίc{3ή/RD:"  Q[49oOըf,j)"I+-[;N A 051 Xj֩ح%%g=[Ɛ{|*y8aB,֌ ݂PБ Bɀa41CC9NXPZd,|*9jױl 4:Ȍ`Rn+D*I4%1MIA!B)ڝ"@ ֚2 @zlqc_fHIVJu2tDry'7=3kB~8[=k~u3uĉ! ]O~G *?/95GZDW`+ґ..R}D+0 F*̟gy I VVչ@vXEgyәyg.fUG҈5]q(!i#*U G]@UЭH^l>vtEܮOu Vm.7yg^lʝMX%lҌgyޒkFk6nXWZ C# $Ca'|q Ng/6a 'SG "'ģ0oGQ@) \KW)*T0w^dq|yo"E@x4PDAKy)OTBIDhRJJ0L䒻kŷߊe'lt:%?$_!\)sULB(fN ba)]KZAp*:mD6`2T g,M礪{Xl[i7Mf؜s!*UbB's UZuEw:AK%TDJ)T(lVФ Q#M'"4E A1V12T& m!Da9_accYG{.{k]1JTu5t-Pj qFO0ΆnC<)Dt(`:0c]yхqHBzaˑSW@Qbӏ(?n߯QAp՝;O Je@EtY#qKKZu ) JP d nQNP)E+Bcr#V{E*S-6ma&4Tq2>ANcb週 op&^ DO,e,tOdhfnf-GgN4KoARĥQ{7֜*D @˿A$JIjCUQ0 Ta$6lfM'ݾvBE>!q-/ݱ.zX I'%*hBPcςuk )I m/A(*@#2DaHe BVI2 $4 Uel TB|MRJ4JIiɶChR u"$&њUNP8vﴭ-c1:! QjK'qiLRBB(-R-\,݌8wɪTv'AJ$ތΝ%?|ԆjTGjTZZٍhF%ʇ/E^鲳,`֊Z%ZYR[55K+=UP_y%JUevX% FIɯ~J>;/EHw=Hto\X\cikHuG8#\!*B(吐ݼ@F" BDK-7]Eh%w!2%k[%&oI&((x grwI: 콏S1j#c#\}Xvmq&v?Pէr*JdPKWdEO@ 8qxt @ӗ_t߿ O-n)`pշg]pJϛ^ܹmq:NQ(5*eaX{5! e anzMmp&ՔLu7q y>N9 ڴ1OEhN86]OorF J A) *("0 ЩfnnDQ)- q 47) ! J%<Y Rkf8$0msovPDU*t3,<0voj-Zt;1kM*BFaQB@(p5aAe'R)" 'Jݭ$:LG4#NZ*8iO%Hy`R.R $c+cDgB KU+y2S{ƷxY]&jU℉ʝ9)-ἧ坬R. {Ɍ')IMH)Zh0׎ܘ\p&5*o=T:4D[[z84J LWƉKW#LhL/0lmF6y˭93ڈq@E EYJ@44}|ҿ廗¿}{\yOxE/?rD\\.mBxdڴ}=AŀמvMH׆.e,.v0RԽ|K\,Gu~W} D j%r"~׃LV$RIVָ'Te;t:̴!P0:\3$ >u-2VIܘ'4Uv-\Iiu1kc>)|7>aRVr0(RHwՃC!sMddxZ)$ LJ*61"phZ#|˩6ޒxj!цT*5^4 ڬZroKwqhMSK o P9Z?[_ƿ$nEVh/9ջ wbi]sQ%s-?W eKg) gaFKs ?k9f]}8w.980df gllK/.z+1v˳zs#m'?,K*~lNzQx#,ԓ/^_D 4w380K/addzR k4JCe\pv\U(2IqD{Ay+Ob@21d1ZזD7էae=@Q %Q)p-X!Э%0hWv{a[m@"rP!T!}UiSV00 ,H2# Zk^m_{(v*Tuv d)=;2hTG:c(W##u(tFR< hIJ+մV=h -%ij(0jq͢:@a 5kUI(R֌@Ju6iGo`d[\qNa$1Πu_n: :RW{Ls $A*+}ӟ,k֬9j6۸9cVh=e}ԧY/jE(Zi GP=mʡ\JUCϱw/c?0Wrfs^"5 E!`MCE{1PqvV=8䃧-TLEAa^qqs= &[8س{7FB& !Q]d*5_' M>OauuDo濸2b ?߯x_mCjCQ )$BXTeܛMP0À0phP"%7k@sjZ:INQtV˴uu !, -!s) ]Б>JuA7›EtR.LkK'I%ڠСRUyOKRMjw  E^x}n}LbW櫥\sؿ(ťއƂht$Śjt%rD5XZ!YH 2\V+0 VByL1ڵ7C%׻L,Jީ9&j$iMA: x`~~?ڠfvbUxE 3\pJ.y^{DD?g`=85Q*xs2LaAnx^:u؝_Y(RXK,7VP1e8%"y@tLf,;ť[>ԄPN<8u8 w\'>7|]w ###\kUѨ̔~2hxxВo"T"2,.JJ+e]Qj Ћ%MU|.;G""Z.DP $$Z[H;u2ɮ\D=eQ682?7 ShYSЫ[H̴7t571\"#CVCkMZGZkLЮw {nuͶEAZBdqӈ'B;W,}Xh^KD\/ pK~/D;9 N܉J-.k7V#`fzѱq:Adu] dذ_C>@0X5Zk'T&Y֚fX-Of1&$B)gT[CvswM,avIZA ɾs><ڧ(}V!d+0Zy4hw])qMmi'I6$Mڢ$՚DB&ƌ5J!\a8Pn@'վXs>~~T<~|bJJ!Y%e@jl`$1Nqs=۩CW8\h, {Kw]w7t#R k qPJ_nQ{s%岣10dz)(={7a)Dp.Y{Y^ddw-pJM@J4SH)Mz~b8s,_#yv@-isN"= AR*c)k47w-4 v|0y.B2 EAPdQ ]AC|*ĩ:8" +dRAL)&? Bћ6 U:a 80ucRJK[=:JROB 99>X*Ni-V!!k!ˆG0>:}=w(8 $(P?R!kSj#$uJ V;wHXysva Zjⷞs&ϛHwC7mtb B9hq#-Nz!,6ti&X8f+ycK5oLux$3z1($"*ˆ!*0 *?5V!`a~Y8yK_FDQs֭$q'G O00sM9@xIwp͙JPU.úҋd75M>ɇ>.R B/DXYQ:yR :oZhF@F-W/Yzxl@XKTxDvդh;0P*E˕BχUf!s撿&61bMuIOKO!q?.>;JK]^׼hޅQV {NYo d"t 1(RL5*! J7KNIC{v9T1bLw#*@ 0J"s !qH$@Vc5@Y2f e&1-^?N mMl N ;o%EuXNDIF{ьBDeku2h=~_vi.[Ί߽Gbuip<$y3s0T= 1i:ˋ6*Rmz1|ArmZQjC-ٳli98=6 ]2 ]i-6pв`mYEGg2]lN.۴b\DfGTCwf' WV~v$HT*j.0::JwT*DQDUD/l|/ &3O/l{[ڱmYPIhV-T_Z(*9k3iOpGˠǎyr(d.MӆTUEh KJEd|[M CFL&IK5F{R.W-(X[qlnjE2n*Ah/ b J[R?4IC019阖~j)y5Dj$%Tc=ZrOSp0rѲ;چSsh- b"uS*Tx{+&+ Ƹ Q:۲9 k3K!I$V\bUفʹ:L-XUNTŏK=ԪMLiU0..yis"yszN>|VŎ[oЙz E!9:#`lq6@ߵkWU\QWYLvgYdԋg]@mH>^mOGwRYR*z YW!NRqFO߾̞_J3-+;,̑$270Ƿ7#ݏ+qYJ)Jx~jX4='5z쉧2 k{h+"5ߊ ̌1""E21]"<ɃYMQЭI[*޵:-Rs Q,X" *}SJQ/z.쳯X~.N)HM;@"Pu!N[+ c^|ryp~+r-emA+ѠJXH+D@WXa{ԱdHj ffSC҉VJH)P") $Fc@IA$8Lu?XCj,\3:dl+_NM!6.&ڒb1DW:0e47oQMq6ץB(OV^¢+g1ٲqA|l \|@g82~ex9 cIDa/ K.wt1kK/:( [EWpőc_kˆBfJDC$ۮ[֮d3&]!ww+ I+_ oɒ]hWIb!WË> )Hǽ*-R0byTCZ:d.ڭo6yt4qڮ147QٹnWHahM ƖQ3םWwpU'fjy[H3ux5 %sbH۶$M܏I)Z[&֎ޒhGyѸ邧D['u@Zgߠ.*O0W{G( 㔂׮PAm;ͫ.b#oYiVbu$B h ) sˮI&''y38{:贒jt{(V;H35c~xL;s%__6tGA/8w#g῱}<3kX/=/\\_|h_]_~m,z;y>IV㮛o̧[/|!;__?1˿.ˮm  {gVq?_7K $N5JxH%s/z/~IZ1Dۆ~ [N;c /73y^ӸCX*4Q&hz}ѯ(EH2]>X.sB B*6hOaSD`d\ٱ{2gu7N\j1 QRrvh=ƻdjWڢv[ƺ ȵ7Ui0laJ5;ｗZơi?':֍7Pŷ$㨤C=wzR) bbq Kq:u]6^jjk62~3‹.d]f r鴍d.NK )jKZ>l%ZZ֚$uD0msӍw'= 0 &6{!ߵ6ZoqC%IMSCjRLS$)waC'I餮$ IhQ,HYo,u],Ԫ54Z׺-[}7iJiH%b^erHC~3c ogUwOZ Ȼ9xn~9) 2pf8>+3^t}xOITXe 2t!!oq{wmkuT肗kVa]+7MЂ$!ֆNiW/n=4=϶ᬍ4;3!(!־MڴVr9IRc&۫ l9G;t;Vj]LT3nWBDҡφɵpkm0JN *s‘I-eH m{Em#ԸQͳRВm' V # .qNQ=/r*9PS̞9VpiYwnn$lxS@Z MZ?[q[pwSvVaRC0Tt#鱿ndqXYd1{ok"#7; W?(ruV$?lVBp3?)$1XN")I%D ~W!VdD%4EK:,4}65tԉ ǧD;p^w,@a޽or1։<*)]0Q;m>\hD”`+HAgڹdop:G8XlX\qW79ʕQVbU1dVӣRԱ -L D0@AYa^~-,̓)7pg}6B&G,vZ'MB_7^s0΍GDߤZSY;cb>7#v]rǃtN219Hf&e͐dHUtdH;1ĩe21Nhn^kS᣻2ӻs4U~?棏5}W\z'sͷi&ƶxm9!6D)53sݐZxqPr".z=u@k qh?ܒ%y" Q$'8Ftg*R q/9LTCZ$SixAͿnb -1AL05CۦLO`1ǒNjU(J IgJn'Ye Ra1Vd n Ja\Օ( IO ] Ⱥ>whQ1YՎN"+RMQasfso4ųS*|H1#A)2u\r^q XUl  MBgz9?R=Fzsr#xD+y$^l$x]U~=g/7nD筐,t˺U8cCeN=&Gf{;ؼBbu):7rR"q3'Wj,_+G(o|Ĺ- h4c6wVN" bvggƟ(/R|r&O_NkϲWl+ɶn`9#ok-sDJvvkuivϵ8nH26s眩 Ҍ ft/0} Xs33@CYNxhP-H&*pcҥnI*x09h'cz)JrJ. ^Qo=+S]r @^:Vg@"ssGPu+xP}zgQ(͖,>u[Za~~Q)2uP@B,p|Ԃ-P^Egky 8<˾\ 8f{۔>[[ Q`t3/QQą(PXMT=/~|N<'RC4{g5 ^}ۜpW൙&xQ G8cqJQ+/ηb*y{hƮ_P)S"JIIʗ.ң BI}KyK/$pӟB~#/拋;KDE^='b z ~};(mZR:;\]fB0NAJ:$ ,2 y,.N/tjuJh6XcIS'q}3p41,Da]s=yY_rώm;غu+6lbjf/}Klذ( o}Wg>օV1yX.&m-ZtٵA".wLvk]X!(z/EkD=L-nZ P&wC\P%:@j.׬]*d!ҁt jQ{6 u0伸uԧ}M do$BA;{6R^;y\wD42YFzPr D>s%"՗5uu*`Ϟ=Lܳu+c ƹ=dfBGvZH!eP~E]ogݿ<:MeRMdzzYEUmD ٱ1m_( X1RR~/H)q0tP3weŇrB ~~t$֢ifˍw':Mۼ QJh!ICC$%WO~o\v B;EHADl\0j'2 Pks4m۶i [a/}K)uҮu\agdE\駬o}ieUyTC# < H rgT$O4Cb4jhr/N7A08!QW#`d@1(46MC\UΰkkOgsNuij9Ou^뛿v |ЯɜR /Ӈ '̞@A&rRÄP\+Wı8|~Lfz!,{''ztVҸw/=р3S9x9#eP18Cq/$eqGn hlevk IDAT(,SJiS>_m%=AK͉ĜaR?T(?t']wށy(&(v uv@$pխC2ӎ+͇nyPBGJ'H>ݕx𧏡\dՀBzɺ!tdbc)tW 444R0 ]gz,077{ri+3 VTUtqc5M_6* 裏㚡D #Hs R"`͎ e EB0eDAW>N]/4=Av6T'4뤐p"$sՖ>SQjh1d %+hqMՅM.XQJO:G}hLNNQ$DeU ضY(a^6IгogҥxfX U!9Bfʋ 4rAVdFevȘ9lqf8 Py9^gI3˛5[YbA@h0dxk_Y\P UkV0c`0exixTRoa!xh;NµW• =87]xΔeP(%bhHQj E(㺢Y#4ˊ+h?PQ$d4g.8!P(,McXOBK?[I{6w 2ȏ])jv\HAp - !_#>zCH7tҤRXW1YnIDE> S&fj3mo܎smkAY%=0SUH3g؇-'z š#SŒ N5W`>z1g͈ "XrG;uI?Ɖjެ yHpt\יQ(,i*,NDBe8ۜSe\[طDSf``XC n޺W=XֲExo_.R!/c +H=!!?%H|R/͔)`0T9yӀfIV;ᤤmeBdX%#S2ԀEKJע %$!Xc 8XL,]% ƕ< n$DҹVO{?,IZp*jO*vCë I7nN !b""M=[h Ҡ #tOPmÙ߆$̓}-f}{s Go33S{=ùIR":NqQaT7>ή~qwp!O(\]7ᚫ#\}5py~##^ < o:>< k W^8<5ozSk\q eOb7ش 5\ۇݫ~V?~H:{5W ^ ہ{8Mkg ]Pε\sOqӟ1s E۞\=ηس ¿|~P#a'`G&N wYOƊpV rTK cō:v-]l+YXm۰\z0~S=ʺ܃@ 8&Κ~LtD=u , o!ޜÿt.. x|.!XAհȈ)D2B2bƂI޵KFQўh7f9˨B+(T, o iѤԀ:27h3὆U"2Yďc1"}<u;P;fRYux֨vv95hNblb? % C%6J<ݬ5J{:vڹ=XlYOi|KF{4azW9(  tEZ F zD- ఏ Xy@Ut^QHbלs]АJ8 >5=KAÐ=U : XsDH:8='04=l8)b$2h"F!Tg ) 9P "HA¢ٔLx0۴1uCxTz{ǶQ! EDP*0#@&BX03X4j='!FM:^?4nVsE ,-2҅xP k%#ܫU/Jb sܱtPzcF|Yf{4󑾍8I:5' .8(B]&lڴ _#<mj%n![hfZ `|rR'peb:…lR7(?䩌ax p#sm؎YƖ>_<ݍ;ߊ{ΦZc 1C1-Xwuck^1 L60`AsӘ9`LuqhT5?aQs ;Þm[ADXRg`!wQQڞpX5YBŸ݄B3߾odv3߰!TpزEXp/Yqte Ik4#1Ȋ_3 7_VXAYK>'mVeKVߵZ-ضkhPj"! -9e*Pyf}zTB%] 1xzDG1իW_w4M\}wGRy4{z ,;\tXOjoXj4P$_/> 4*?\?6jQ7 Xu!|k*|PPe$itO N X$ڻׯx>^zR]i;'מdp}/߼ +Uښg+_k6@Mֱ} TʷMf9Mo߆]7zg6c)k1$%v[i"Z֖ eijvᅯ9vt9X@йP׬C hGA0D^=HEQPdz"=?c6dpܰ lw\ԗFlKx>L9BoHEj',U18 Ag(Vo W]0BGj"[eۥ5ݺe3:6( KsOZ<)O6>0}ذc7%Aܠ{اcV^G$W tk Yێ#߿&XhmG9t]$RPXZ :6{:# &Om+T0YAVсzhv>H<ǔ[,R=7W1z6 ӎYp #"q p!|@T%e@%q ވMuڛ-&^S1=#.>d~v 2{Q&XeVljz4O,&&'SZ-_7?^46b9O:\`T_0/_u:?"@5 0$\ =̀{ݳ:fd%dSBRB D"M"3LB1X` (zae-p)3V*8>19[c _i9P @- 6sAP0xa2 +Qy LZĴT1? t!WA)XaFCwVR*zt]W&|Ɖ?H&+vs壭dYVh4F셖!Y('~G&2g?y{[ |~}L2d 9vlA#6)*k^( FA*@e +9G`g@tˉT(#W .XM,ÛwlօSR;7&k~DyA=w|@1auMc8QngrPܧ$|i&@,Igǘ4BO _C-R eh0""FPT E g(Uw̌P/=׏SżJv<=@ xSXe$!Ne`mb4B1gb-VE=׬x!:6WBrr+LMCVb^  hآI]UM5 ^C4 E Ɇ&?w4nmx1 ${̄cP juYrmānf@| HTÇJ1$i\H?;3t᪻J+9cxV~bA1s,S@:UJdx.*дRfoʫCWW\\x;b\8S;0ھ/|qӷ0>sťXVc?g>} >s1iwN~i4'thguPk@k񁠙 jv\^KqO/:p0cԯ#b7]v:V|4%Žm0urաx9 ӚÓ?'ldb(.W*P;Oc8dBMxyKɈN'pn&:ty/`"lc8cQ@M[{vcl"8L0cQpf& ${۱gn4ǨL*Í>?Τ?T ,!kc{iFFU A*ن2ju]u8d 8bb ?z\4qxJa@3 B+Ϫ ^`j ڴ''Pk_nƶ9 FLV8`&Wb]p?,E:D4]3vaʃѵm¹DI"ϳJ]kKFUX…ՀOP)σ:[.:s.d*e\Z{^ 8TG𔊪}8ņFm4qg⤓UQ6 :AQb~'EnoDۗ^ܐy'?5]v~ਣ̕^NRk^S\eK*=P'i"R(ׅ\x ϱt;:hui9 SgS~wTTyл{ռfhW O_?~'vؑcf-bЅg R%˖gubji~xx:kvGd4JBܻy:wf'ɸ{)y KX%|t~SH(_NNAeꂔŽ.7"T6 Pź(^_ĮF3o4D8Ty&xw^O]uWkN.N"`Ͱnah*ٲ~۷sx ۴Zфyd y2Y/;)sF7ӛ>|s>~"'iFbF=x7]$'/ł?9#>HΗM|Julx JiE ({(0HeÚPlXA `O]O3HWH_HJ5`xjI_?u Vj {1:a>fLj!/H8d+ee.ΨJّk䉍ܑXd3)zΙ)NJ02QIU2ڒ Yɸ|\p<c?=y}z!e$#qEޤދJW\P<+4~|}]g0jGشi3nA^ou]?^ >ҲPl6Qd8{#)\<_ߘN~TK$bVB4<  @㚌W *՝צrO,9c^72qPF;ȧ998Ւh͡Rw"/ >g8?"N*QiaO`EZ{{|Epy ^{G23>ӟ4.IuEBo}[/Ceu{p]wǸănu]7|͹9淌4گa+PB@ !%ރcuT,G+:rEI)Lآ8%fO`4g b2>D7 CyHUc9^kobޫYmBPmՒUmX* Uhtp>̾ka]c'2BaϛsBD):p^rF[9H)җ{ Z|k^ Yx׽uя~'p饗¶8 "38g8}Z\xnqnear$:{;q ģ?"|_u`~ uqѻޅ6< 8sq'>o _v$~X{(d/=Lpw !P0jc8pJMYAEYakHd)=SyǍhӡM:6MrdRaB7"8]l4(Fdmk <gq1nû02EzDhZXz=Phpf<$믯P"CO<pl t@ T^Y*Htq] 3Ûmgٶmm6gcH-?>昑& ;oX6pNkcncAK-h9_)s6nvnN#L1P/ Ȯ9SVK)ʂ^,-+6Z>smߙ_Uak::1 X ,?/+r@+x}:Tk@UY+C·6-.ivb^˰;빥V8g_Eby̳^v(G9 "L Q˹淨Yc ]DZ-U>C-V@k%q%}G1%UAF =eεSAT /٫WRBZJZ]+Gxc7f=!@\%QHŵҋ,0M yێ9ؾ߹c֮=}sn{vD2<σ, k$Ty[RxrOG ŕJ"vfH2SNUhuI)"E4rZL%",`GqJ5 0zM4at ?1չ+, 9&qb"m?W8y=/q\AŪ$hf9Bq$h>TbNw=,~d'Ed)aQU*sAʤ7SP˄=F΁]Ȧ [ ~rBhZaNYRE)d [^}exegSEMCʥsΙy>b9J+3)D{⬫9Q]W#9SQnM,?օ.= yb42o=\ l1Ye8bgyW | !'\BĊ Ԭ"p hg߯ +޹O2o6!3oJG4vAI(,ouny2n`^Q7A_J@M=ju][څnɪ:L*eg˿,LQ{/!3,\AG82a'gAbȱ:jAI-Z.XÀ @"1!)Xn:@ǦyDQ3s3yAΐ@F"B.BW"*xpsg@J R#9׺W"β1ãr"Wh[ Y[J`o0Ӏ+b)(-7@ZZlE K(X(Qdc ê<(~"8Ø* r9̞Myesl=WBRRyη7g/20?d+~Ise'@bY6oN z MD"Q{THZ)q]k>3:XRqQq_a,:(1VyiʉEI(*_!Z^VC;GS'VeHJ媭Kx@E!`1(tgѽgH#1C4RaV[<ܰŁM2gg{y0g>Mzy*խ_F?\-{4g6% 9ΒQ!d7lsQ*;\lxeJ y9L?.[g6UxŔbPJuhJ3Rd·>5)y@P|ͧ+ʳw f1A.yzsYJ y“  ̾5lh2RPUh{^5C}W}Nra~PAyPjKN yRO1oϯ7MF@u!c?GMKFøŨI)1*\Rb (܄&eCe{]K)߼8 נ^'* 2ʞڀ, ծYu#E"300hDdUC"D(<47dz)  wEؕ"c_5 !l((BrE]~AOTXF᧼> (5N*z~1{/Ȃ KC,H~Cq.%mS5Q%dHtU|Pö* ʴ+uED:c2{;yrh"Bhj"/z{)%/-IBO3/@0 J@U@{}.PZJ~,C8vwPd q)U`1QYO_AEg-a# sĸ\4g)4V"e;GLB uLr&uaX&b`q0hۧWs|5cH?p`EdD,$t(B t\FL fJ,!ZD^g|][: dTMr-aCif`~ PߑHbTV3r0V0UbB3,T((3O>Sp&'+¶ox Y&+>HxL3Q^!Wfbpc(yW=k9@5a#R+Q]rE}VQ9BPe?L~X\WL>9^X kg)_XECofhу ڷW)V: hF!4h;=Q#yrϦ|Ŝw-Pyr(,ܤPU{'IMqqf*'#o3iꕃg^SRNH:Kym W#f,Iȿ@޻mp7j(>/*!dT<}$@XS}'x&/ශP0p &HʇS< @p%D&_v䡤%PjUH+,uX!ي9wMFhZl:mܼp%hݞ΋zG x+N:%J\)N CqIR"Ga]uZaʊQC붊}q GY ۞݊EӎqKhX2vk"mIX[kpog3M0r"EO0w잓43 M 8,4[3G]ב $'uROJ%-,$l1cql}&ꟃzlKBI'G]#>Nمta/p,+Z pw0yYUusg)4΍qh 3'iuԳ9.l2/Hs^ d5s$y]cy[xJ(O*6DR欅&A 8TE*où}{P}¶ ?>L˱A#ÿ_D0SV4sF̐B921`?1 .Z:8vG TjcUii!8`-=dHlv] U)e}:%]' "${WDIR}/rcfiles.list" xargs --arg-file="${WDIR}/rcfiles.list" extractrc > "${WDIR}/rc.cpp" # additional string for KAboutData echo 'i18nc("NAME OF TRANSLATORS","Your names");' >> "${WDIR}/rc.cpp" echo 'i18nc("EMAIL OF TRANSLATORS","Your emails");' >> "${WDIR}/rc.cpp" echo "Done preparing rc files" echo "Extracting messages" # see above on sorting find "${BASEDIR}" -name '*.cpp' -o -name '*.h' -o -name '*.c' | sort > "${WDIR}/infiles.list" echo "rc.cpp" >> "${WDIR}/infiles.list" xgettext --from-code=UTF-8 -C -kde -ci18n -ki18n:1 -ki18nc:1c,2 -ki18np:1,2 -ki18ncp:1c,2,3 \ -ktr2i18n:1 -kI18N_NOOP:1 -kI18N_NOOP2:1c,2 -kaliasLocale -kki18n:1 -kki18nc:1c,2 \ -kki18np:1,2 -kki18ncp:1c,2,3 --msgid-bugs-address="${BUGADDR}" --files-from=infiles.list \ -D "${BASEDIR}" -D "${WDIR}" -o "${PROJECT}.pot" || \ { echo "error while calling xgettext. aborting."; exit 1; } echo "Done extracting messages" echo "Merging translations" catalogs=`find . -name '*.po'` for cat in $catalogs; do echo "$cat" msgmerge -o "$cat.new" "$cat" "${WDIR}/${PROJECT}.pot" mv "$cat.new" "$cat" done echo "Done merging translations" echo "Cleaning up" rm "${WDIR}/rcfiles.list" rm "${WDIR}/infiles.list" rm "${WDIR}/rc.cpp" echo "Done" plasma-widget-smooth-tasks/po/de.po000644 000765 000765 00000100550 11724514472 020150 0ustar00salvosalvo000000 000000 # 2009-08-28 # Markus Slopianka , 2009. # Daniel Schemala <28364@web.de>, 2010, 2011. # Toni Dietze , 2011. msgid "" msgstr "" "Project-Id-Version: \n" "Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n" "POT-Creation-Date: 2011-07-30 18:12+0200\n" "PO-Revision-Date: 2011-07-30 18:22+0200\n" "Last-Translator: Toni Dietze \n" "Language-Team: German \n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Lokalize 1.2\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14 #. i18n: ectx: property (windowTitle), widget (QWidget, General) #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17 #. i18n: ectx: property (accessibleName), widget (QWidget, General) #: ../applet/SmoothTasks/Applet.cpp:756 rc.cpp:274 rc.cpp:277 msgid "General" msgstr "Allgemein" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6 #. i18n: ectx: property (windowTitle), widget (QWidget, Appearance) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9 #. i18n: ectx: property (accessibleName), widget (QWidget, Appearance) #: ../applet/SmoothTasks/Applet.cpp:760 rc.cpp:3 rc.cpp:6 msgid "Appearance" msgstr "Erscheinungsbild" #: ../applet/SmoothTasks/Applet.cpp:764 msgid "Workarounds" msgstr "Provisorium" #: ../applet/SmoothTasks/Applet.cpp:776 msgid "Do Not Group" msgstr "Nicht gruppieren" #: ../applet/SmoothTasks/Applet.cpp:778 msgid "By Program Name" msgstr "Nach Programmname" #: ../applet/SmoothTasks/Applet.cpp:788 msgid "Do Not Sort" msgstr "Nicht sortieren" #: ../applet/SmoothTasks/Applet.cpp:789 msgid "Manually" msgstr "Manuell" #: ../applet/SmoothTasks/Applet.cpp:790 msgid "Alphabetically" msgstr "Alphabetisch" #: ../applet/SmoothTasks/Applet.cpp:791 msgid "By Desktop" msgstr "Nach Arbeitsfläche" #: ../applet/SmoothTasks/Applet.cpp:795 msgid "No Action" msgstr "Keine Aktion" #: ../applet/SmoothTasks/Applet.cpp:796 msgid "Close Task" msgstr "Task beenden" #: ../applet/SmoothTasks/Applet.cpp:797 msgid "Move to Current Desktop" msgstr "Auf die aktuelle Arbeitsfläche verschieben" #: ../applet/SmoothTasks/Applet.cpp:834 ../applet/SmoothTasks/Applet.cpp:853 msgid "None" msgstr "Keine" #: ../applet/SmoothTasks/Applet.cpp:835 msgid "Smooth" msgstr "Smooth" #: ../applet/SmoothTasks/Applet.cpp:836 msgid "Plasma" msgstr "Plasma" #: ../applet/SmoothTasks/Applet.cpp:840 msgid "By Taskbar Shape" msgstr "Nach der Form der Taskleiste" #: ../applet/SmoothTasks/Applet.cpp:841 msgid "Maximum Squeeze" msgstr "Maximale Dichte" #: ../applet/SmoothTasks/Applet.cpp:842 msgid "Fixed Item Number per Row" msgstr "Feste Anzahl von Tasks pro Zeile" #: ../applet/SmoothTasks/Applet.cpp:843 msgid "Limited Squeeze" msgstr "Beschränkte Komprimierung" #: ../applet/SmoothTasks/Applet.cpp:844 msgid "Fixed Maximum Item Height" msgstr "Feste maximale Task-Höhe" #: ../applet/SmoothTasks/Applet.cpp:854 msgid "Active" msgstr "Aktive" #: ../applet/SmoothTasks/Applet.cpp:855 msgid "From the current desktop" msgstr "Von der aktuellen Arbeitsfläche" #: ../applet/SmoothTasks/Applet.cpp:856 msgid "All" msgstr "Alle" #: ../applet/SmoothTasks/Applet.cpp:862 msgid "Classic" msgstr "Klassisch" #: ../applet/SmoothTasks/Applet.cpp:863 msgid "New" msgstr "Neu" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:106 #: ../applet/SmoothTasks/PlasmaToolTip.cpp:130 #: ../applet/SmoothTasks/Task.cpp:173 msgid "On all desktops" msgstr "Auf allen Arbeitsflächen" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:107 #: ../applet/SmoothTasks/PlasmaToolTip.cpp:133 #: ../applet/SmoothTasks/Task.cpp:174 msgctxt "Which virtual desktop a window is currently on" msgid "On %1" msgstr "Auf %1" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:132 msgid "On various desktops" msgstr "Auf verschiedenen Arbeitsflächen" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:139 #: ../applet/SmoothTasks/Task.cpp:168 msgid "Starting application..." msgstr "Programm wird gestartet..." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16 #. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab) #: rc.cpp:9 msgid "Task Items" msgstr "Tasks" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22 #. i18n: ectx: property (text), widget (QLabel, spaceLabel) #: rc.cpp:12 msgid "Space &Between Tasks:" msgstr "&Platz zwischen den Programmen:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:32 #. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:49 #. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:69 #. i18n: ectx: property (suffix), widget (QSpinBox, maxButtonWidth) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:189 #. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:273 #. i18n: ectx: property (suffix), widget (QSpinBox, minButtonWidth) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:511 #. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:610 #. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize) #: rc.cpp:15 rc.cpp:21 rc.cpp:27 rc.cpp:61 rc.cpp:79 rc.cpp:147 rc.cpp:181 msgid "px" msgstr "px" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:42 #. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel) #: rc.cpp:18 msgid "Minimal Icon Space:" msgstr "Minimale Symbolgröße:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:62 #. i18n: ectx: property (text), widget (QLabel, maxButtonWidthLabel) #: rc.cpp:24 msgid "Maximal Button Width:" msgstr "Maximale Task-Breite:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:82 #. i18n: ectx: property (text), widget (QLabel, iconScaleLabel) #: rc.cpp:30 msgid "&Icon Scale:" msgstr "&Symbolskalierung:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:92 #. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale) #: rc.cpp:33 msgid "" "The scale of the task icons in relation to the height/width (whatever is " "smaller) of the task item." msgstr "" "Die Skalierung des Task-Symbols in Relation zu der Höhe/Breite (was davon " "kleiner ist) des Tasks." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:95 #. i18n: ectx: property (suffix), widget (QSpinBox, iconScale) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:971 #. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:987 #. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical) #: rc.cpp:37 rc.cpp:267 rc.cpp:271 #, no-c-format msgid "%" msgstr "%" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:111 #. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame) #: rc.cpp:40 msgid "" "For some plasma themes task items might look better when their frames " "are not rotated. This only concerns vertical layouts, e.g. when you place " "the taskbar at the left (or right) screen edge." msgstr "" "Für manche Plasma-Themes sieht es eventuell besser aus, wenn die Rahmen " "der Tasks nicht rotiert werden. Dies betrifft nur vertikale Layouts, z.B. " "wenn die Taskleiste am linken oder rechten Bildschirmrand platziert ist." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:114 #. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame) #: rc.cpp:43 msgid "Don't &Rotate Frames" msgstr "Rahmen &nicht rotieren" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:121 #. i18n: ectx: property (text), widget (QCheckBox, textShadow) #: rc.cpp:46 msgid "Draw &Text-Shadow" msgstr "&Textschatten anzeigen" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:131 #. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks) #: rc.cpp:49 msgid "Switch Tasks using &Wheel" msgstr "Tasks mit dem &Mausrad wechseln" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:163 #. i18n: ectx: property (text), widget (QCheckBox, expandTasks) #: rc.cpp:52 msgid "&Expand Tasks" msgstr "Tasks aus&klappen" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:173 #. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel) #: rc.cpp:55 msgid "E&xpanding Size:" msgstr "&Ausklappgröße:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:186 #. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize) #: rc.cpp:58 msgid "" "This is the width of a taskbar button which is expanded by hover or by " "attention demand. Keep in mind that the taskbar buttons might not be able to " "expand fully when there is not enough room." msgstr "" "Dies ist die Breite, die ein Task erhält, wenn er durch Mausberührung " "oder oder Verlangen der Aufmerksamkeit aufgeklappt wird. Wenn nicht genug " "Platz in der Taskleiste vorhanden ist, kann dieser Wert auch unterschritten " "werden." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:208 #. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention) #: rc.cpp:64 msgid "Expand on &Attention" msgstr "Bei geforderter &Aufmerksamkeit aufklappen" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:218 #. i18n: ectx: property (text), widget (QCheckBox, expandOnHover) #: rc.cpp:67 msgid "Expand on &Hover" msgstr "Bei &Mauskontakt aufklappen" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:231 #. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel) #: rc.cpp:70 msgid "&Keep Expanded:" msgstr "Ausgeklappt &lassen:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:260 #. i18n: ectx: property (text), widget (QLabel, minButtonWidthLabel) #: rc.cpp:73 msgid "Minimal Button Width:" msgstr "Minimale Task-Breite:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:270 #. i18n: ectx: property (toolTip), widget (QSpinBox, minButtonWidth) #: rc.cpp:76 msgid "" "This is the minimal width of a taskbar button which stays expanded (see " "“Keep Expanded”). Keep in mind that the taskbar buttons might not be able to " "expand fully when there is not enough room." msgstr "" "Dies ist die Breite, die ein Task erhält, wenn er durch Mausberührung " "oder oder Verlangen der Aufmerksamkeit aufgeklappt wird. Wenn nicht genug " "Platz in der Taskleiste vorhanden ist, kann dieser Wert auch unterschritten " "werden." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284 #. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab) #: rc.cpp:82 msgid "Taskbar Layout" msgstr "Taskleisten-Layout" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:296 #. i18n: ectx: property (text), widget (QLabel, label_2) #: rc.cpp:85 msgid "Row Constraints" msgstr "Zeilen-Beschränkungen" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:303 #. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel) #: rc.cpp:88 msgid "&Minimum Rows:" msgstr "&Minimale Zeilenanzahl:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:313 #. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows) #: rc.cpp:91 msgid "" "This defines the minimum row count. Some layouts stretch the filled rows " "in order to fill any empty space. This way the displayed rows might be still " "fewer than this value." msgstr "" "Dieser Wert gibt die minimale Zeilenanzahl an. Manche Layouts strecken " "die gefüllten Zeilen so, dass keine leeren Zeilen angezeigt werden. In " "diesem Fall können weniger Zeilen angezeigt werden, als dieser Wert angibt." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:326 #. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel) #: rc.cpp:94 msgid "Ma&ximum Rows:" msgstr "Ma&ximale Zeilenanzahl:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:336 #. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows) #: rc.cpp:97 msgid "This defines the maximum row count." msgstr "Dieser Wert gibt die maximale Anzahl an Zeilen an." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:376 #. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel) #: rc.cpp:100 msgid "&Layout:" msgstr "&Layout:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:409 #. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout) #: rc.cpp:103 msgid "" "

The layout is responsible for the size and placement of the task items.\n" "Each of the provided layouts has other advantages and disadvantages.\n" "Because I can't decide which layouting strategy is best suited for this " "purpose I include several choices for now.

\n" "\n" "

By Taskbar Shape

\n" "

This layout creates as much rows as are needed so that following " "condition is met:

\n" "
row height × row aspect ratio ≤ row width
\n" "

However, if this would yield empty rows the filled rows are scaled in " "height so that the whole task bar space is covered.

\n" "\n" "

Maximum Squeeze

\n" "

Because the width of the task items depends of their height the more rows " "there are the less room the items occupy.\n" "This layout sets the width of the task items always to the width they would " "have when the row count would have reached the maximally allowed value.\n" "\n" "

Fixed Item Number per Row

\n" "

This layout always put the configured number of task items into one row, " "unless there would not be enough room for all task items.\n" "Then the items are distributed evenly over the rows.

\n" "\n" "

Limited Squeeze

\n" "

This layout tries to squeeze the task items only up to a given maximum " "squeeze ratio. If it would have to squeeze them more than that it creates a " "new row. Currently this layout is the only one that respects the “Prefer " "Grouping” setting.

\n" "\n" "

Fixed Maximum Item Height

\n" "

This layout always assumes the configured height of the task items.\n" "Through the dependency between the width and height of the task items this " "leads to a specific distribution of the items.\n" "This layout does not fill empty space by up-scaling the rows.

" msgstr "" "

Das Layout ist für die Größe und die Platzierung der Tasks " "verantwortlich.\n" "Jedes der zur Verfügung gestellten Layouts hat Vor- und Nachteile.\n" "Da ich nicht zu entscheiden vermag, welches am besten für eine Taskleiste " "geeignet ist, biete ich eine Auswahl von Layouts an:

\n" "\n" "

Nach der Form der Taskleiste

\n" "

Dieses Layout erzeugt so viele Zeilen wie nötig, um folgende Bedingung zu " "erfüllen:

\n" "
Zeilenhöhe × Zeilen-Seitenverhältnis ≤ Zeilenbreite
\n" "

Wenn jedoch hieraus Leerzeilen erfolgen würden, werden die gefüllten " "Zeilen in ihrer Höhe skaliert, um den freien Bereich aufzufüllen.

\n" "\n" "

Maximale Dichte

\n" "

Da die Breite der Tasks von ihrer Höhe abhängt, passen immer mehr Tasks " "in eine Zeile, je mehr Zeilen es gibt. Dieses Layout setzt die Breite der " "Tasks immer auf die Breite, die sie hätten, wenn die Maximale " "Zeilenanzahl erreicht wäre.

\n" "

Feste Anzahl von Tasks pro Zeile

\n" "

Dieses Layout setzt immer die konfigurierte Anzahl von Tasks in eine " "Zeile, außer es gibt nicht genug Platz für alle Tasks. Dann werden die Tasks " "auf alle Zeilen gleich aufgeteilt.

\n" "

Beschränkte Komprimierung

\n" "

Dieses Layout versucht, die Tasks nicht mehr als auf die angegebene " "maximale Komprimierung zu schrumpfen. Wenn die Tasks stärker geschrumpft " "werden müssten, um in eine Zeile zu passen, wird eine neue Zeile eingefügt. " "Zur Zeit ist dieses Layout das einzige, welches die „Bevorzuge Gruppierung“-" "Option beachtet.

\n" "

Feste maximale Task-Höhe

\n" "

Dieses Layout nimmt immer die konfigurierte Höhe der Tasks an. Durch die " "Abhängigkeit zwischen der Breite und Höhe der Tasks führt dies zu einer " "spezifischen Aufteilung der Tasks auf die Zeilen. Dieses Layout füllt " "etwaigen freien Raum nicht auf.

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:434 #. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel) #: rc.cpp:129 msgid "Row &Aspect Ratio:" msgstr "Zeilen-&Seitenverhältnis:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:447 #. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio) #: rc.cpp:132 msgid "" "The “By Taskbar Shape” layout uses this value to determine how many rows " "should be created." msgstr "" "Das „Nach der Form der Taskleiste“-Layout verwendet diesen Wert, um zu " "ermitteln, wie viele Zeilen angezeigt werden sollen." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:469 #. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel) #: rc.cpp:135 msgid "&Items per Row:" msgstr "Tasks pro &Zeile" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:482 #. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow) #: rc.cpp:138 msgid "" "The “Fixed Item Number per Row” layout uses this amount to fill the rows " "with task items." msgstr "" "Das „Feste Anzahl von Tasks pro Zeile“-Layout verwendet diesen Wert, um die " "Zeilen mit entsprechend vielen Tasks aufzufüllen." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:495 #. i18n: ectx: property (text), widget (QLabel, itemHeightLabel) #: rc.cpp:141 msgid "Maximum Item &Height:" msgstr "Maximale Task-&Höhe" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:508 #. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight) #: rc.cpp:144 msgid "" "The “Fixed Maximum Item Height” layout uses this value to determine the " "size of the task items." msgstr "" "Das „Feste maximale Task-Höhe“-Layout verwendet diesen Wert, um die Größe " "der Tasks zu ermitteln." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:524 #. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel) #: rc.cpp:150 msgid "Maximum &Squeeze Ratio:" msgstr "Maximales &Komprimierungsverhältnis:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:537 #. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio) #: rc.cpp:153 msgid "" "

The “Limited Squeeze” layout tries not to squeeze items so that " "squeezed item width / item width ≥ maximum squeeze ratio.

" msgstr "" "

Das „Beschränkte Komprimierung“-Layout versucht, die Tasks nur so stark " "zu komprimieren, dass Komprimierte Task-Breite / Task-Breite ≥ " "Maximale Komprimierung erfüllt ist.

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:559 #. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping) #: rc.cpp:156 msgid "" "Prefere grouping of tasks over the creation of new rows (currently only " "supported by the Limited Squeeze” layout)." msgstr "" "Bevorzuge das Gruppieren von Tasks vor dem Erzeugen neuer Zeilen (zur Zeit " "nur vom „Beschränkte Komprimierung“-Layout unterstützt)." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:562 #. i18n: ectx: property (text), widget (QCheckBox, preferGrouping) #: rc.cpp:159 msgid "&Prefer Grouping" msgstr "&Bevorzuge Gruppierung" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:570 #. i18n: ectx: attribute (title), widget (QWidget, toolTipTab) #: rc.cpp:162 msgid "Tool Tip" msgstr "Kurzinfo" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576 #. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel) #: rc.cpp:165 msgid "Preview St&yle:" msgstr "&Vorschaumodus:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590 #. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout) #: rc.cpp:168 msgid "" "

Classic

\n" "

\n" "\n" "

New

\n" "

" msgstr "" "

Klassisch

\n" "

\n" "\n" "

Neu

\n" "

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:597 #. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel) #: rc.cpp:175 msgid "Preview Si&ze:" msgstr "Vorschau&größe:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:607 #. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize) #: rc.cpp:178 msgid "" "This value defines the maximum length of one side of window previews." msgstr "" "Dieser Wert definiert die maximale Länge einer Seite der Vorschaubilder." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:640 #. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel) #: rc.cpp:184 msgid "Tool Tip &Type:" msgstr "Kurz&info-Art:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:657 #. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind) #: rc.cpp:187 msgid "" "

None

\n" "

Don't display tool tips.

\n" "\n" "

Smooth

\n" "

Use advanced tool tips for the task items. These tool tips show window " "previews that can be clicked to activate the corresponding window. When you " "hover the preview the window gets highlighted. However, this kind of tool " "tip is not well integrated with plasma.

\n" "\n" "

Plasma

\n" "

Use native plasma tool tips. This kind of tool tips do not provide the " "features described above. Instead they integrate well with other applet's " "tool tips and move animated across applets.

" msgstr "" "

Keine

\n" "

Keine Kurzinfos anzeigen.

\n" "\n" "

Smooth

\n" "

Diese Art der Kurzinfos zeigt Vorschaubilder an, die angeklickt werden " "können, um die entsprechenden Fenster zu aktivieren. Bei Mauskontakt wird " "das dazugehörige Fenster hervorgehoben. Diese Kurzinfos integrieren sich " "jedoch nicht vollständig in die Plasma-Oberfläche.

\n" "\n" "

Plasma

\n" "

Diese Art der Kurzinfos bietet keine der oben genannten Eigenschaften, " "integriert sich jedoch in die Plasma-Oberfläche. Dies bedeutet, dass sich " "die Kurzinfos auch über Appletgrenzen hinweg zu anderen Applets bewegen.

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:679 #. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:712 #. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:781 #. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration) #: rc.cpp:197 rc.cpp:206 rc.cpp:227 msgid "ms" msgstr "ms" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:692 #. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel) #: rc.cpp:200 msgid "Move &Duration:" msgstr "&Bewegungsdauer:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:702 #. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel) #: rc.cpp:203 msgid "&Highlight Delay:" msgstr "&Hervorhebungsverzögerung:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:725 #. i18n: ectx: property (text), widget (QCheckBox, hideTooltipAfterClick) #: rc.cpp:209 msgid "Hide Tool Tip after Click" msgstr "Kurzinfo nach Klick verschwinden lassen" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:736 #. i18n: ectx: attribute (title), widget (QWidget, animationTab) #: rc.cpp:212 msgid "Animation" msgstr "Animation" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:742 #. i18n: ectx: property (text), widget (QLabel, fpsLabel) #: rc.cpp:215 msgid "&Frames per Second:" msgstr "Bil&der in der Sekunde:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:752 #. i18n: ectx: property (suffix), widget (QSpinBox, fps) #: rc.cpp:218 msgid "fps" msgstr "fps" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:768 #. i18n: ectx: property (text), widget (QLabel, animationDurationLabel) #: rc.cpp:221 msgid "&Animation Duration:" msgstr "&Animationsdauer:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:778 #. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration) #: rc.cpp:224 msgid "" "This defines the duration of animations like the expansion of tasks and " "the delay for which a tool tip will be shown after you stopped hovering the " "task item or tool tip." msgstr "" "Dieser Wert gibt die Dauer von Animationen an, wie das Aufklappen der " "Tasks und die Dauer für welche Kurzinfos noch angezeigt werden sollen, wenn " "die Maus diese bzw. den entsprechenden Task bereits verlassen hat." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:797 #. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel) #: rc.cpp:230 msgid "Animation Speed:" msgstr "Animationsgeschwindigkeit" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:821 #. i18n: ectx: attribute (title), widget (QWidget, lightsTab) #: rc.cpp:233 msgid "Lights" msgstr "&Beleuchtung" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:839 #. i18n: ectx: property (toolTip), widget (QCheckBox, lights) #: rc.cpp:236 msgid "" "When this is checked a blob of light is drawn on the task items when you " "hover them or when they demand attention." msgstr "" "Wenn diese Option ausgewählt ist, wird ein Licht-Fleck auf den Tasks-" "Buttons angezeigt, wenn die Maus diese berührt oder der Task Aufmerksamkeit " "verlangt." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:842 #. i18n: ectx: property (text), widget (QCheckBox, lights) #: rc.cpp:239 msgid "&Lights" msgstr "Be&leuchtung" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:855 #. i18n: ectx: property (text), widget (QLabel, colorLabel) #: rc.cpp:242 msgid "&Color:" msgstr "&Farbe:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:889 #. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon) #: rc.cpp:245 msgid "" "When this is checked the dominant color of the task icon is used as the " "light color. When only an ugly (grayish) color could be extracted the color " "specified above is used instead." msgstr "" "Bei Verwendung dieser Option wird für das Licht die dominante Farbe des " "Task-Symbols verwendet. Sollte nur eine hässliche (graue) Farbe aus dem " "Symbol extrahiert werden können, dann wird die Farbe von oben verwendet." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:892 #. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon) #: rc.cpp:248 msgid "Color From &Icon" msgstr "Farbe aus dem Programmsymbol" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:905 #. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights) #: rc.cpp:251 msgid "" "Usually a different frame for hovered task items is used. But for some " "plasma themes this might look ugly in combination with the light effect. " "Using this option you can deactivate the usage of a different task item " "frame on hover." msgstr "" "Normalerweise wird, wenn die Maus einen Task berührt, ein anderer Rahmen " "um den Task gezeichnet. Bei manchen Plasma-Themen sieht dies jedoch hässlich " "aus, wenn der Lichteffekt verwendet wird. Mit dieser Option wird bei " "Berührung kein anderer Rahmen gezeichnet." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:908 #. i18n: ectx: property (text), widget (QCheckBox, onlyLights) #: rc.cpp:254 msgid "As &Only Hover Effect" msgstr "&Einziger Effekt bei Berührung" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:921 #. i18n: ectx: property (text), widget (QLabel, label) #: rc.cpp:257 msgid "Anchor Light:" msgstr "Beleuchtung verankern:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:951 #. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled) #: rc.cpp:260 msgid "Anchor horizontally at:" msgstr "Horizontal verankern bei:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:961 #. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled) #: rc.cpp:263 msgid "Anchor vertically at:" msgstr "Vertikal verankern bei:" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44 #. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel) #: rc.cpp:280 msgid "Grouping & Sorting" msgstr "Gruppierung und Sortieren" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51 #. i18n: ectx: property (text), widget (QLabel, groupingLabel) #: rc.cpp:283 msgid "&Grouping:" msgstr "&Gruppierung:" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89 #. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull) #: rc.cpp:286 msgid "Only when the taskbar is &full" msgstr "Nur wenn die Taskleiste &voll ist" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98 #. i18n: ectx: property (text), widget (QLabel, sortingLabel) #: rc.cpp:289 msgid "&Sorting:" msgstr "&Sortieren:" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136 #. i18n: ectx: property (text), widget (QLabel, filtersLabel) #: rc.cpp:292 msgid "Filters" msgstr "Filter" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized) #: rc.cpp:295 msgid "Only show tasks that are &minimized" msgstr "Nur &minimierte Fenster anzeigen" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop) #: rc.cpp:298 msgid "Only show tasks from the current &desktop" msgstr "Nur Fenster der aktuellen &Arbeitsfläche anzeigen" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen) #: rc.cpp:301 msgid "Only show tasks from the current s&creen" msgstr "Nur Fenster des aktuellen &Bildschirms anzeigen" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237 #. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel) #: rc.cpp:304 msgid "Middle Click &Action:" msgstr "Mittelklick-&Aktion:" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247 #. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction) #: rc.cpp:307 msgid "Action that should be performed when a task item is middle clicked." msgstr "" "Auszuführende Aktion, wenn die mittlere Maustaste auf einem Task gedrückt " "wird" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:278 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentActivity) #: rc.cpp:310 msgid "O&nly show tasks from the current activity" msgstr "Nur Fenster der aktuellen &Aktivität anzeigen" #. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14 #. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds) #: rc.cpp:313 msgid "Form" msgstr "Fenster" #. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26 #. i18n: ectx: property (text), widget (QLabel, label) #: rc.cpp:316 msgid "" "The margin sizes for task bar buttons are not designed for having a light " "effect in the middle of a button. If the light effect looks strange you can " "define custom button margins for the light here." msgstr "" "Die Randgrößen der Taskbuttons wurden nicht für einen Beleuchtungseffekt " "konzipiert. Wenn die Beleuchtung seltsam aussieht, können Sie die Ränder " "hier anpassen." #. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36 #. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom) #: rc.cpp:319 msgid "enable custom margin sizes" msgstr "Spezifische Randgrößen aktivieren:" #: rc.cpp:320 msgctxt "NAME OF TRANSLATORS" msgid "Your names" msgstr "Fabian Würtz, Mathias Panzenböck, Markus Slopianka, Daniel Schemala" #: rc.cpp:321 msgctxt "EMAIL OF TRANSLATORS" msgid "Your emails" msgstr "" "xadras@sidux.com, grosser.meister.morti@gmx.net, kamikazow@web.de, " "sehrpositiv@web.de" #~ msgid "Rectangle" #~ msgstr "Rechteck" #~ msgid "Square" #~ msgstr "Quadrat" #~ msgid "Task &Shape:" #~ msgstr "Task&form:" #~ msgid "" #~ "

This setting is only effective when there is enough room in the " #~ "taskbar to display the task items in the according shape.

\n" #~ "\n" #~ "

Rectangle

\n" #~ "

Displays collapsed task items as rectangles.

\n" #~ "\n" #~ "

Square

\n" #~ "

Displays collapsed task items as squares.

" #~ msgstr "" #~ "

Diese Option ist nur wirksam, wenn in der Taskleiste genug Platz " #~ "vorhanden ist, um die jeweilige Form anzuzeigen.

\n" #~ "\n" #~ "

Rechteck

\n" #~ "

Zeigt zugeklappte Tasks als Rechteck an.

\n" #~ "\n" #~ "

Quadrat

\n" #~ "

Zeigt zugeklappte Tasks als Quadrat an.

" #, fuzzy #~ msgid "" #~ "This is the additional size that gets added to a task item when it " #~ "expands. Keep in mind that the task items might not be able to expand " #~ "fully when there is not enough room." #~ msgstr "" #~ "Dies ist die minimale Breite, die ein Task erhält, der aufgeklappt " #~ "bleibt (Siehe „Ausgeklappt lassen“). Wenn nicht genug Platz in der " #~ "Taskleiste vorhanden ist, kann dieser Wert auch unterschritten werden." #~ msgid "minimal text space:" #~ msgstr "Minimale Textbreite:" #~ msgid "maximal text space:" #~ msgstr "Maximale Textbreite:" plasma-widget-smooth-tasks/po/zh_CN.po000644 000765 000765 00000071733 11724514472 020573 0ustar00salvosalvo000000 000000 # Daniel Schemala <28364@web.de>, 2010. msgid "" msgstr "" "Project-Id-Version: \n" "Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n" "POT-Creation-Date: 2010-01-12 22:42+0100\n" "PO-Revision-Date: 2010-01-12 22:03+0100\n" "Last-Translator: Daniel Schemala <28364@web.de>\n" "Language-Team: Deutsch \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: Chinese\n" "X-Poedit-Country: CHINA\n" "X-Poedit-SourceCharset: utf-8\n" "X-Generator: Lokalize 1.0\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14 #. i18n: ectx: property (windowTitle), widget (QWidget, General) #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17 #. i18n: ectx: property (accessibleName), widget (QWidget, General) #: ../applet/SmoothTasks/Applet.cpp:641 rc.cpp:280 rc.cpp:283 msgid "General" msgstr "常规" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6 #. i18n: ectx: property (windowTitle), widget (QWidget, Appearance) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9 #. i18n: ectx: property (accessibleName), widget (QWidget, Appearance) #: ../applet/SmoothTasks/Applet.cpp:645 rc.cpp:3 rc.cpp:6 msgid "Appearance" msgstr "外观" #: ../applet/SmoothTasks/Applet.cpp:649 msgid "Workarounds" msgstr "" #: ../applet/SmoothTasks/Applet.cpp:660 msgid "Do Not Group" msgstr "不分组" #: ../applet/SmoothTasks/Applet.cpp:662 msgid "By Program Name" msgstr "按程序名称" #: ../applet/SmoothTasks/Applet.cpp:672 msgid "Do Not Sort" msgstr "不排序" #: ../applet/SmoothTasks/Applet.cpp:673 msgid "Manually" msgstr "手动" #: ../applet/SmoothTasks/Applet.cpp:674 msgid "Alphabetically" msgstr "按字母排序" #: ../applet/SmoothTasks/Applet.cpp:675 msgid "By Desktop" msgstr "按桌面" #: ../applet/SmoothTasks/Applet.cpp:679 msgid "No Action" msgstr "无操作" #: ../applet/SmoothTasks/Applet.cpp:680 msgid "Close Task" msgstr "关闭任务" #: ../applet/SmoothTasks/Applet.cpp:681 msgid "Move to Current Desktop" msgstr "放到当前桌面" #: ../applet/SmoothTasks/Applet.cpp:685 msgid "Rectangle" msgstr "矩形" #: ../applet/SmoothTasks/Applet.cpp:686 msgid "Square" msgstr "正方形" #: ../applet/SmoothTasks/Applet.cpp:721 ../applet/SmoothTasks/Applet.cpp:740 msgid "None" msgstr "无" #: ../applet/SmoothTasks/Applet.cpp:722 msgid "Smooth" msgstr "Smooth" #: ../applet/SmoothTasks/Applet.cpp:723 msgid "Plasma" msgstr "Plasma" #: ../applet/SmoothTasks/Applet.cpp:727 msgid "By Taskbar Shape" msgstr "按任务栏的形状" #: ../applet/SmoothTasks/Applet.cpp:728 msgid "Maximum Squeeze" msgstr "最大压缩" #: ../applet/SmoothTasks/Applet.cpp:729 msgid "Fixed Item Number per Row" msgstr "每行固定个数" #: ../applet/SmoothTasks/Applet.cpp:730 msgid "Limited Squeeze" msgstr "限制压缩" #: ../applet/SmoothTasks/Applet.cpp:731 msgid "Fixed Maximum Item Height" msgstr "固定任务项最大高度" #: ../applet/SmoothTasks/Applet.cpp:741 msgid "Active" msgstr "活动的" #: ../applet/SmoothTasks/Applet.cpp:742 msgid "From the current desktop" msgstr "当前桌面" #: ../applet/SmoothTasks/Applet.cpp:743 msgid "All" msgstr "全部" #: ../applet/SmoothTasks/Applet.cpp:749 msgid "Classic" msgstr "传统样式" #: ../applet/SmoothTasks/Applet.cpp:750 msgid "New" msgstr "新样式" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:81 #: ../applet/SmoothTasks/PlasmaToolTip.cpp:105 #: ../applet/SmoothTasks/Task.cpp:122 #: ../applet/SmoothTasks/WindowPreview.cpp:270 msgid "On all desktops" msgstr "于全部桌面" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:82 #: ../applet/SmoothTasks/PlasmaToolTip.cpp:108 #: ../applet/SmoothTasks/Task.cpp:123 #: ../applet/SmoothTasks/WindowPreview.cpp:271 msgctxt "Which virtual desktop a window is currently on" msgid "On %1" msgstr "于 %1" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:107 msgid "On various desktops" msgstr "于多个桌面" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:114 #: ../applet/SmoothTasks/Task.cpp:117 #: ../applet/SmoothTasks/WindowPreview.cpp:268 msgid "Starting application..." msgstr "程序启动中…" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16 #. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab) #: rc.cpp:9 msgid "Task Items" msgstr "任务项" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22 #. i18n: ectx: property (text), widget (QLabel, taskShapeLabel) #: rc.cpp:12 msgid "Task &Shape:" msgstr "任务项形状(&S)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:38 #. i18n: ectx: property (toolTip), widget (QComboBox, shape) #: rc.cpp:15 msgid "" "

This setting is only effective when there is enough room in the taskbar " "to display the task items in the according shape.

\n" "\n" "

Rectangle

\n" "

Displays collapsed task items as rectangles.

\n" "\n" "

Square

\n" "

Displays collapsed task items as squares.

" msgstr "" "

这个设置只在有任务栏中足够的空间显示任务项时起作用。

\n" "\n" "

矩形

\n" "

按矩形显示折叠的任务项

\n" "\n" "

正方形

\n" "

按正方形显示折叠的任务项

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:45 #. i18n: ectx: property (text), widget (QLabel, spaceLabel) #: rc.cpp:24 msgid "Space &Between Tasks:" msgstr "任务项间空隙(&B)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:55 #. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:79 #. i18n: ectx: property (suffix), widget (QSpinBox, minTextSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:96 #. i18n: ectx: property (suffix), widget (QSpinBox, maxTextSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:216 #. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284 #. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:525 #. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:624 #. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize) #: rc.cpp:27 rc.cpp:36 rc.cpp:42 rc.cpp:76 rc.cpp:88 rc.cpp:156 rc.cpp:190 msgid "px" msgstr "像素" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:65 #. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel) #: rc.cpp:30 msgid "minimal icon space:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:72 #. i18n: ectx: property (text), widget (QLabel, minTextSpaceLabel) #: rc.cpp:33 msgid "minimal text space:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:89 #. i18n: ectx: property (text), widget (QLabel, maxTextSpaceLabel) #: rc.cpp:39 msgid "maximal text space:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:109 #. i18n: ectx: property (text), widget (QLabel, iconScaleLabel) #: rc.cpp:45 msgid "&Icon Scale:" msgstr "图标大小(&I)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119 #. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale) #: rc.cpp:48 msgid "" "The scale of the task icons in relation to the height/width (whatever is " "smaller) of the task item." msgstr "任务图标的大小和任务项的高度/宽度(较小的值)的比例。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122 #. i18n: ectx: property (suffix), widget (QSpinBox, iconScale) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975 #. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:991 #. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical) #: rc.cpp:52 rc.cpp:273 rc.cpp:277 #, no-c-format msgid "%" msgstr "%" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:138 #. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame) #: rc.cpp:55 msgid "" "For some plasma themes task items might look better when their frames " "are not rotated. This only concerns vertical layouts, e.g. when you place " "the taskbar at the left (or right) screen edge." msgstr "" "有些Plasma 主题可能框架不旋转看起来更好。这个选项只和竖向布局有关，例如你将任" "务栏放在屏幕的左边或右边时。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:141 #. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame) #: rc.cpp:58 msgid "Don't &Rotate Frames" msgstr "不要旋转框架(&R)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:148 #. i18n: ectx: property (text), widget (QCheckBox, textShadow) #: rc.cpp:61 msgid "Draw &Text-Shadow" msgstr "绘制文字阴影(&T)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:158 #. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks) #: rc.cpp:64 msgid "Switch Tasks using &Wheel" msgstr "使用滚轮切换任务(&W)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:190 #. i18n: ectx: property (text), widget (QCheckBox, expandTasks) #: rc.cpp:67 msgid "&Expand Tasks" msgstr "展开任务项(&E)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:200 #. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel) #: rc.cpp:70 msgid "E&xpanding Size:" msgstr "展开大小(&x)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:213 #. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize) #: rc.cpp:73 msgid "" "This is the additional size that gets added to a task item when it " "expands. Keep in mind that the task items might not be able to expand fully " "when there is not enough room." msgstr "" "这个值时当一个任务项展开时所需要的额外空间。注意任务项也许由于空间不足不会被" "完全展开。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:235 #. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel) #: rc.cpp:79 msgid "&Keep Expanded:" msgstr "保持展开(&K)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:264 #. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention) #: rc.cpp:82 msgid "Expand on &Attention" msgstr "请求注意时展开(&A)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274 #. i18n: ectx: property (text), widget (QCheckBox, expandOnHover) #: rc.cpp:85 msgid "Expand on &Hover" msgstr "悬停时展开(&H)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:298 #. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab) #: rc.cpp:91 msgid "Taskbar Layout" msgstr "任务栏布局" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:310 #. i18n: ectx: property (text), widget (QLabel, label_2) #: rc.cpp:94 msgid "Row Constraints" msgstr "行数约束：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:317 #. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel) #: rc.cpp:97 msgid "&Minimum Rows:" msgstr "最小行数(&M)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:327 #. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows) #: rc.cpp:100 msgid "" "This defines the minimum row count. Some layouts stretch the filled rows " "in order to fill any empty space. This way the displayed rows might be still " "fewer than this value." msgstr "" "这个值定义了最小的行数。有些布局拉伸了被填充的行从而填充空白区域。这种方式显" "示的行数可能比这个值小。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:340 #. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel) #: rc.cpp:103 msgid "Ma&ximum Rows:" msgstr "最大行数(&x)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:350 #. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows) #: rc.cpp:106 msgid "This defines the maximum row count." msgstr "这个值定义了最大的行数。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:390 #. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel) #: rc.cpp:109 msgid "&Layout:" msgstr "布局(&L)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:423 #. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout) #: rc.cpp:112 msgid "" "

The layout is responsible for the size and placement of the task items.\n" "Each of the provided layouts has other advantages and disadvantages.\n" "Because I can't decide which layouting strategy is best suited for this " "purpose I include several choices for now.

\n" "\n" "

By Taskbar Shape

\n" "

This layout creates as much rows as are needed so that following " "condition is met:

\n" "
row height × row aspect ratio ≤ row width
\n" "

However, if this would yield empty rows the filled rows are scaled in " "height so that the whole task bar space is covered.

\n" "\n" "

Maximum Squeeze

\n" "

Because the width of the task items depends of their height the more rows " "there are the less room the items occupy.\n" "This layout sets the width of the task items always to the width they would " "have when the row count would have reached the maximally allowed value.\n" "\n" "

Fixed Item Number per Row

\n" "

This layout always put the configured number of task items into one row, " "unless there would not be enough room for all task items.\n" "Then the items are distributed evenly over the rows.

\n" "\n" "

Limited Squeeze

\n" "

This layout tries to squeeze the task items only up to a given maximum " "squeeze ratio. If it would have to squeeze them more than that it creates a " "new row. Currently this layout is the only one that respects the “Prefer " "Grouping” setting.

\n" "\n" "

Fixed Maximum Item Height

\n" "

This layout always assumes the configured height of the task items.\n" "Through the dependency between the width and height of the task items this " "leads to a specific distribution of the items.\n" "This layout does not fill empty space by up-scaling the rows.

" msgstr "" "

布局负责任务项的放置和大小。\n" "每种布局都有它自己的优点和缺点。\n" "由于我不能决定哪种布局方法最适合，因此我在这里提供了很多选择。

\n" "\n" "

按任务栏形状

\n" "

这个布局创建尽可能多的行来满足以下条件：

\n" "
行高度 × 行长宽比 ≤ 行宽度
\n" "

但是，如果这个规则产生了空行，非空行就会调整高度使得空白区域被覆盖。

\n" "\n" "

最大压缩

\n" "

因为任务项的宽度取决于它们的高度，行数越多那么它们所占的空间就越小。\n" "这个布局总是将任务项的宽度设置为它们达到最大的行数时的宽度。\n" "\n" "

每行固定个数

\n" "

这个布局总是在一行内放置固定数量项，除非已经没有足够的空间放置所有的任务" "项。\n" "然后项就会被均匀的分布在每一行里。

\n" "\n" "

限制压缩

\n" "

这个布局尝试压缩任务项，至多压缩到最大压缩比。如果我们不得不超过这个比率时" "那么就新建一行。目前这是唯一一个受“优先分组”选项影响的布局。

\n" "\n" "

固定任务项最大高度

\n" "

这个布局总是假定任务项的高度为所配置的值。\n" "因为任务项宽和高之间的依赖关系，这个布局会导致一个特殊的项的分布。\n" "这个布局不会通过增加行高来填充空白。

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:448 #. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel) #: rc.cpp:138 msgid "Row &Aspect Ratio:" msgstr "行长宽比" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:461 #. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio) #: rc.cpp:141 msgid "" "The “By Taskbar Shape” layout uses this value to determine how many rows " "should be created." msgstr "“按任务栏的形状”布局使用这个值来确定有多少行应当被创建。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483 #. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel) #: rc.cpp:144 msgid "&Items per Row:" msgstr "每行任务项个数(&I)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:496 #. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow) #: rc.cpp:147 msgid "" "The “Fixed Item Number per Row” layout uses this amount to fill the rows " "with task items." msgstr "“固定每行项个数”布局在用任务项填充行时使用这个值。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:509 #. i18n: ectx: property (text), widget (QLabel, itemHeightLabel) #: rc.cpp:150 msgid "Maximum Item &Height:" msgstr "最大项高度(&H)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:522 #. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight) #: rc.cpp:153 msgid "" "The “Fixed Maximum Item Height” layout uses this value to determine the " "size of the task items." msgstr "“固定任务项最大高度”布局使用这个值来决定任务项的大小。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:538 #. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel) #: rc.cpp:159 msgid "Maximum &Squeeze Ratio:" msgstr "最大压缩比(&S)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:551 #. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio) #: rc.cpp:162 msgid "" "

The “Limited Squeeze” layout tries not to squeeze items so that " "squeezed item width / item width ≥ maximum squeeze ratio.

" msgstr "" "

“限制压缩”布局尝试不压缩任务项，从而压缩任务项宽度 / 任务项原始宽度 " "≥ 最大压缩比.

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:573 #. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping) #: rc.cpp:165 msgid "" "Prefere grouping of tasks over the creation of new rows (currently only " "supported by the Limited Squeeze” layout)." msgstr "优先对任务分组而不是建立新的行（当前值被“限制压缩”布局支持）" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576 #. i18n: ectx: property (text), widget (QCheckBox, preferGrouping) #: rc.cpp:168 msgid "&Prefer Grouping" msgstr "优先分组(&P)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584 #. i18n: ectx: attribute (title), widget (QWidget, toolTipTab) #: rc.cpp:171 msgid "Tool Tip" msgstr "工具提示" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590 #. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel) #: rc.cpp:174 msgid "Preview St&yle:" msgstr "预览样式(&t)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:604 #. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout) #: rc.cpp:177 msgid "" "

Classic

\n" "

\n" "\n" "

New

\n" "

" msgstr "" "

经典样式

\n" "

\n" "\n" "

新样式

\n" "

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:611 #. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel) #: rc.cpp:184 msgid "Preview Si&ze:" msgstr "预览大小(&i)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:621 #. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize) #: rc.cpp:187 msgid "" "This value defines the maximum length of one side of window previews." msgstr "这个值定义了窗口预览的最大的边的大小。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:654 #. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel) #: rc.cpp:193 msgid "Tool Tip &Type:" msgstr "工具提示种类(&T)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:671 #. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind) #: rc.cpp:196 msgid "" "

None

\n" "

Don't display tool tips.

\n" "\n" "

Smooth

\n" "

Use advanced tool tips for the task items. These tool tips show window " "previews that can be clicked to activate the corresponding window. When you " "hover the preview the window gets highlighted. However, this kind of tool " "tip is not well integrated with plasma.

\n" "\n" "

Plasma

\n" "

Use native plasma tool tips. This kind of tool tips do not provide the " "features described above. Instead they integrate well with other applet's " "tool tips and move animated across applets.

" msgstr "" "

无

\n" "

不显示任何工具提示。

\n" "\n" "

Smooth

\n" "

为任务项使用高级提示。这些提示显示可以被单击激活对应窗口的窗口预览。当你鼠" "标停在一个窗口预览上时窗口被高亮显示。但是，这类提示和Plasma的集成并不好。\n" "\n" "

Plasma

\n" "

使用Plasma原生的提示。除了他们和其他Plamsa部件的提示集成地很好，可以在不同" "的部件之间移动之外，这类提示并没有上述的特性。

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693 #. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726 #. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:785 #. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration) #: rc.cpp:206 rc.cpp:215 rc.cpp:233 msgid "ms" msgstr "毫秒" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:706 #. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel) #: rc.cpp:209 msgid "Move &Duration:" msgstr "移动持续时间(&v)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:716 #. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel) #: rc.cpp:212 msgid "&Highlight Delay:" msgstr "高亮延迟(&H)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:740 #. i18n: ectx: attribute (title), widget (QWidget, animationTab) #: rc.cpp:218 msgid "Animation" msgstr "动画" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:746 #. i18n: ectx: property (text), widget (QLabel, fpsLabel) #: rc.cpp:221 msgid "&Frames per Second:" msgstr "每秒帧数(&F)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:756 #. i18n: ectx: property (suffix), widget (QSpinBox, fps) #: rc.cpp:224 msgid "fps" msgstr "fps" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:772 #. i18n: ectx: property (text), widget (QLabel, animationDurationLabel) #: rc.cpp:227 msgid "&Animation Duration:" msgstr "动画持续时间(&A)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:782 #. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration) #: rc.cpp:230 msgid "" "This defines the duration of animations like the expansion of tasks and " "the delay for which a tool tip will be shown after you stopped hovering the " "task item or tool tip." msgstr "" "这个值定义了动画的持续时间，比如展开任务项和当你停止将鼠标放在任务项或者工具" "提示上时工具提示显示的延迟时间。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:801 #. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel) #: rc.cpp:236 #, fuzzy msgid "Animation Speed:" msgstr "动画" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:825 #. i18n: ectx: attribute (title), widget (QWidget, lightsTab) #: rc.cpp:239 #, fuzzy msgid "Lights" msgstr "高亮(&L)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:843 #. i18n: ectx: property (toolTip), widget (QCheckBox, lights) #: rc.cpp:242 msgid "" "When this is checked a blob of light is drawn on the task items when you " "hover them or when they demand attention." msgstr "当这项被选中时，鼠标悬停在任务项上或者任务请求注意时会显示一团光效。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:846 #. i18n: ectx: property (text), widget (QCheckBox, lights) #: rc.cpp:245 msgid "&Lights" msgstr "高亮(&L)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:859 #. i18n: ectx: property (text), widget (QLabel, colorLabel) #: rc.cpp:248 msgid "&Color:" msgstr "颜色(&C)：" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:893 #. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon) #: rc.cpp:251 msgid "" "When this is checked the dominant color of the task icon is used as the " "light color. When only an ugly (grayish) color could be extracted the color " "specified above is used instead." msgstr "" "当选中时，任务图标的主要颜色被用作高亮颜色。当图标中只能选取出较难看的（灰" "色）颜色时，上面指定的颜色才被使用。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:896 #. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon) #: rc.cpp:254 msgid "Color From &Icon" msgstr "按图标显示颜色(&I)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909 #. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights) #: rc.cpp:257 msgid "" "Usually a different frame for hovered task items is used. But for some " "plasma themes this might look ugly in combination with the light effect. " "Using this option you can deactivate the usage of a different task item " "frame on hover." msgstr "" "通常鼠标悬停后，任务项会使用不同的框架效果。但是对某些Plasma主题来说，这会使" "得在启用光亮效果时令它们很难看。使用这个选项你可以禁用对鼠标悬停任务项使用一" "个不同的框架效果这一功能。" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:912 #. i18n: ectx: property (text), widget (QCheckBox, onlyLights) #: rc.cpp:260 msgid "As &Only Hover Effect" msgstr "作为唯一的悬停效果(&O)" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:925 #. i18n: ectx: property (text), widget (QLabel, label) #: rc.cpp:263 msgid "Anchor Light:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:955 #. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled) #: rc.cpp:266 msgid "Anchor horizontally at:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:965 #. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled) #: rc.cpp:269 msgid "Anchor vertically at:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44 #. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel) #: rc.cpp:286 msgid "Grouping & Sorting" msgstr "分组和排序：" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51 #. i18n: ectx: property (text), widget (QLabel, groupingLabel) #: rc.cpp:289 msgid "&Grouping:" msgstr "分组(&G)：" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89 #. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull) #: rc.cpp:292 msgid "Only when the taskbar is &full" msgstr "只在任务栏满时分组(&f)" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98 #. i18n: ectx: property (text), widget (QLabel, sortingLabel) #: rc.cpp:295 msgid "&Sorting:" msgstr "排序(&S)：" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136 #. i18n: ectx: property (text), widget (QLabel, filtersLabel) #: rc.cpp:298 msgid "Filters" msgstr "过滤" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized) #: rc.cpp:301 msgid "Only show tasks that are &minimized" msgstr "只显示最小化的任务(&m)" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop) #: rc.cpp:304 msgid "Only show tasks from the current &desktop" msgstr "只显示当前桌面的任务" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215 #. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen) #: rc.cpp:307 msgid "Only show tasks from the current s&creen" msgstr "只显示当前屏幕的任务(&s)" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237 #. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel) #: rc.cpp:310 msgid "Middle Click &Action:" msgstr "单击中键操作(&A)：" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247 #. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction) #: rc.cpp:313 msgid "Action that should be performed when a task item is middle clicked." msgstr "当任务项被鼠标中键点击时的动作" #. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14 #. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds) #: rc.cpp:316 msgid "Form" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26 #. i18n: ectx: property (text), widget (QLabel, label) #: rc.cpp:319 msgid "" "The margin sizes for task bar buttons are not designed for having a light " "effect in the middle of a button. If the light effect looks strange you can " "define custom button margins for the light here." msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36 #. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom) #: rc.cpp:322 msgid "enable custom margin sizes" msgstr "" #: rc.cpp:323 msgctxt "NAME OF TRANSLATORS" msgid "Your names" msgstr "Weng Xuetian" #: rc.cpp:324 msgctxt "EMAIL OF TRANSLATORS" msgid "Your emails" msgstr "hurricanek@126.com" plasma-widget-smooth-tasks/po/fr.po000644 000765 000765 00000075703 11724514472 020202 0ustar00salvosalvo000000 000000 # 2009-08-28 # Daniel Schemala <28364@web.de>, 2010. msgid "" msgstr "" "Project-Id-Version: \n" "Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n" "POT-Creation-Date: 2010-01-12 22:42+0100\n" "PO-Revision-Date: 2010-01-12 21:59+0100\n" "Last-Translator: Daniel Schemala <28364@web.de>\n" "Language-Team: Deutsch \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Lokalize 1.0\n" "Plural-Forms: nplurals=2; plural=n != 1;\n" #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14 #. i18n: ectx: property (windowTitle), widget (QWidget, General) #. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17 #. i18n: ectx: property (accessibleName), widget (QWidget, General) #: ../applet/SmoothTasks/Applet.cpp:641 rc.cpp:280 rc.cpp:283 msgid "General" msgstr "Général" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6 #. i18n: ectx: property (windowTitle), widget (QWidget, Appearance) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9 #. i18n: ectx: property (accessibleName), widget (QWidget, Appearance) #: ../applet/SmoothTasks/Applet.cpp:645 rc.cpp:3 rc.cpp:6 msgid "Appearance" msgstr "Apparence" #: ../applet/SmoothTasks/Applet.cpp:649 msgid "Workarounds" msgstr "" #: ../applet/SmoothTasks/Applet.cpp:660 msgid "Do Not Group" msgstr "Ne pas grouper" #: ../applet/SmoothTasks/Applet.cpp:662 msgid "By Program Name" msgstr "Par nom de programme" #: ../applet/SmoothTasks/Applet.cpp:672 msgid "Do Not Sort" msgstr "Ne pas trier" #: ../applet/SmoothTasks/Applet.cpp:673 msgid "Manually" msgstr "Manuellement" #: ../applet/SmoothTasks/Applet.cpp:674 msgid "Alphabetically" msgstr "Par ordre alphabétique" #: ../applet/SmoothTasks/Applet.cpp:675 msgid "By Desktop" msgstr "Par bureau" #: ../applet/SmoothTasks/Applet.cpp:679 msgid "No Action" msgstr "Pas d'action" #: ../applet/SmoothTasks/Applet.cpp:680 msgid "Close Task" msgstr "Fermer la tâche" #: ../applet/SmoothTasks/Applet.cpp:681 msgid "Move to Current Desktop" msgstr "Déplacer vers le bureau courant" #: ../applet/SmoothTasks/Applet.cpp:685 msgid "Rectangle" msgstr "Rectangle" #: ../applet/SmoothTasks/Applet.cpp:686 msgid "Square" msgstr "Carré" #: ../applet/SmoothTasks/Applet.cpp:721 ../applet/SmoothTasks/Applet.cpp:740 msgid "None" msgstr "Rien" #: ../applet/SmoothTasks/Applet.cpp:722 msgid "Smooth" msgstr "Smooth" #: ../applet/SmoothTasks/Applet.cpp:723 msgid "Plasma" msgstr "Plasma" #: ../applet/SmoothTasks/Applet.cpp:727 msgid "By Taskbar Shape" msgstr "Selon la forme de la barre des tâches" #: ../applet/SmoothTasks/Applet.cpp:728 msgid "Maximum Squeeze" msgstr "Réduire au maximum" #: ../applet/SmoothTasks/Applet.cpp:729 msgid "Fixed Item Number per Row" msgstr "Nombre fixe de tâches par ligne" #: ../applet/SmoothTasks/Applet.cpp:730 msgid "Limited Squeeze" msgstr "Réduire à proportion" #: ../applet/SmoothTasks/Applet.cpp:731 msgid "Fixed Maximum Item Height" msgstr "Hauteur maximale des tâches fixe" #: ../applet/SmoothTasks/Applet.cpp:741 msgid "Active" msgstr "Les tâches actives" #: ../applet/SmoothTasks/Applet.cpp:742 msgid "From the current desktop" msgstr "Les tâches du bureau courant" #: ../applet/SmoothTasks/Applet.cpp:743 msgid "All" msgstr "Toutes les tâches" #: ../applet/SmoothTasks/Applet.cpp:749 msgid "Classic" msgstr "Classique" #: ../applet/SmoothTasks/Applet.cpp:750 msgid "New" msgstr "Nouveau" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:81 #: ../applet/SmoothTasks/PlasmaToolTip.cpp:105 #: ../applet/SmoothTasks/Task.cpp:122 #: ../applet/SmoothTasks/WindowPreview.cpp:270 msgid "On all desktops" msgstr "Sur tous les bureaux" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:82 #: ../applet/SmoothTasks/PlasmaToolTip.cpp:108 #: ../applet/SmoothTasks/Task.cpp:123 #: ../applet/SmoothTasks/WindowPreview.cpp:271 msgctxt "Which virtual desktop a window is currently on" msgid "On %1" msgstr "Sur %1" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:107 msgid "On various desktops" msgstr "Sur plusieurs bureaux" #: ../applet/SmoothTasks/PlasmaToolTip.cpp:114 #: ../applet/SmoothTasks/Task.cpp:117 #: ../applet/SmoothTasks/WindowPreview.cpp:268 msgid "Starting application..." msgstr "Démarrage de l'application..." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16 #. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab) #: rc.cpp:9 msgid "Task Items" msgstr "&Tâches" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22 #. i18n: ectx: property (text), widget (QLabel, taskShapeLabel) #: rc.cpp:12 msgid "Task &Shape:" msgstr "&Forme de la tâche:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:38 #. i18n: ectx: property (toolTip), widget (QComboBox, shape) #: rc.cpp:15 msgid "" "

This setting is only effective when there is enough room in the taskbar " "to display the task items in the according shape.

\n" "\n" "

Rectangle

\n" "

Displays collapsed task items as rectangles.

\n" "\n" "

Square

\n" "

Displays collapsed task items as squares.

" msgstr "" "

Cette configuration est effective seulement quand il y a suffisamment de " "place dans la barre pour afficher les tâches avec la forme correspondante.\n" "\n" "

Rectangle

\n" "

Affiche les tâches réduites avec des rectangles.

\n" "\n" "

Carré

\n" "

Affiche les tâches réduites avec des carrés.

" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:45 #. i18n: ectx: property (text), widget (QLabel, spaceLabel) #: rc.cpp:24 msgid "Space &Between Tasks:" msgstr "&Espace entre les tâches:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:55 #. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:79 #. i18n: ectx: property (suffix), widget (QSpinBox, minTextSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:96 #. i18n: ectx: property (suffix), widget (QSpinBox, maxTextSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:216 #. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284 #. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:525 #. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:624 #. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize) #: rc.cpp:27 rc.cpp:36 rc.cpp:42 rc.cpp:76 rc.cpp:88 rc.cpp:156 rc.cpp:190 msgid "px" msgstr "px" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:65 #. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel) #: rc.cpp:30 msgid "minimal icon space:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:72 #. i18n: ectx: property (text), widget (QLabel, minTextSpaceLabel) #: rc.cpp:33 msgid "minimal text space:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:89 #. i18n: ectx: property (text), widget (QLabel, maxTextSpaceLabel) #: rc.cpp:39 msgid "maximal text space:" msgstr "" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:109 #. i18n: ectx: property (text), widget (QLabel, iconScaleLabel) #: rc.cpp:45 msgid "&Icon Scale:" msgstr "Taille de l'&icône:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119 #. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale) #: rc.cpp:48 msgid "" "The scale of the task icons in relation to the height/width (whatever is " "smaller) of the task item." msgstr "" "Echelle des icônes de tâche en fonction de la hauteur/largeur (la plus " "grande des deux) du cadre de la tâche." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122 #. i18n: ectx: property (suffix), widget (QSpinBox, iconScale) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975 #. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal) #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:991 #. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical) #: rc.cpp:52 rc.cpp:273 rc.cpp:277 #, no-c-format msgid "%" msgstr "%" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:138 #. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame) #: rc.cpp:55 msgid "" "For some plasma themes task items might look better when their frames " "are not rotated. This only concerns vertical layouts, e.g. when you place " "the taskbar at the left (or right) screen edge." msgstr "" "Pour quelques thèmes plasma, les tâches ont meilleure apparence quand " "leurs cadres n'ont pas subi de rotation. Cela concerne uniquement les " "dispositions verticales, c'est-à-dire lorsque la barre des tâches est placée " "sur le côté gauche ou droit de l'écran." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:141 #. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame) #: rc.cpp:58 msgid "Don't &Rotate Frames" msgstr "Pas de &rotation des cadres" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:148 #. i18n: ectx: property (text), widget (QCheckBox, textShadow) #: rc.cpp:61 msgid "Draw &Text-Shadow" msgstr "Activer les o&mbres de texte" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:158 #. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks) #: rc.cpp:64 msgid "Switch Tasks using &Wheel" msgstr "C&hanger de tâche avec la molette" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:190 #. i18n: ectx: property (text), widget (QCheckBox, expandTasks) #: rc.cpp:67 msgid "&Expand Tasks" msgstr "&Développer les tâches" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:200 #. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel) #: rc.cpp:70 msgid "E&xpanding Size:" msgstr "Taille du dévelo&ppement:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:213 #. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize) #: rc.cpp:73 msgid "" "This is the additional size that gets added to a task item when it " "expands. Keep in mind that the task items might not be able to expand fully " "when there is not enough room." msgstr "" "Ceci est la largeur additionnelle d'une tâche quand elle se développe. " "Garder à l'esprit qu'une tâche ne peut se développer s'il n'y a pas " "suffisamment d'espace." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:235 #. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel) #: rc.cpp:79 msgid "&Keep Expanded:" msgstr "&Maintenir développées:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:264 #. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention) #: rc.cpp:82 msgid "Expand on &Attention" msgstr "Dével&opper à l'appel d'attention" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274 #. i18n: ectx: property (text), widget (QCheckBox, expandOnHover) #: rc.cpp:85 msgid "Expand on &Hover" msgstr "Déve&lopper au survol" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:298 #. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab) #: rc.cpp:91 msgid "Taskbar Layout" msgstr "Barre des tâches" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:310 #. i18n: ectx: property (text), widget (QLabel, label_2) #: rc.cpp:94 msgid "Row Constraints" msgstr "Contraintes sur les lignes" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:317 #. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel) #: rc.cpp:97 msgid "&Minimum Rows:" msgstr "Nombre &minimum de lignes:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:327 #. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows) #: rc.cpp:100 msgid "" "This defines the minimum row count. Some layouts stretch the filled rows " "in order to fill any empty space. This way the displayed rows might be still " "fewer than this value." msgstr "" "Ceci définit le nombre minimum de lignes. Certaines dispositions étirent " "les lignes non vides afin de remplir l'espace restant. De ce fait, les " "lignes affichées peuvent être moins nombreuses que cette valeur." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:340 #. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel) #: rc.cpp:103 msgid "Ma&ximum Rows:" msgstr "Nombre ma&ximum de lignes:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:350 #. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows) #: rc.cpp:106 msgid "This defines the maximum row count." msgstr "Ceci définit le nombre maximum de lignes." #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:390 #. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel) #: rc.cpp:109 msgid "&Layout:" msgstr "&Disposition:" #. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:423 #. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout) #: rc.cpp:112 msgid "" "

The layout is responsible for the size and placement of the task items.\n" "Each of the provided layouts has other advantages and disadvantages.\n" "Because I can't decide which layouting strategy is best suited for this " "purpose I include several choices for now.

\n" "\n" "

By Taskbar Shape

\n" "

This layout creates as much rows as are needed so that following " "condition is met:

\n" "
row height × row aspect ratio ≤ row width
\n" "

However, if this would yield empty rows the filled rows are scaled in " "height so that the whole task bar space is covered.

\n" "\n" "

Maximum Squeeze

\n" "

Because the width of the task items depends of their height the more rows " "there are the less room the items occupy.\n" "This layout sets the width of the task items always to the width they would " "have when the row count would have reached the maximally allowed value.\n" "\n" "

Fixed Item Number per Row

\n" "

This layout always put the configured number of task items into one row, " "unless there would not be enough room for all task items.\n" "Then the items are distributed evenly over the rows.

\n" "\n" "

Limited Squeeze

\n" "

This layout tries to squeeze the task items only up to a given maximum " "squeeze ratio. If it would have to squeeze them more than that it creates a " "new row. Currently this layout is the only one that respects the “Prefer " "Grouping” setting.

\n" "\n" "

Fixed Maximum Item Height

\n" "

This layout always assumes the configured height of the task items.\n" "Through the dependency between the width and height of the task items this " "leads to a specific distribution of the items.\n" "This layout does not fill empty space by up-scaling the rows.

" msgstr "" "

La Disposition gère la taille et le placement des tâches.\n" "Chaque disposition fournie a ses avantages et inconvénients.\n" "Comme il est difficile de déterminer quelle stratégie de disposition est la " "plus appropriée, plusieurs alternatives sont proposées.

\n" "\n" "

Selon la forme de la barre des tâches

\n" "

Cette disposition crée autant de lignes qu'il est nécessaire pour que la " "condition suivante soit satisfaite:

\n" "
hauteur de ligne × proportion de ligne ≤ largeur de ligne\n"
"
Cependant, si cette valeur génère des lignes vides, les autres lignes "
"sont redimensionnées pour remplir la barre des tâches sur sa hauteur.
\n"
"\n"
"
Réduire au maximum
\n"
"
Parce que la largeur des tâches dépend de leur taille, plus il y a de "
"tâches moins chacune occupe d'espace.\n"
"Cette disposition donne aux tâches la largeur qu'elles auraient si le nombre "
"maximum de tâches par ligne était atteint.
\n"
"\n"
"
Nombre fixe de tâches par ligne
\n"
"
Cette disposition remplit chaque ligne jusqu'à atteindre le nombre de "
"tâches indiqué, sauf il n'y a pas assez de place.\n"
"Dans ce cas, les tâches sont réparties uniformément sur toutes les lignes.\n"
"\n"
"
Réduire à proportion
\n"
"
Cette disposition essaie de compresser les tâches jusqu'à un taux de "
"réduction \n"
"maximum paramétrable. Aller au delà de cette réduction crée une nouvelle "
"ligne. Actuellement, cette disposition est la seule à tenir compte de "
"l'option \n"
"«Préférer le regroupement»
\n"
"\n"
"
Hauteur maximale des tâches fixe
\n"
"
Cette disposition applique toujours la hauteur configurée pour les "
"tâches.\n"
"De par la dépendance entre la largeur et la hauteur d'une tâche, ceci "
"conduit à une distribution spécifique des tâches.\n"
"Cette disposition n'agrandit pas les tâches pour combler les lignes vides."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:448
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:138
msgid "Row &Aspect Ratio:"
msgstr "Pr&oportion d'une ligne:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:461
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:141
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""
"La disposition «Selon la forme de la barre des tâches» utilise cette "
"valeur pour déterminer combien de lignes doivent être créées."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:144
msgid "&Items per Row:"
msgstr "&Tâches par ligne:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:496
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:147
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""
"La disposition «Nombre fixe de tâches par ligne» utilise cette valeur pour "
"remplir la ligne avec des tâches."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:509
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:150
msgid "Maximum Item &Height:"
msgstr "&Hauteur maximale des tâches:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:522
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:153
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the "
"size of the task items."
msgstr ""
"La disposition «Hauteur maximale des tâches fixe» utilise cette valeur pour "
"déterminer la taille des tâches."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:538
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:159
msgid "Maximum &Squeeze Ratio:"
msgstr "Tau&x de réduction maximum:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:551
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:162
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""
"
La disposition «Réduction à proportion» essaie de réduire les tâches en "
"respectant  la condition :largeur de la tâche réduite / largeur initiale "
"de la tâche < taux de réduction maximum.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:573
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:165
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""
"Préférer le regroupement des tâches à la création de nouvelles lignes "
"(Actuellement, uniquement supporté par la disposition «Réduction à "
"proportion»)."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
msgid "&Prefer Grouping"
msgstr "&Préférer le regroupement"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:171
msgid "Tool Tip"
msgstr "Info&bulle"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:174
msgid "Preview St&yle:"
msgstr "St&yle de l'aperçu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:604
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:177
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""
"
Classique
\n"
"
\n"
"\n"
"
Nouveau
\n"
"
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:611
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:184
msgid "Preview Si&ze:"
msgstr "&Taille de l'aperçu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:621
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:187
msgid ""
"This value defines the maximum length of one side of window previews."
msgstr ""
"Selon orientation de la barre des tâches, largeur ou Hauteur maximale des "
"miniatures de fenêtres (aperçus)."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:654
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:193
msgid "Tool Tip &Type:"
msgstr "Ty&pe d'infobulle:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:671
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:196
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""
"
Rien
\n"
"
Ne pas afficher d'infobulle.
\n"
"\n"
"
Smooth
\n"
"
Utiliser les infobulles avancées pour les tâches.\n"
" Ces infobulles montrent des aperçus de fenêtres.\n"
" On peut cliquer sur ces derniers pour activer la fenêtre correspondante.\n"
" De plus, quand vous placez le pointeur de souris sur l'aperçu, il passe en "
"surbrillance.\n"
" Cependant, ce type d'infobulle n'est pas bien intégré à plasma.
\n"
"\n"
"
Plasma
\n"
"
Utiliser les infobulles natives de plasma.\n"
" Ces infobulles ne présentent pas les fonctionnalités décrites plus haut.\n"
" Néanmoins, elles s'intégrent bien aux infobulles d'autres widgets et aux "
"déplacements animés entre widgets.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:785
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:206 rc.cpp:215 rc.cpp:233
msgid "ms"
msgstr "ms"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:706
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:209
msgid "Move &Duration:"
msgstr "Durée de dé&placement de l'infobulle:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:716
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:212
msgid "&Highlight Delay:"
msgstr "Délai de mise en su&rbrillance"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:740
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:218
msgid "Animation"
msgstr "A&nimation"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:746
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:221
msgid "&Frames per Second:"
msgstr "Im&ages par seconde:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:756
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:224
msgid "fps"
msgstr "fps"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:772
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:227
msgid "&Animation Duration:"
msgstr "Durée de l'&Animation:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:782
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:230
msgid ""
"This defines the duration of animations like the expansion of tasks and "
"the delay for which a tool tip will be shown after you stopped hovering the "
"task item or tool tip."
msgstr ""
"Ceci définit la durée des animations comme le développement de tâches et "
"le délai pendant lequel une infobulle sera affichée après que le pointeur de "
"souris cesse d'être sur la tâche."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:801
#. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel)
#: rc.cpp:236
#, fuzzy
msgid "Animation Speed:"
msgstr "A&nimation"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:825
#. i18n: ectx: attribute (title), widget (QWidget, lightsTab)
#: rc.cpp:239
#, fuzzy
msgid "Lights"
msgstr "Retro-éclaira&ge de la tâche"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:843
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:242
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""
"Quand ceci est coché, un éclairage est placé sur la tâche lorsque vous "
"passez dessus ou lorsqu'elle demande votre attention."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:846
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:245
msgid "&Lights"
msgstr "Retro-éclaira&ge de la tâche"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:859
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:248
msgid "&Color:"
msgstr "&Couleur:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:893
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:251
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""
"Quand ceci est coché, la couleur dominante de l'icône de tâche est "
"utilisée comme couleur de rétro-éclairage. Lorsque qu'une couleur grisâtre "
"est ansi extraite, la couleur spécifiée ci-dessus est utilisée à la place."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:896
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:254
msgid "Color From &Icon"
msgstr "Couleur de l'icô&ne"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:257
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""
"Habituellement, un encadrement différent est utilisé pour la tâche "
"lorsque le pointeur de souris la survole. Pour quelques thèmes plasma, la "
"combinaison du changement de cadre avec le rétro-éclairage de la tâche a un "
"mauvais rendu. Cette option désactive l'utilisation d'un cadre différent au "
"survol."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:912
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:260
msgid "As &Only Hover Effect"
msgstr "Comme seul effet du sur&vol"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:925
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:263
msgid "Anchor Light:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:955
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled)
#: rc.cpp:266
msgid "Anchor horizontally at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:965
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled)
#: rc.cpp:269
msgid "Anchor vertically at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:286
msgid "Grouping & Sorting"
msgstr "Tri et regroupement"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:289
msgid "&Grouping:"
msgstr "&Grouper:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:292
msgid "Only when the taskbar is &full"
msgstr ""
"Uniquement si la barre des tâches \n"
" est &pleine"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:295
msgid "&Sorting:"
msgstr "T&rier:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:298
msgid "Filters"
msgstr "Filtres"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:301
msgid "Only show tasks that are &minimized"
msgstr "Montrer seulement les tâches &minimisées"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:304
msgid "Only show tasks from the current &desktop"
msgstr "Montrer seulement les tâches du &bureau courant"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:307
msgid "Only show tasks from the current s&creen"
msgstr "Montrer seulement les tâches de l'é&cran courant"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:310
msgid "Middle Click &Action:"
msgstr "Action sur clic milieu de la so&uris:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:313
msgid "Action that should be performed when a task item is middle clicked."
msgstr ""
"Action effectuée lorsqu'on clique sur une tâche avec le bouton du milieu de "
"la souris."

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds)
#: rc.cpp:316
msgid "Form"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:319
msgid ""
"The margin sizes for task bar buttons are not designed for having a light "
"effect in the middle of a button. If the light effect looks strange you can "
"define custom button margins for the light here."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36
#. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom)
#: rc.cpp:322
msgid "enable custom margin sizes"
msgstr ""

#: rc.cpp:323
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Sergio Guibert"

#: rc.cpp:324
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "sergio.guibert@gmail.com"
plasma-widget-smooth-tasks/po/uk_UA.po000644 000765 000765 00000106121 11724514472 020564 0ustar00salvosalvo000000 000000 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
#
# Oleksandr Natalenko , 2009.
# Daniel Schemala <28364@web.de>, 2010.
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n"
"POT-Creation-Date: 2010-01-12 22:42+0100\n"
"PO-Revision-Date: 2010-01-12 22:02+0100\n"
"Last-Translator: Daniel Schemala <28364@web.de>\n"
"Language-Team: Deutsch \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 1.0\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%"
"10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, General)
#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, General)
#: ../applet/SmoothTasks/Applet.cpp:641 rc.cpp:280 rc.cpp:283
msgid "General"
msgstr "Загальне"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6
#. i18n: ectx: property (windowTitle), widget (QWidget, Appearance)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9
#. i18n: ectx: property (accessibleName), widget (QWidget, Appearance)
#: ../applet/SmoothTasks/Applet.cpp:645 rc.cpp:3 rc.cpp:6
msgid "Appearance"
msgstr "Вигляд"

#: ../applet/SmoothTasks/Applet.cpp:649
msgid "Workarounds"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:660
msgid "Do Not Group"
msgstr "Не групувати"

#: ../applet/SmoothTasks/Applet.cpp:662
msgid "By Program Name"
msgstr "За іменем програми"

#: ../applet/SmoothTasks/Applet.cpp:672
msgid "Do Not Sort"
msgstr "Не сортувати"

#: ../applet/SmoothTasks/Applet.cpp:673
msgid "Manually"
msgstr "Вручну"

#: ../applet/SmoothTasks/Applet.cpp:674
msgid "Alphabetically"
msgstr "За алфавітом"

#: ../applet/SmoothTasks/Applet.cpp:675
msgid "By Desktop"
msgstr "За робочими столами"

#: ../applet/SmoothTasks/Applet.cpp:679
msgid "No Action"
msgstr "Без дії"

#: ../applet/SmoothTasks/Applet.cpp:680
msgid "Close Task"
msgstr "Закрити задачу"

#: ../applet/SmoothTasks/Applet.cpp:681
msgid "Move to Current Desktop"
msgstr "Перемістити на поточний робочий стіл"

#: ../applet/SmoothTasks/Applet.cpp:685
msgid "Rectangle"
msgstr "Прямокутник"

#: ../applet/SmoothTasks/Applet.cpp:686
msgid "Square"
msgstr "Квадрат"

#: ../applet/SmoothTasks/Applet.cpp:721 ../applet/SmoothTasks/Applet.cpp:740
msgid "None"
msgstr "Немає"

#: ../applet/SmoothTasks/Applet.cpp:722
msgid "Smooth"
msgstr "Плавний"

#: ../applet/SmoothTasks/Applet.cpp:723
msgid "Plasma"
msgstr "Плазма"

#: ../applet/SmoothTasks/Applet.cpp:727
msgid "By Taskbar Shape"
msgstr "За формою панелі задач"

#: ../applet/SmoothTasks/Applet.cpp:728
msgid "Maximum Squeeze"
msgstr "Максимальне стиснення"

#: ../applet/SmoothTasks/Applet.cpp:729
msgid "Fixed Item Number per Row"
msgstr "Фіксована кількість елементів на рядок"

#: ../applet/SmoothTasks/Applet.cpp:730
msgid "Limited Squeeze"
msgstr "Обмежене стиснення"

#: ../applet/SmoothTasks/Applet.cpp:731
msgid "Fixed Maximum Item Height"
msgstr "Фіксована максимальна висота елементу"

#: ../applet/SmoothTasks/Applet.cpp:741
msgid "Active"
msgstr "Активний"

#: ../applet/SmoothTasks/Applet.cpp:742
msgid "From the current desktop"
msgstr "Із поточного робочого столу"

#: ../applet/SmoothTasks/Applet.cpp:743
msgid "All"
msgstr "Усі"

#: ../applet/SmoothTasks/Applet.cpp:749
msgid "Classic"
msgstr "Класичний"

#: ../applet/SmoothTasks/Applet.cpp:750
msgid "New"
msgstr "Новий"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:81
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:105
#: ../applet/SmoothTasks/Task.cpp:122
#: ../applet/SmoothTasks/WindowPreview.cpp:270
msgid "On all desktops"
msgstr "На всіх робочих столах"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:82
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:108
#: ../applet/SmoothTasks/Task.cpp:123
#: ../applet/SmoothTasks/WindowPreview.cpp:271
msgctxt "Which virtual desktop a window is currently on"
msgid "On %1"
msgstr "На %1"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:107
msgid "On various desktops"
msgstr "На різних робочих столах"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:114
#: ../applet/SmoothTasks/Task.cpp:117
#: ../applet/SmoothTasks/WindowPreview.cpp:268
msgid "Starting application..."
msgstr "Запуск програми…"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16
#. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab)
#: rc.cpp:9
msgid "Task Items"
msgstr "Задачі"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22
#. i18n: ectx: property (text), widget (QLabel, taskShapeLabel)
#: rc.cpp:12
msgid "Task &Shape:"
msgstr "Форма задачі:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:38
#. i18n: ectx: property (toolTip), widget (QComboBox, shape)
#: rc.cpp:15
msgid ""
"
This setting is only effective when there is enough room in the taskbar "
"to display the task items in the according shape.
\n"
"\n"
"
Rectangle
\n"
"
Displays collapsed task items as rectangles.
\n"
"\n"
"
Square
\n"
"
Displays collapsed task items as squares.
"
msgstr ""
"
Ці налаштування ефективні лише тоді, коли достатньо простору на панелі "
"задач для відображення задач у відповідній формі.
\n"
"\n"
"
Прямокутник
\n"
"
Показує згорнуті задачі як прямокутники.
\n"
"\n"
"
Квадрат
\n"
"
Показує згорнуті задачі як квадрати.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:45
#. i18n: ectx: property (text), widget (QLabel, spaceLabel)
#: rc.cpp:24
msgid "Space &Between Tasks:"
msgstr "Простір між задачами:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:55
#. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:79
#. i18n: ectx: property (suffix), widget (QSpinBox, minTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:96
#. i18n: ectx: property (suffix), widget (QSpinBox, maxTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:216
#. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284
#. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:525
#. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:624
#. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:27 rc.cpp:36 rc.cpp:42 rc.cpp:76 rc.cpp:88 rc.cpp:156 rc.cpp:190
msgid "px"
msgstr "пікс"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:65
#. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel)
#: rc.cpp:30
msgid "minimal icon space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:72
#. i18n: ectx: property (text), widget (QLabel, minTextSpaceLabel)
#: rc.cpp:33
msgid "minimal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:89
#. i18n: ectx: property (text), widget (QLabel, maxTextSpaceLabel)
#: rc.cpp:39
msgid "maximal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:109
#. i18n: ectx: property (text), widget (QLabel, iconScaleLabel)
#: rc.cpp:45
msgid "&Icon Scale:"
msgstr "Масштаб піктограми:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119
#. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale)
#: rc.cpp:48
msgid ""
"The scale of the task icons in relation to the height/width (whatever is "
"smaller) of the task item."
msgstr ""
"Масштаб піктограми задачі відносно висоти/ширини (залежно від того, що "
"менше) елементу задачі."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122
#. i18n: ectx: property (suffix), widget (QSpinBox, iconScale)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:991
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical)
#: rc.cpp:52 rc.cpp:273 rc.cpp:277
#, no-c-format
msgid "%"
msgstr "%"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:138
#. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:55
msgid ""
"For some plasma themes task items might look better when their frames "
"are not rotated. This only concerns vertical layouts, e.g. when you place "
"the taskbar at the left (or right) screen edge."
msgstr ""
"Для деяких тем Плазми задачі можуть виглядати краще, коли їх кадри не "
"повернуті. Це стосується лише вертикальних схем, наприклад, коли ви "
"поміщуєте панель задач на лівий (чи правий) край екрану."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:141
#. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:58
msgid "Don't &Rotate Frames"
msgstr "Не повертати кадри"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:148
#. i18n: ectx: property (text), widget (QCheckBox, textShadow)
#: rc.cpp:61
msgid "Draw &Text-Shadow"
msgstr "Малювати тінь тексту"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:158
#. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks)
#: rc.cpp:64
msgid "Switch Tasks using &Wheel"
msgstr "Перемикати задачі колесом"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:190
#. i18n: ectx: property (text), widget (QCheckBox, expandTasks)
#: rc.cpp:67
msgid "&Expand Tasks"
msgstr "Розгортати задачі"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:200
#. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel)
#: rc.cpp:70
msgid "E&xpanding Size:"
msgstr "Розмір розгортання:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:213
#. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize)
#: rc.cpp:73
msgid ""
"This is the additional size that gets added to a task item when it "
"expands. Keep in mind that the task items might not be able to expand fully "
"when there is not enough room."
msgstr ""
"Це додатковий розмір, який додається до елементу задачі при розгортанні. "
"Пам’ятайте, що елементи задачі можуть бути нездатними повністю розгорнутися, "
"коли місця недостатньо."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:235
#. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel)
#: rc.cpp:79
msgid "&Keep Expanded:"
msgstr "Тримати розгорнутим:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:264
#. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention)
#: rc.cpp:82
msgid "Expand on &Attention"
msgstr "Розгортати при потребі уваги"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274
#. i18n: ectx: property (text), widget (QCheckBox, expandOnHover)
#: rc.cpp:85
msgid "Expand on &Hover"
msgstr "Розгортати під мишкою"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:298
#. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab)
#: rc.cpp:91
msgid "Taskbar Layout"
msgstr "Схема панелі задач"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:310
#. i18n: ectx: property (text), widget (QLabel, label_2)
#: rc.cpp:94
msgid "Row Constraints"
msgstr "Обмеження рядку"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:317
#. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel)
#: rc.cpp:97
msgid "&Minimum Rows:"
msgstr "Мінімум рядків:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:327
#. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows)
#: rc.cpp:100
msgid ""
"This defines the minimum row count. Some layouts stretch the filled rows "
"in order to fill any empty space. This way the displayed rows might be still "
"fewer than this value."
msgstr ""
"Це задає мінімальну кількість рядків. За деякими схемами заповнені рядки "
"розтягуються для заповнення вільного простору. Тому відображуваних рядків "
"може бути менше за це значення."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:340
#. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel)
#: rc.cpp:103
msgid "Ma&ximum Rows:"
msgstr "Максимум рядків:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:350
#. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows)
#: rc.cpp:106
msgid "This defines the maximum row count."
msgstr "Це визначає максимальну кількість рядків."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:390
#. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel)
#: rc.cpp:109
msgid "&Layout:"
msgstr "Схема:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:423
#. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout)
#: rc.cpp:112
msgid ""
"
The layout is responsible for the size and placement of the task items.\n"
"Each of the provided layouts has other advantages and disadvantages.\n"
"Because I can't decide which layouting strategy is best suited for this "
"purpose I include several choices for now.
\n"
"\n"
"
By Taskbar Shape
\n"
"
This layout creates as much rows as are needed so that following "
"condition is met:
\n"
"
row height × row aspect ratio ≤ row width
\n"
"
However, if this would yield empty rows the filled rows are scaled in "
"height so that the whole task bar space is covered.
\n"
"\n"
"
Maximum Squeeze
\n"
"
Because the width of the task items depends of their height the more rows "
"there are the less room the items occupy.\n"
"This layout sets the width of the task items always to the width they would "
"have when the row count would have reached the maximally allowed value.\n"
"\n"
"
Fixed Item Number per Row
\n"
"
This layout always put the configured number of task items into one row, "
"unless there would not be enough room for all task items.\n"
"Then the items are distributed evenly over the rows.
\n"
"\n"
"
Limited Squeeze
\n"
"
This layout tries to squeeze the task items only up to a given maximum "
"squeeze ratio. If it would have to squeeze them more than that it creates a "
"new row. Currently this layout is the only one that respects the “Prefer "
"Grouping” setting.
\n"
"\n"
"
Fixed Maximum Item Height
\n"
"
This layout always assumes the configured height of the task items.\n"
"Through the dependency between the width and height of the task items this "
"leads to a specific distribution of the items.\n"
"This layout does not fill empty space by up-scaling the rows.
"
msgstr ""
"
Схема відповідає за розмір та розміщення елементів задач.\n"
"Кожна схема має свої переваги та недоліки.\n"
"Оскільки неможливо вирішити, яка схема краще підходить для цієї цілі, "
"можливий вибір із декількох варіантів.
\n"
"\n"
"
За формою панелі задач
\n"
"
За цією схемою створюється стільки рядків, скільки необхідно, "
"задовольняючи наступні умови:
\n"
"
висота рядка × співвідношення сторін рядка ≤ ширина рядка\n"
"
Однак це віддасть пусті рядки, а заповнені змасштабуються по висоті, тому "
"весь простір панелі задач буде покритий.
\n"
"\n"
"
Максимальне стиснення
\n"
"
Оскільки ширина елементів задач залежить від їх висоти, то чим більше "
"рядків, тим менше простору займають елементи.\n"
"Ця схема встановлює ширину елементів задач такою, яку б вони мали, коли "
"кількість досягла б максимально дозволеного значення.\n"
"\n"
"
Фіксована кількість елементів на рядок
\n"
"
Ця схема завжди вміщує задану кількість елементів до одного рядка, поки "
"не вистачить простору для усіх елементів задач.\n"
"Тоді елементи рівномірно розподіляються по рядках.
\n"
"\n"
"
Обмежене стиснення
\n"
"
За цією схемою елементи задач стискуються до максимального коефіцієнту "
"стиснення. Якщо необхідно їх стиснути більше, то створюється новий рядок. "
"Наразі це єдина схема, яка враховує установку «Надавати перевагу групуванню»."
"
\n"
"\n"
"
Фіксована максимальна висота елемента
\n"
"
За цією схемою елементи задачі завжди мають визначену висоту.\n"
"Через залежність між шириною та висотою елементів задач це призводить до "
"специфічного розподілу елементів.\n"
"За цією схемою заповнення вільного простору масштабуванням рядків не "
"відбувається.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:448
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:138
msgid "Row &Aspect Ratio:"
msgstr "Співвідношення сторін рядка:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:461
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:141
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""
"Схема «За формою панелі задач» використовує це значення для визначення, "
"скільки рядків повинно бути створено."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:144
msgid "&Items per Row:"
msgstr "Елементів на рядок:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:496
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:147
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""
"Схема «Фіксована кількість елементів на рядок» використовує цю кількість для "
"заповнення рядків задачами."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:509
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:150
msgid "Maximum Item &Height:"
msgstr "Максимальна висота елемента:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:522
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:153
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the "
"size of the task items."
msgstr ""
"Схема «Фіксована максимальна висота елемента» використовує це значення для "
"визначення розміру елементів задач."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:538
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:159
msgid "Maximum &Squeeze Ratio:"
msgstr "Максимальний коефіцієнт стиснення:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:551
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:162
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""
"
Схема «Обмежене стиснення» намагається не стискати елементи, у яких "
"співвідношення ширина / висота ≥ максимальний коефіцієнт стиснення.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:573
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:165
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""
"Надавати перевагу групуванню задач, а не створенню нових рядків (наразі "
"підтримується лише у схемі «Обмежене стиснення»)."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
msgid "&Prefer Grouping"
msgstr "Надавати перевагу групуванню"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:171
msgid "Tool Tip"
msgstr "Спливаюче вікно"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:174
msgid "Preview St&yle:"
msgstr "Стиль попереднього перегляду:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:604
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:177
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""
"
Класичний
\n"
"
\n"
"\n"
"
Новий
\n"
"
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:611
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:184
msgid "Preview Si&ze:"
msgstr "Розмір попереднього перегляду:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:621
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:187
msgid ""
"This value defines the maximum length of one side of window previews."
msgstr ""
"Це значення визначає максимальну довжину однієї сторони вікна попереднього "
"перегляду."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:654
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:193
msgid "Tool Tip &Type:"
msgstr "Тип спливаючого вікна:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:671
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:196
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""
"
Немає
\n"
"
Не відображувати спливаючі вікна.
\n"
"\n"
"
Згладжений
\n"
"
Використовувати просунуте спливаюче вікно для задач. Ці спливаючі вікна "
"показують попередній перегляд вікон, на який можна натиснути для активації "
"відповідного вікна. Коли курсор миші знаходиться над таким вікном, вікно "
"підсвічується. Однак, такий тип спливаючого вікна не надто добре "
"інтегрований до Плазми.
\n"
"\n"
"
Плазма
\n"
"
Використовувати спливаючі вікна Плазми. Цей вид спливаючих вікон не дає "
"можливостей, описаних вище. Замість того, вони добре інтегруються із "
"спливаючими вікнами інших апплетів та рухаються між апплетами із анімацією."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:785
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:206 rc.cpp:215 rc.cpp:233
msgid "ms"
msgstr "мс"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:706
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:209
msgid "Move &Duration:"
msgstr "Тривалість переміщення:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:716
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:212
msgid "&Highlight Delay:"
msgstr "Затримка підсвітки:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:740
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:218
msgid "Animation"
msgstr "Анімація"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:746
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:221
msgid "&Frames per Second:"
msgstr "Кадрів на секунду:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:756
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:224
msgid "fps"
msgstr "к/с"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:772
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:227
msgid "&Animation Duration:"
msgstr "Тривалість анімації:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:782
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:230
msgid ""
"This defines the duration of animations like the expansion of tasks and "
"the delay for which a tool tip will be shown after you stopped hovering the "
"task item or tool tip."
msgstr ""
"Це визначає тривалість анімації типу розгортання задач та час, протягом "
"якого буде показуватись спливаюче вікно після того, як курсор миші полишить "
"це вікно чи елемент задачі."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:801
#. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel)
#: rc.cpp:236
#, fuzzy
msgid "Animation Speed:"
msgstr "Анімація"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:825
#. i18n: ectx: attribute (title), widget (QWidget, lightsTab)
#: rc.cpp:239
#, fuzzy
msgid "Lights"
msgstr "Світло"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:843
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:242
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""
"Коли це відмічено, світлова пляма промальовується на задачах, коли курсор "
"миші знаходиться над ними або коли вони вимагають уваги."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:846
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:245
msgid "&Lights"
msgstr "Світло"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:859
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:248
msgid "&Color:"
msgstr "Колір:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:893
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:251
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""
"Коли це відмічено, домінуючий колір піктограми задачі використовується як "
"колір світла. Коли використовується тільки негарний колір, використовується "
"колір, зазначений вище."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:896
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:254
msgid "Color From &Icon"
msgstr "Колір із піктограми"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:257
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""
"Зазвичай, використовується інший кадр підсвіченої задачі. Але для деяких тем "
"Плазми це може виглядати негарно у комбінації зі світловим ефектом. "
"Використовуючи цей параметр, ви можете вимкнути використання іншого кадру "
"підсвіченої задачі."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:912
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:260
msgid "As &Only Hover Effect"
msgstr "Як тільки ефект підсвітки"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:925
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:263
msgid "Anchor Light:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:955
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled)
#: rc.cpp:266
msgid "Anchor horizontally at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:965
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled)
#: rc.cpp:269
msgid "Anchor vertically at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:286
msgid "Grouping & Sorting"
msgstr "Групування та сортування"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:289
msgid "&Grouping:"
msgstr "Групування:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:292
msgid "Only when the taskbar is &full"
msgstr "Лише тоді, коли панель задач заповнена"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:295
msgid "&Sorting:"
msgstr "Сортування:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:298
msgid "Filters"
msgstr "Фільтри"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:301
msgid "Only show tasks that are &minimized"
msgstr "Показувати лише мінімізовані задачі"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:304
msgid "Only show tasks from the current &desktop"
msgstr "Показувати лише задачі із поточного робочого столу"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:307
msgid "Only show tasks from the current s&creen"
msgstr "Показувати лише задачі із поточного екрану"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:310
msgid "Middle Click &Action:"
msgstr "Дія при натисненні середньої кнопки:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:313
msgid "Action that should be performed when a task item is middle clicked."
msgstr ""
"Дія, яка буде виконана, коли на елемент задачі натиснути середньою кнопкою "
"миші."

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds)
#: rc.cpp:316
msgid "Form"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:319
msgid ""
"The margin sizes for task bar buttons are not designed for having a light "
"effect in the middle of a button. If the light effect looks strange you can "
"define custom button margins for the light here."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36
#. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom)
#: rc.cpp:322
msgid "enable custom margin sizes"
msgstr ""

#: rc.cpp:323
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Олександр Ігорович Наталенко"

#: rc.cpp:324
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "pfactum@gmail.com"
plasma-widget-smooth-tasks/po/CMakeLists.txt000644 000765 000765 00000001517 11724514472 021763 0ustar00salvosalvo000000 000000 find_program(GETTEXT_MSGFMT_EXECUTABLE msgfmt)
 
if(NOT GETTEXT_MSGFMT_EXECUTABLE)
	message(
"------
                 NOTE: msgfmt not found. Translations will *not* be installed
------")
else(NOT GETTEXT_MSGFMT_EXECUTABLE)

	set(catalogname plasma_applet_smooth-tasks)
	add_custom_target(translations ALL)
	
	file(GLOB PO_FILES
		*.po
	)

	foreach(_poFile ${PO_FILES})
		get_filename_component(_lang ${_poFile} NAME_WE)
		set(_gmoFile ${CMAKE_CURRENT_BINARY_DIR}/${_lang}.gmo)
		add_custom_command(TARGET translations
			COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --check -o ${_gmoFile} ${_poFile}
			WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
			DEPENDS ${_poFile})

		install(FILES ${_gmoFile}
			DESTINATION share/locale/${_lang}/LC_MESSAGES/
			RENAME ${catalogname}.mo)
	endforeach(_poFile ${PO_FILES})
 
endif(NOT GETTEXT_MSGFMT_EXECUTABLE)
plasma-widget-smooth-tasks/po/tr.po000644 000765 000765 00000060675 11724514472 020222 0ustar00salvosalvo000000 000000 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
#
# Anıl Özbek, 2011.
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n"
"POT-Creation-Date: 2011-02-04 16:58+0200\n"
"PO-Revision-Date: 2011-02-04 19:19+0200\n"
"Last-Translator: Anıl Özbek\n"
"Language-Team: Turkish \n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 1.1\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
"n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, General)
#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, General)
#: ../applet/SmoothTasks/Applet.cpp:658 rc.cpp:239 rc.cpp:242
msgid "General"
msgstr "Genel"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Appearance)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, Appearance)
#: ../applet/SmoothTasks/Applet.cpp:662 rc.cpp:3 rc.cpp:6
msgid "Appearance"
msgstr "Görünüm"

#: ../applet/SmoothTasks/Applet.cpp:673
msgid "Do Not Group"
msgstr "Gruplama"

#: ../applet/SmoothTasks/Applet.cpp:675
msgid "By Program Name"
msgstr "Program İsmine Göre"

#: ../applet/SmoothTasks/Applet.cpp:685
msgid "Do Not Sort"
msgstr "Sıralama"

#: ../applet/SmoothTasks/Applet.cpp:686
msgid "Manually"
msgstr "Elle"

#: ../applet/SmoothTasks/Applet.cpp:687
msgid "Alphabetically"
msgstr "Alfabetik"

#: ../applet/SmoothTasks/Applet.cpp:688
msgid "By Desktop"
msgstr "Masaüstüne Göre"

#: ../applet/SmoothTasks/Applet.cpp:692
msgid "No Action"
msgstr "Hareket Yok"

#: ../applet/SmoothTasks/Applet.cpp:693
msgid "Close Task"
msgstr "Görevi Kapat"

#: ../applet/SmoothTasks/Applet.cpp:694
msgid "Move to Current Desktop"
msgstr "Aktif Masaüstüne Taşı"

#: ../applet/SmoothTasks/Applet.cpp:698
msgid "Rectangle"
msgstr "Dikdörtgen"

#: ../applet/SmoothTasks/Applet.cpp:699
msgid "Square"
msgstr "Kare"

#: ../applet/SmoothTasks/Applet.cpp:724 ../applet/SmoothTasks/Applet.cpp:743
msgid "None"
msgstr "Hiçbiri"

#: ../applet/SmoothTasks/Applet.cpp:725
msgid "Smooth"
msgstr "Pürüzsüz"

#: ../applet/SmoothTasks/Applet.cpp:726
msgid "Plasma"
msgstr "Plasma"

#: ../applet/SmoothTasks/Applet.cpp:730
msgid "By Taskbar Shape"
msgstr "Görev Çubuğu Şekline Göre"

#: ../applet/SmoothTasks/Applet.cpp:731
msgid "Maximum Squeeze"
msgstr "Maksimum Sıklık"

#: ../applet/SmoothTasks/Applet.cpp:732
msgid "Fixed Item Number per Row"
msgstr "Satır Başına Sabit Öğe Sayısı"

#: ../applet/SmoothTasks/Applet.cpp:733
msgid "Limited Squeeze"
msgstr "Sınırlı Sıklık"

#: ../applet/SmoothTasks/Applet.cpp:734
msgid "Fixed Maximum Item Height"
msgstr "Sabit Maksimum Öğe Yüksekliği"

#: ../applet/SmoothTasks/Applet.cpp:744
msgid "Active"
msgstr "Aktif"

#: ../applet/SmoothTasks/Applet.cpp:745
msgid "From the current desktop"
msgstr "Aktif masaüstünden "

#: ../applet/SmoothTasks/Applet.cpp:746
msgid "All"
msgstr "Hepsi"

#: ../applet/SmoothTasks/Applet.cpp:752
msgid "Classic"
msgstr "Klasik"

#: ../applet/SmoothTasks/Applet.cpp:753
msgid "New"
msgstr "Yeni"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:106
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:130
#: ../applet/SmoothTasks/Task.cpp:157
#: ../applet/SmoothTasks/WindowPreview.cpp:271
msgid "On all desktops"
msgstr "Tüm masaüstlerinde"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:107
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:133
#: ../applet/SmoothTasks/Task.cpp:158
#: ../applet/SmoothTasks/WindowPreview.cpp:272
msgctxt "Which virtual desktop a window is currently on"
msgid "On %1"
msgstr "%1 üzerinde"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:132
msgid "On various desktops"
msgstr "Çeşitli masaüstleri üzerinde"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:139
#: ../applet/SmoothTasks/Task.cpp:152
#: ../applet/SmoothTasks/WindowPreview.cpp:269
msgid "Starting application..."
msgstr "Uygulama başlatılıyor..."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:27
#. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab)
#: rc.cpp:9
msgid "Task Items"
msgstr "Görev Öğeleri"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:48
#. i18n: ectx: property (text), widget (QLabel, taskShapeLabel)
#: rc.cpp:12
msgid "Task &Shape:"
msgstr "Görev &Şekli:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:70
#. i18n: ectx: property (toolTip), widget (QComboBox, shape)
#: rc.cpp:15
msgid ""
"
This setting is only effective when there is enough room in the taskbar "
"to display the task items in the according shape.
\n"
"\n"
"
Rectangle
\n"
"
Displays collapsed task items as rectangles.
\n"
"\n"
"
Square
\n"
"
Displays collapsed task items as squares.
"
msgstr ""
"
Bu ayar yalnızca görev çubuğunda görev öğelerini şekle göre "
"gösterecek kadar yeterli yer kalmadığında etkili olacaktır.
\n"
"\n"
"
Dikdörtgen
\n"
"
Daraltılmış görev öğelerini dikdörtgenler şeklinde gösterir.
\n"
"\n"
"
Kate
\n"
"
Daraltılmış görev öğelerini kare şeklinde gösterir.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:77
#. i18n: ectx: property (text), widget (QLabel, spaceLabel)
#: rc.cpp:24
msgid "Space &Between Tasks:"
msgstr "Görevler Arasında &Boşluk:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:93
#. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:195
#. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:667
#. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:790
#. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:27 rc.cpp:49 rc.cpp:159 rc.cpp:193
msgid "px"
msgstr "piksel"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:103
#. i18n: ectx: property (text), widget (QLabel, iconScaleLabel)
#: rc.cpp:30
msgid "&Icon Scale:"
msgstr "S&imge Ölçekleme:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119
#. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale)
#: rc.cpp:33
msgid ""
"The scale of the task icons in relation to the height/width (whatever is "
"smaller) of the task item."
msgstr ""
"Görev simgesinin yükseklik / genişlik (hangisi daha küçükse) "
"oranında ölçeklenmesi."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122
#. i18n: ectx: property (suffix), widget (QSpinBox, iconScale)
#: rc.cpp:37
#, no-c-format
msgid "%"
msgstr "%"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:166
#. i18n: ectx: property (text), widget (QCheckBox, expandTasks)
#: rc.cpp:40
msgid "&Expand Tasks"
msgstr "Görevi G&enişlet"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:176
#. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel)
#: rc.cpp:43
msgid "E&xpanding Size:"
msgstr "%Genişleme Boyu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:192
#. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize)
#: rc.cpp:46
msgid ""
"This is the additional size that gets added to a task item when it expands. "
"Keep in mind that the task items might not be able to expand fully when "
"there is not enough room."
msgstr ""
"Bu bir görev öğesine genişletildiği zaman eklenecek boyuttur. "
"Gerekli boş alan yoksa görev öğelerinin tam olarak genişletilemeyeceğini "
"aklınızda bulundurun."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:214
#. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel)
#: rc.cpp:52
msgid "&Keep Expanded:"
msgstr "Ge&nişlemiş Tut:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:55
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""
"Bu işaretlendiğinde görev öğesinin üzerinde dolaşılırken veya görevler ilgi "
"isterken "
"bir ışık damlası çizilecektir."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:277
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:58
msgid "&Lights"
msgstr "&Işıklar"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:308
#. i18n: ectx: property (text), widget (QCheckBox, expandOnHover)
#: rc.cpp:61
msgid "Expand on &Hover"
msgstr "&Üstündeyken Genişlet"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:318
#. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:64
msgid ""
"For some plasma themes task items might look better when their frames are "
"not rotated. This only concerns vertical layouts, e.g. when you place the "
"taskbar at the left (or right) screen edge."
msgstr ""
"Bazı plasma temalarında görev öğeleri, kareleri döndürülmediğinde daha güzel "
"görüntülenebilmektedir. Bu yalnızca dikey yerleşimleri ilgilendiren bir "
"konudur,  "
"örneğin görev çuvuğu sol veya sağ köşedeyken."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:321
#. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:67
msgid "Don't &Rotate Frames"
msgstr "Kareleri &Döndürme"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:331
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:70
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""
"Genellikle üstüne gelinen görev öğesi için farklı bir kare kullanılır. Fakat "
"bu, bazı plasma temalarında ışık efekti ile birleştiğinde çirkin görünebilir."
" "
"Bu seçeneği kullanarak görev öğesi üzerine gelindiğinde farklı kare "
"kullanımını engelleyebilirsiniz."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:334
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:73
msgid "As &Only Hover Effect"
msgstr "Yalnızca &Üste Gelim Efekti Olarak"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:344
#. i18n: ectx: property (text), widget (QCheckBox, textShadow)
#: rc.cpp:76
msgid "Draw &Text-Shadow"
msgstr "Metin-Gölgelerini &Çiz"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:357
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:79
#, fuzzy
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""
"Bu seçenek işaretlendiğinde görev simgesinin baskın rengi ışık rengi "
"olarak kullanılacaktır."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:360
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:82
msgid "Color From &Icon"
msgstr "Simgeden Ren&k"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:373
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:85
msgid "&Color:"
msgstr "&Renk:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:383
#. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks)
#: rc.cpp:88
msgid "Switch Tasks using &Wheel"
msgstr "Görevleri &Fare Tekerleğiyle Değiştir"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:396
#. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention)
#: rc.cpp:91
msgid "Expand on &Attention"
msgstr "&ilgi Çektiğinde Genişlet"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:404
#. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab)
#: rc.cpp:94
msgid "Taskbar Layout"
msgstr "Görev Çubuğu Yerleşimi"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:431
#. i18n: ectx: property (text), widget (QLabel, label_2)
#: rc.cpp:97
msgid "Row Constraints"
msgstr "Satır Kısıtlamaları"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:438
#. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel)
#: rc.cpp:100
msgid "&Minimum Rows:"
msgstr "&Minimum Satır:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:454
#. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows)
#: rc.cpp:103
msgid ""
"This defines the minimum row count. Some layouts stretch the filled rows in "
"order to fill any empty space. This way the displayed rows might be still "
"fewer than this value."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:467
#. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel)
#: rc.cpp:106
msgid "Ma&ximum Rows:"
msgstr "Maksimum &Satır:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows)
#: rc.cpp:109
msgid "This defines the maximum row count."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:523
#. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel)
#: rc.cpp:112
msgid "&Layout:"
msgstr "&Yerleşim:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:559
#. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout)
#: rc.cpp:115
msgid ""
"
The layout is responsible for the size and placement of the task items.\n"
"Each of the provided layouts has other advantages and disadvantages.\n"
"Because I can't decide which layouting strategy is best suited for this "
"purpose I include several choices for now.
\n"
"\n"
"
By Taskbar Shape
\n"
"
This layout creates as much rows as are needed so that following "
"condition is met:
\n"
"
row height × row aspect ratio ≤ row width
\n"
"
However, if this would yield empty rows the filled rows are scaled in "
"height so that the whole task bar space is covered.
\n"
"\n"
"
Maximum Squeeze
\n"
"
Because the width of the task items depends of their height the more rows "
"there are the less room the items occupy.\n"
"This layout sets the width of the task items always to the width they would "
"have when the row count would have reached the maximally allowed value.\n"
"\n"
"
Fixed Item Number per Row
\n"
"
This layout always put the configured number of task items into one row, "
"unless there would not be enough room for all task items.\n"
"Then the items are distributed evenly over the rows.
\n"
"\n"
"
Limited Squeeze
\n"
"
This layout tries to squeeze the task items only up to a given maximum "
"squeeze ratio. If it would have to squeeze them more than that it creates a "
"new row. Currently this layout is the only one that respects the “Prefer "
"Grouping” setting.
\n"
"\n"
"
Fixed Maximum Item Height
\n"
"
This layout always assumes the configured height of the task items.\n"
"Through the dependency between the width and height of the task items this "
"leads to a specific distribution of the items.\n"
"This layout does not fill empty space by up-scaling the rows.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:141
msgid "Row &Aspect Ratio:"
msgstr "Satır &Görüntü Oranı:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:597
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:144
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:619
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:147
msgid "&Items per Row:"
msgstr "Satır başına &Öğe:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:635
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:150
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:648
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:153
msgid "Maximum Item &Height:"
msgstr "Maksimum Öğe &Genişliği:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:664
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:156
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the size "
"of the task items."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:680
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:162
msgid "Maximum &Squeeze Ratio:"
msgstr "Maksimum &Sıklık Oranı:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:165
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:715
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:718
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:171
msgid "&Prefer Grouping"
msgstr "Gruplamayı &Tercih Et"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:174
msgid "Tool Tip"
msgstr "Araç İpucu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:744
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:177
msgid "Preview St&yle:"
msgstr "Önizleme &Biçimi"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:764
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:180
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:771
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:187
msgid "Preview Si&ze:"
msgstr "Ö&nizleme Boyutu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:787
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:190
msgid "This value defines the maximum length of one side of window previews."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:820
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:196
msgid "Tool Tip &Type:"
msgstr "Araç İpucu &Tipi:"

# son kısma biraz daha ekleme lazım
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:840
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:199
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""
"
Hiçbiri
\n"
"
Araç ipuçları gösterme.
\n"
"\n"
"
Pürüzsüz
\n"
"
Görev öğeleri için gelişmiş araç ipuçları göster. Bu araç ipuçları "
"tıklandığında denk düştüğü uygulamaları açmaya yarayan pencere "
"önizlemelerini gösterir. Önizlemenin üstüne geldiğinizde pencere "
"parlaklaşacaktır. Bununla birlikte bu tip bir araç ipucu plasma ile "
"yeteri kadar bütünleşik değildir.
\n"
"\n"
"
Plasma
\n"
"
Plasma'nın yerleşik araç ipuçlarını kullan. Bu tip araç ipuçları "
"yukarıdaki özellikleri sunmaz. Bununla birlikte diğer uygulamaların "
"araç ipuçları ile daha bütünleşiktir.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:862
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:895
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:978
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:209 rc.cpp:218 rc.cpp:236
msgid "ms"
msgstr "ms"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:875
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:212
msgid "Move &Duration:"
msgstr "&Hareket Süresi:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:885
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:215
msgid "&Highlight Delay:"
msgstr "A&ydınlatma Gecikmesi:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:221
msgid "Animation"
msgstr "Animasyon"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:927
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:224
msgid "&Frames per Second:"
msgstr "&Saniye başına Kare:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:943
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:227
msgid "fps"
msgstr "sbk"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:959
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:230
msgid "&Animation Duration:"
msgstr "&Animasyon Süresi:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:233
msgid ""
"This defines the duration of animations like the expansion of tasks and the "
"delay for which a tool tip will be shown after you stopped hovering the task "
"item or tool tip."
msgstr ""
"Bu, görevlerin genişletilmesi gibi animasyonların ne kadar süreceğini ve "
"bir görev öğesi üzerinde durduktan ne kadar sonra ipucunun gösterileceğini "
"tanımlar."

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:245
msgid "Grouping & Sorting"
msgstr "Gruplama ve Sıralama"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:248
msgid "&Grouping:"
msgstr "&Gruplama:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:251
msgid "Only when the taskbar is &full"
msgstr "Yalnızca görev çubuğu dolu oldu&ğunda"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:254
msgid "&Sorting:"
msgstr "&Sıralama"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:257
msgid "Filters"
msgstr "Filtreler"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:260
msgid "Only show tasks that are &minimized"
msgstr "Yalnızca &küçültülmüş görevleri göster"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:263
msgid "Only show tasks from the current &desktop"
msgstr "Yalnızca aktif &masaüstündeki görevleri göster"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:266
msgid "Only show tasks from the current s&creen"
msgstr "Yalnızca aktif &ekrandaki görevleri göster"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:269
msgid "Middle Click &Action:"
msgstr "Orta Tıklama &Hareketi:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:272
msgid "Action that should be performed when a task item is middle clicked."
msgstr "Bir görev orta fare tuşuyla tıklandığında gerçekleştirilecek hareket."

#: rc.cpp:273
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Anıl Özbek"

#: rc.cpp:274
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "ozbekanil@gmail.com"


plasma-widget-smooth-tasks/po/pl.po000644 000765 000765 00000062167 11724514472 020206 0ustar00salvosalvo000000 000000 # 2009-08-28
# Maciej , 2010.
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n"
"POT-Creation-Date: 2009-11-07 00:47+0100\n"
"PO-Revision-Date: 2010-01-23 15:38+0100\n"
"Last-Translator: Maciej \n"
"Language-Team: Polish \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 1.0\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, General)
#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, General)
#: ../applet/SmoothTasks/Applet.cpp:611 rc.cpp:239 rc.cpp:242
msgid "General"
msgstr "Główne"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Appearance)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, Appearance)
#: ../applet/SmoothTasks/Applet.cpp:615 rc.cpp:3 rc.cpp:6
msgid "Appearance"
msgstr "Wygląd"

#: ../applet/SmoothTasks/Applet.cpp:626
msgid "Do Not Group"
msgstr "Nie grupuj"

#: ../applet/SmoothTasks/Applet.cpp:628
msgid "By Program Name"
msgstr "Po nazwie programu"

#: ../applet/SmoothTasks/Applet.cpp:638
msgid "Do Not Sort"
msgstr "Nie sortuj"

#: ../applet/SmoothTasks/Applet.cpp:639
msgid "Manually"
msgstr "Ręcznie"

#: ../applet/SmoothTasks/Applet.cpp:640
msgid "Alphabetically"
msgstr "Alfabetycznie"

#: ../applet/SmoothTasks/Applet.cpp:641
msgid "By Desktop"
msgstr "Po pulpicie"

#: ../applet/SmoothTasks/Applet.cpp:645
msgid "No Action"
msgstr "Brak akcji"

#: ../applet/SmoothTasks/Applet.cpp:646
msgid "Close Task"
msgstr "Zamknij zadanie"

#: ../applet/SmoothTasks/Applet.cpp:647
msgid "Move to Current Desktop"
msgstr "Przesuń do aktualnego pulpitu"

#: ../applet/SmoothTasks/Applet.cpp:651
msgid "Rectangle"
msgstr "Prostokąt"

#: ../applet/SmoothTasks/Applet.cpp:652
msgid "Square"
msgstr "Kwadrat"

#: ../applet/SmoothTasks/Applet.cpp:677 ../applet/SmoothTasks/Applet.cpp:696
msgid "None"
msgstr "Brak"

#: ../applet/SmoothTasks/Applet.cpp:678
msgid "Smooth"
msgstr "Płynny"

#: ../applet/SmoothTasks/Applet.cpp:679
msgid "Plasma"
msgstr "Plasma"

#: ../applet/SmoothTasks/Applet.cpp:683
msgid "By Taskbar Shape"
msgstr "Według kształtu paska zadań"

#: ../applet/SmoothTasks/Applet.cpp:684
msgid "Maximum Squeeze"
msgstr "Maksymalne ściśnięcie"

#: ../applet/SmoothTasks/Applet.cpp:685
msgid "Fixed Item Number per Row"
msgstr "Ustalona liczba zadań na rząd"

#: ../applet/SmoothTasks/Applet.cpp:686
msgid "Limited Squeeze"
msgstr "Częściowe ściśnięcie"

#: ../applet/SmoothTasks/Applet.cpp:687
msgid "Fixed Maximum Item Height"
msgstr "Maksymalna wysokość zadań"

#: ../applet/SmoothTasks/Applet.cpp:697
msgid "Active"
msgstr "Aktywne"

#: ../applet/SmoothTasks/Applet.cpp:698
msgid "From the current desktop"
msgstr "Z aktualnego pulpitu"

#: ../applet/SmoothTasks/Applet.cpp:699
msgid "All"
msgstr "Wszystkie"

#: ../applet/SmoothTasks/Applet.cpp:705
msgid "Classic"
msgstr "Klasyczny"

#: ../applet/SmoothTasks/Applet.cpp:706
msgid "New"
msgstr "Nowy"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:81
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:105
#: ../applet/SmoothTasks/Task.cpp:121
#: ../applet/SmoothTasks/WindowPreview.cpp:270
msgid "On all desktops"
msgstr "Na wszystkich pulpitach"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:82
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:108
#: ../applet/SmoothTasks/Task.cpp:122
#: ../applet/SmoothTasks/WindowPreview.cpp:271
msgctxt "Which virtual desktop a window is currently on"
msgid "On %1"
msgstr "Na %1"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:107
msgid "On various desktops"
msgstr "Na różnych pulpitach"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:114
#: ../applet/SmoothTasks/Task.cpp:116
#: ../applet/SmoothTasks/WindowPreview.cpp:268
msgid "Starting application..."
msgstr "Uruchamianie programu..."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:27
#. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab)
#: rc.cpp:9
msgid "Task Items"
msgstr "&Ikony zadań"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:48
#. i18n: ectx: property (text), widget (QLabel, taskShapeLabel)
#: rc.cpp:12
msgid "Task &Shape:"
msgstr "&Kształt ikony:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:70
#. i18n: ectx: property (toolTip), widget (QComboBox, shape)
#: rc.cpp:15
#, fuzzy
msgid ""
"
This setting is only effective when there is enough room in the taskbar "
"to display the task items in the according shape.
\n"
"\n"
"
Rectangle
\n"
"
Displays collapsed task items as rectangles.
\n"
"\n"
"
Square
\n"
"
Displays collapsed task items as squares.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:77
#. i18n: ectx: property (text), widget (QLabel, spaceLabel)
#: rc.cpp:24
msgid "Space &Between Tasks:"
msgstr "Przestrzeń &pomiędzy ikonami:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:93
#. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:195
#. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:667
#. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:790
#. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:27 rc.cpp:49 rc.cpp:159 rc.cpp:193
msgid "px"
msgstr "px"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:103
#. i18n: ectx: property (text), widget (QLabel, iconScaleLabel)
#: rc.cpp:30
msgid "&Icon Scale:"
msgstr "&Rozmiar ikony:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119
#. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale)
#: rc.cpp:33
msgid ""
"The scale of the task icons in relation to the height/width (whatever is "
"smaller) of the task item."
msgstr "Skala ikon zadań "

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122
#. i18n: ectx: property (suffix), widget (QSpinBox, iconScale)
#: rc.cpp:37
#, no-c-format
msgid "%"
msgstr "%"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:166
#. i18n: ectx: property (text), widget (QCheckBox, expandTasks)
#: rc.cpp:40
msgid "&Expand Tasks"
msgstr "&Rozszerzaj zadania "

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:176
#. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel)
#: rc.cpp:43
msgid "E&xpanding Size:"
msgstr "Rozmiar po &rozszerzeniu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:192
#. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize)
#: rc.cpp:46
msgid ""
"This is the additional size that gets added to a task item when it expands. "
"Keep in mind that the task items might not be able to expand fully when "
"there is not enough room."
msgstr ""
"To jest odległość, o jaką zostanie poszerzona\n"
"ikona programu. Pamiętaj jednak o tym, że\n"
"nie będzie ona mogła się w całości rozszerzyć,\n"
"gdy nie będzie wystarczająco dużo miejsca."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:214
#. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel)
#: rc.cpp:52
msgid "&Keep Expanded:"
msgstr "&Rozszerzaj:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:55
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:277
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:58
msgid "&Lights"
msgstr "Podś&wietlenie"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:308
#. i18n: ectx: property (text), widget (QCheckBox, expandOnHover)
#: rc.cpp:61
msgid "Expand on &Hover"
msgstr "Rozszerzaj po &najechaniu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:318
#. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:64
msgid ""
"For some plasma themes task items might look better when their frames are "
"not rotated. This only concerns vertical layouts, e.g. when you place the "
"taskbar at the left (or right) screen edge."
msgstr ""
"Dla niektórych tematów pulpitu, ikony zadań mogą wyglądać lepiej gdy ramki\n"
"je otaczające nie są obrócone. Tyczy się to jedynie pionowych pasków zadań, "
"na przykład\n"
"przy ułożeniu go po prawej lub lewej stronie ekranu."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:321
#. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:67
msgid "Don't &Rotate Frames"
msgstr "Nie &obracaj ramek"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:331
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:70
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""
"Zazwyczaj, do zadań na które najechał kursor myszy\n"
"wyświetlane jest inne obramowanie. Z tego powodu,\n "
"efekt podświetlenia może wyglądać niepoprawnie w\n"
"połączeniu z niektórymi tematami pulpitu. Ta opcja\n"
"powoduje, że najechanie myszą na zadanie nie zmienia\n"
"obramowania ikony programu na pasku zadań."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:334
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:73
msgid "As &Only Hover Effect"
msgstr "Tylko dla efektu &najechania"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:344
#. i18n: ectx: property (text), widget (QCheckBox, textShadow)
#: rc.cpp:76
msgid "Draw &Text-Shadow"
msgstr "Rysuj &cień tekstu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:357
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:79
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""
"Ta opcja powoduje, że do określenia koloru podświetlenia\n"
"używana jest barwa będąca dominującą składową ikony\n"
"danego zadania. Kiedy efektem będzie brzydka (szarawa)\n"
"barwa, zamiast niej użyty będzie kolor ustalony powyżej."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:360
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:82
msgid "Color From &Icon"
msgstr "&Zależny od koloru ikony"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:373
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:85
msgid "&Color:"
msgstr "&Kolor:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:383
#. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks)
#: rc.cpp:88
msgid "Switch Tasks using &Wheel"
msgstr ""
"Przełączaj &kółkiem myszy\n"
"pomiędzy programamami"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:396
#. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention)
#: rc.cpp:91
msgid "Expand on &Attention"
msgstr "Rozszerzaj przy &wydarzeniu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:404
#. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab)
#: rc.cpp:94
msgid "Taskbar Layout"
msgstr "&Rozkład paska zadań"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:431
#. i18n: ectx: property (text), widget (QLabel, label_2)
#: rc.cpp:97
msgid "Row Constraints"
msgstr "Ograniczanie ilości rzędów"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:438
#. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel)
#: rc.cpp:100
msgid "&Minimum Rows:"
msgstr "&Minimalna liczba rzędów"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:454
#. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows)
#: rc.cpp:103
#, fuzzy
msgid ""
"This defines the minimum row count. Some layouts stretch the filled rows in "
"order to fill any empty space. This way the displayed rows might be still "
"fewer than this value."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:467
#. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel)
#: rc.cpp:106
msgid "Ma&ximum Rows:"
msgstr "Ma&ksymalna liczba rzędów:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows)
#: rc.cpp:109
msgid "This defines the maximum row count."
msgstr "Określa maksymalną liczbę rzędów."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:523
#. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel)
#: rc.cpp:112
msgid "&Layout:"
msgstr "&Rozkład:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:559
#. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout)
#: rc.cpp:115
#, fuzzy
msgid ""
"
The layout is responsible for the size and placement of the task items.\n"
"Each of the provided layouts has other advantages and disadvantages.\n"
"Because I can't decide which layouting strategy is best suited for this "
"purpose I include several choices for now.
\n"
"\n"
"
By Taskbar Shape
\n"
"
This layout creates as much rows as are needed so that following "
"condition is met:
\n"
"
row height × row aspect ratio ≤ row width
\n"
"
However, if this would yield empty rows the filled rows are scaled in "
"height so that the whole task bar space is covered.
\n"
"\n"
"
Maximum Squeeze
\n"
"
Because the width of the task items depends of their height the more rows "
"there are the less room the items occupy.\n"
"This layout sets the width of the task items always to the width they would "
"have when the row count would have reached the maximally allowed value.\n"
"\n"
"
Fixed Item Number per Row
\n"
"
This layout always put the configured number of task items into one row, "
"unless there would not be enough room for all task items.\n"
"Then the items are distributed evenly over the rows.
\n"
"\n"
"
Limited Squeeze
\n"
"
This layout tries to squeeze the task items only up to a given maximum "
"squeeze ratio. If it would have to squeeze them more than that it creates a "
"new row. Currently this layout is the only one that respects the “Prefer "
"Grouping” setting.
\n"
"\n"
"
Fixed Maximum Item Height
\n"
"
This layout always assumes the configured height of the task items.\n"
"Through the dependency between the width and height of the task items this "
"leads to a specific distribution of the items.\n"
"This layout does not fill empty space by up-scaling the rows.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:141
msgid "Row &Aspect Ratio:"
msgstr ""
"Wzajemny &stosunek\n"
"wymiarów rzędów:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:597
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:144
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""
"Rozkład \"Według kształtu paska zadań\" używa tej wartości, by móc określić\n"
"ile rzędów należy utworzyć."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:619
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:147
msgid "&Items per Row:"
msgstr "&Ikon na rząd:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:635
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:150
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""
"Rozkład \"Ustalona liczba zadań na rząd\" używa tej wartości, by wypełnić\n"
"rzędy zadaniami."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:648
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:153
msgid "Maximum Item &Height:"
msgstr "Maksymalna &wysokość ikony:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:664
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:156
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the size "
"of the task items."
msgstr ""
"Rozkład \"Maksymalna szerokość zadań\" używa tej wartości do określenia\n"
"rozmiaru zadań."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:680
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:162
msgid "Maximum &Squeeze Ratio:"
msgstr ""
"Współczynnik &maksymalnego\n"
"dopuszczalnego ściśnięcia:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:165
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""
"Opcja ta jest wykorzystywana przy rozkładzie \"Częściowe ściśnięcie\".\n"
"Współczynnik ten określa stopień dopuszczalnego maksymalnego\n"
"ściśnięcia zadania, względem zadania nieściśniętego.\n"
"(Iloraz szerokości ściśniętego zadania do szerokości nieściśniętego\n"
"zadania nie może być mniejszy niż podana wartość współczynnika)"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:715
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""
"Opcja ta powoduje, że Smooth Tasks dąży do\n"
"grupowania zadań, zamiast zwiększać liczbę rzędów.\n"
"(obecnie wspierana jedynie przez opcję \"Częściowe ściśnięcie\")"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:718
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:171
msgid "&Prefer Grouping"
msgstr "Najpierw &grupuj"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:174
msgid "Tool Tip"
msgstr "&Podgląd okien"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:744
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:177
msgid "Preview St&yle:"
msgstr "&Styl Podglądu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:764
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:180
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""
"
Klasyczny
\n"
"
\n"
"\n"
"
Nowy
\n"
"
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:771
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:187
msgid "Preview Si&ze:"
msgstr "&Rozmiar podglądu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:787
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:190
msgid "This value defines the maximum length of one side of window previews."
msgstr "Określa maksymalną długość jednego z boków dymka z podglądem okna."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:820
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:196
msgid "Tool Tip &Type:"
msgstr "Typ &dymka:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:840
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:199
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""
"
Brak
\n"
"
Podglądy okien nie będą wyświetlane.
\n"
"\n"
"
Płynny
\n"
"
Do wyświetlania podglądów okien zostaną użyte nowe, zaawansowane dymki. "
"Można kliknąć na podgląd okna, by je pokazać, najechanie na podgląd kursorem "
"powoduje jego wybór. Niestety, ten typ dymków nie jest jeszcze dobrze "
"zintegrowany z powłoką pulpitu. 
\n"
"\n"
"
Natywny
\n"
"
Do wyświetlania podglądów okien zostaną użyte standradowe dymki. Nie "
"posiadają one wyżej opisanych właściwości, ale dobrze integrują się z "
"dymkami innych apletów systemu i zapewniają animowany ruch pomiędzy innymi "
"apletami.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:862
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:895
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:978
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:209 rc.cpp:218 rc.cpp:236
msgid "ms"
msgstr "ms"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:875
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:212
msgid "Move &Duration:"
msgstr "Czas trwania &ruchu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:885
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:215
msgid "&Highlight Delay:"
msgstr "&Opóźnienie podświetlenia:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:221
msgid "Animation"
msgstr "&Animacja"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:927
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:224
msgid "&Frames per Second:"
msgstr "Klatki na &sekundę:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:943
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:227
msgid "fps"
msgstr " k/s"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:959
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:230
msgid "&Animation Duration:"
msgstr "Czas &trwania animacji"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:233
msgid ""
"This defines the duration of animations like the expansion of tasks and the "
"delay for which a tool tip will be shown after you stopped hovering the task "
"item or tool tip."
msgstr ""
"Ta opcja określa czas trwania animacji takich, jak czas rozszerzania zadań "
"i czas, przez jaki zostanie pokazywana miniatury okna już po tym, gdy kursor "
"myszy wyjedzie poza obszar miniatury lub ikony zadania."

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:245
msgid "Grouping & Sorting"
msgstr "Grupowanie i sortowanie"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:248
msgid "&Grouping:"
msgstr "&Grupowanie:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:251
msgid "Only when the taskbar is &full"
msgstr "Tylko gdy pasek zadań jest pełny"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:254
msgid "&Sorting:"
msgstr "&Sortowanie:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:257
msgid "Filters"
msgstr "Filtry"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:260
msgid "Only show tasks that are &minimized"
msgstr "Pokaż zadania z&minimalizowane"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:263
msgid "Only show tasks from the current &desktop"
msgstr "Pokaż zadania tylko z aktualnego &pulpitu"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:266
msgid "Only show tasks from the current s&creen"
msgstr "Pokaż zadania tylko z aktualnego &ekranu"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:269
msgid "Middle Click &Action:"
msgstr "Akcja środkowego &przycisku:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:272
msgid "Action that should be performed when a task item is middle clicked."
msgstr ""
"Akcja, ktora powinna być wykonana gdy ikona programu zostanie kliknięcia "
"środkowym przyciskiem myszy."

#: rc.cpp:273
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Maciej Warnecki"

#: rc.cpp:274
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "maciekw5@gmail.com"


plasma-widget-smooth-tasks/po/ru.po000644 000765 000765 00000104400 11724514472 020204 0ustar00salvosalvo000000 000000 # 2009-08-28
# Ritt K. , 2009.
# Константин , 2009.
# Daniel Schemala <28364@web.de>, 2010.
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n"
"POT-Creation-Date: 2010-01-12 22:42+0100\n"
"PO-Revision-Date: 2010-01-12 22:01+0100\n"
"Last-Translator: Daniel Schemala <28364@web.de>\n"
"Language-Team: Deutsch \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 1.0\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, General)
#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, General)
#: ../applet/SmoothTasks/Applet.cpp:641 rc.cpp:280 rc.cpp:283
msgid "General"
msgstr "Параметры"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6
#. i18n: ectx: property (windowTitle), widget (QWidget, Appearance)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9
#. i18n: ectx: property (accessibleName), widget (QWidget, Appearance)
#: ../applet/SmoothTasks/Applet.cpp:645 rc.cpp:3 rc.cpp:6
msgid "Appearance"
msgstr "Внешний вид"

#: ../applet/SmoothTasks/Applet.cpp:649
msgid "Workarounds"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:660
msgid "Do Not Group"
msgstr "Не группировать"

#: ../applet/SmoothTasks/Applet.cpp:662
msgid "By Program Name"
msgstr "По имени программы"

#: ../applet/SmoothTasks/Applet.cpp:672
msgid "Do Not Sort"
msgstr "Не сортировать"

#: ../applet/SmoothTasks/Applet.cpp:673
msgid "Manually"
msgstr "Вручную"

#: ../applet/SmoothTasks/Applet.cpp:674
msgid "Alphabetically"
msgstr "По имени"

#: ../applet/SmoothTasks/Applet.cpp:675
msgid "By Desktop"
msgstr "По рабочим столам"

#: ../applet/SmoothTasks/Applet.cpp:679
msgid "No Action"
msgstr "Ничего"

#: ../applet/SmoothTasks/Applet.cpp:680
msgid "Close Task"
msgstr "Закрыть задачу"

#: ../applet/SmoothTasks/Applet.cpp:681
msgid "Move to Current Desktop"
msgstr "С текущего рабочего стола"

#: ../applet/SmoothTasks/Applet.cpp:685
msgid "Rectangle"
msgstr "Прямоугольник"

#: ../applet/SmoothTasks/Applet.cpp:686
msgid "Square"
msgstr "Квадрат"

#: ../applet/SmoothTasks/Applet.cpp:721 ../applet/SmoothTasks/Applet.cpp:740
msgid "None"
msgstr "Нет"

#: ../applet/SmoothTasks/Applet.cpp:722
msgid "Smooth"
msgstr "Smooth"

#: ../applet/SmoothTasks/Applet.cpp:723
msgid "Plasma"
msgstr "Plasma"

#: ../applet/SmoothTasks/Applet.cpp:727
msgid "By Taskbar Shape"
msgstr "По форме панели задач"

#: ../applet/SmoothTasks/Applet.cpp:728
msgid "Maximum Squeeze"
msgstr "Максимальное уменьшение"

#: ../applet/SmoothTasks/Applet.cpp:729
msgid "Fixed Item Number per Row"
msgstr "Фиксированное кол-во элементов в строке"

#: ../applet/SmoothTasks/Applet.cpp:730
msgid "Limited Squeeze"
msgstr "Ограниченное уменьшение"

#: ../applet/SmoothTasks/Applet.cpp:731
msgid "Fixed Maximum Item Height"
msgstr "Фиксированная макс. высота элемента"

#: ../applet/SmoothTasks/Applet.cpp:741
msgid "Active"
msgstr "Активная"

#: ../applet/SmoothTasks/Applet.cpp:742
msgid "From the current desktop"
msgstr "С текущего рабочего стола"

#: ../applet/SmoothTasks/Applet.cpp:743
msgid "All"
msgstr "Все"

#: ../applet/SmoothTasks/Applet.cpp:749
msgid "Classic"
msgstr "Классический"

#: ../applet/SmoothTasks/Applet.cpp:750
msgid "New"
msgstr "Новый"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:81
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:105
#: ../applet/SmoothTasks/Task.cpp:122
#: ../applet/SmoothTasks/WindowPreview.cpp:270
msgid "On all desktops"
msgstr "На всех рабочих столах"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:82
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:108
#: ../applet/SmoothTasks/Task.cpp:123
#: ../applet/SmoothTasks/WindowPreview.cpp:271
msgctxt "Which virtual desktop a window is currently on"
msgid "On %1"
msgstr "На %1"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:107
msgid "On various desktops"
msgstr "На различных рабочих столах"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:114
#: ../applet/SmoothTasks/Task.cpp:117
#: ../applet/SmoothTasks/WindowPreview.cpp:268
msgid "Starting application..."
msgstr "Запуск приложения..."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16
#. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab)
#: rc.cpp:9
msgid "Task Items"
msgstr "Элементы"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22
#. i18n: ectx: property (text), widget (QLabel, taskShapeLabel)
#: rc.cpp:12
msgid "Task &Shape:"
msgstr "&Форма элемента:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:38
#. i18n: ectx: property (toolTip), widget (QComboBox, shape)
#: rc.cpp:15
msgid ""
"
This setting is only effective when there is enough room in the taskbar "
"to display the task items in the according shape.
\n"
"\n"
"
Rectangle
\n"
"
Displays collapsed task items as rectangles.
\n"
"\n"
"
Square
\n"
"
Displays collapsed task items as squares.
"
msgstr ""
"
Данная опция эффективна только при наличии достаточного пространства\n"
"для отображения формы элемента на панели задач.
\n"
"\n"
"
Прямоугольник
\n"
"
Показывает свёрнутые элементы в виде прямоугольников.
\n"
"\n"
"
Квадрат
\n"
"
Показывает свёрнутые элементы в виде квадратов.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:45
#. i18n: ectx: property (text), widget (QLabel, spaceLabel)
#: rc.cpp:24
msgid "Space &Between Tasks:"
msgstr "Отступ &между элементами:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:55
#. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:79
#. i18n: ectx: property (suffix), widget (QSpinBox, minTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:96
#. i18n: ectx: property (suffix), widget (QSpinBox, maxTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:216
#. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284
#. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:525
#. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:624
#. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:27 rc.cpp:36 rc.cpp:42 rc.cpp:76 rc.cpp:88 rc.cpp:156 rc.cpp:190
msgid "px"
msgstr " px"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:65
#. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel)
#: rc.cpp:30
msgid "minimal icon space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:72
#. i18n: ectx: property (text), widget (QLabel, minTextSpaceLabel)
#: rc.cpp:33
msgid "minimal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:89
#. i18n: ectx: property (text), widget (QLabel, maxTextSpaceLabel)
#: rc.cpp:39
msgid "maximal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:109
#. i18n: ectx: property (text), widget (QLabel, iconScaleLabel)
#: rc.cpp:45
msgid "&Icon Scale:"
msgstr "Масштаб &значка:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119
#. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale)
#: rc.cpp:48
msgid ""
"The scale of the task icons in relation to the height/width (whatever is "
"smaller) of the task item."
msgstr ""
"Масштаб значка зависит от соотношения высота/ширина элемента (выбирается "
"меньшее значение)."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122
#. i18n: ectx: property (suffix), widget (QSpinBox, iconScale)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:991
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical)
#: rc.cpp:52 rc.cpp:273 rc.cpp:277
#, no-c-format
msgid "%"
msgstr "%"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:138
#. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:55
msgid ""
"For some plasma themes task items might look better when their frames "
"are not rotated. This only concerns vertical layouts, e.g. when you place "
"the taskbar at the left (or right) screen edge."
msgstr ""
"Для некоторых тем Plasma элементы панели задач выглядят лучше,\n"
"если их рамки не повёрнуты. Это относится только к вертикальным "
"компоновкам,\n"
"например, когда Вы располагаете панель задач в левой или правой части экрана."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:141
#. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:58
msgid "Don't &Rotate Frames"
msgstr "Не &поворачивать рамки"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:148
#. i18n: ectx: property (text), widget (QCheckBox, textShadow)
#: rc.cpp:61
msgid "Draw &Text-Shadow"
msgstr "Рисовать &тень от текста"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:158
#. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks)
#: rc.cpp:64
msgid "Switch Tasks using &Wheel"
msgstr "Переключение задач &колёсиком"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:190
#. i18n: ectx: property (text), widget (QCheckBox, expandTasks)
#: rc.cpp:67
msgid "&Expand Tasks"
msgstr "&Разворачивать элементы"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:200
#. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel)
#: rc.cpp:70
msgid "E&xpanding Size:"
msgstr "Максимальный &размер:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:213
#. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize)
#: rc.cpp:73
msgid ""
"This is the additional size that gets added to a task item when it "
"expands. Keep in mind that the task items might not be able to expand fully "
"when there is not enough room."
msgstr ""
"Максимальный размер развёрнутого элемента.\n"
"Имейте в виду, что элемент может быть не полностью развёрнут,\n"
"если для этого недостаточно свободного места."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:235
#. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel)
#: rc.cpp:79
msgid "&Keep Expanded:"
msgstr "&Оставлять развёрнутым"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:264
#. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention)
#: rc.cpp:82
msgid "Expand on &Attention"
msgstr "Разворачивать при &наведении"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274
#. i18n: ectx: property (text), widget (QCheckBox, expandOnHover)
#: rc.cpp:85
msgid "Expand on &Hover"
msgstr "Разворачивать при &наведении"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:298
#. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab)
#: rc.cpp:91
msgid "Taskbar Layout"
msgstr "Компоновка"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:310
#. i18n: ectx: property (text), widget (QLabel, label_2)
#: rc.cpp:94
msgid "Row Constraints"
msgstr "Настройки строк"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:317
#. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel)
#: rc.cpp:97
msgid "&Minimum Rows:"
msgstr "&Минимальное кол-во строк:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:327
#. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows)
#: rc.cpp:100
msgid ""
"This defines the minimum row count. Some layouts stretch the filled rows "
"in order to fill any empty space. This way the displayed rows might be still "
"fewer than this value."
msgstr ""
"Определяет минимальное количество строк.\n"
"Некоторые компоновки растягивают строки чтобы заполнить пустое "
"пространство.\n"
"В таком случае строка может быть меньше, чем данное значение."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:340
#. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel)
#: rc.cpp:103
msgid "Ma&ximum Rows:"
msgstr "Мак&симальное кол-во строк:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:350
#. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows)
#: rc.cpp:106
msgid "This defines the maximum row count."
msgstr "Определяет максимальное количество строк."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:390
#. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel)
#: rc.cpp:109
msgid "&Layout:"
msgstr "&Компоновка:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:423
#. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout)
#: rc.cpp:112
msgid ""
"
The layout is responsible for the size and placement of the task items.\n"
"Each of the provided layouts has other advantages and disadvantages.\n"
"Because I can't decide which layouting strategy is best suited for this "
"purpose I include several choices for now.
\n"
"\n"
"
By Taskbar Shape
\n"
"
This layout creates as much rows as are needed so that following "
"condition is met:
\n"
"
row height × row aspect ratio ≤ row width
\n"
"
However, if this would yield empty rows the filled rows are scaled in "
"height so that the whole task bar space is covered.
\n"
"\n"
"
Maximum Squeeze
\n"
"
Because the width of the task items depends of their height the more rows "
"there are the less room the items occupy.\n"
"This layout sets the width of the task items always to the width they would "
"have when the row count would have reached the maximally allowed value.\n"
"\n"
"
Fixed Item Number per Row
\n"
"
This layout always put the configured number of task items into one row, "
"unless there would not be enough room for all task items.\n"
"Then the items are distributed evenly over the rows.
\n"
"\n"
"
Limited Squeeze
\n"
"
This layout tries to squeeze the task items only up to a given maximum "
"squeeze ratio. If it would have to squeeze them more than that it creates a "
"new row. Currently this layout is the only one that respects the “Prefer "
"Grouping” setting.
\n"
"\n"
"
Fixed Maximum Item Height
\n"
"
This layout always assumes the configured height of the task items.\n"
"Through the dependency between the width and height of the task items this "
"leads to a specific distribution of the items.\n"
"This layout does not fill empty space by up-scaling the rows.
"
msgstr ""
"
Компоновка отвечает за размер и расположение элементов.\n"
"Каждая из приведённых ниже компоновок имеет свои преимущества и недостатки.\n"
"\n"
"
По форме панели задач
\n"
"
Создаёт столько строк, сколько необходимо для выполнения следующего "
"условия:
\n"
"
высота строки × коэффициент растяжения строки ≤ ширина строки\n"
"
Однако, если это приведёт к созданию пустых строк, дрегие строки увеличат "
"высоту, заняв всё доступное пространство панели задач.
\n"
"\n"
"
Максимальное уменьшение
\n"
"
Поскольку ширина элемента зависит от его высоты, то чем больше строк, тем "
"меньше места занимают элементы.\n"
"Ширина элемента всегда вычисляется на основе максимального количества "
"строк.\n"
"\n"
"
Фиксированное кол-во элементов в строке
\n"
"
Каждая строка всегда вмещает не более указанного количества элементов.\n"
"\n"
"
Ограниченное уменьшение
\n"
"
Пытается уменьшать элементы только до максимального коэффициента "
"уменьшения.\n"
"Если потребуется ещё большее уменьшение, будет создана строка.\n"
"В настоящий момент только данная компоновка учитывает опцию “Предпочитать "
"группировку”.
\n"
"\n"
"
Фиксированная максимальная высота элемента
\n"
"
Всегда учитывает максимальную высоту элемента, указанную в настройках.\n"
"Зависимость от отношения ширины элемента к высоте элемента приводит к "
"специфическому распределению элементов.\n"
"Данная компоновка не заполняет свободное пространство путём увеличения "
"высоты строки.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:448
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:138
msgid "Row &Aspect Ratio:"
msgstr "Коэффициент &растяжения строки:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:461
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:141
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""
"Компоновка «По форме панели задач» использует данное значение\n"
"для определения требуемого количества строк."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:144
msgid "&Items per Row:"
msgstr "&Элементов в строке:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:496
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:147
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""
"Компоновка «Фиксированное кол-во элементов в строке» \n"
"использует данное значение для заполнения строк элементами."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:509
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:150
msgid "Maximum Item &Height:"
msgstr "Максимальная &высота элемента:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:522
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:153
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the "
"size of the task items."
msgstr ""
"Компоновка «Фиксированная максимальная высота элемента»\n"
"использует данное значение для определения размера элементов."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:538
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:159
msgid "Maximum &Squeeze Ratio:"
msgstr "Макс. коэффициент &уменьшения:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:551
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:162
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""
"
Компоновка «Ограниченное уменьшение» пытается не уменьшать элементы, пока "
"уменьшенная ширина элемента / ширина элемента < максимальный "
"коэффициент уменьшения.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:573
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:165
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""
"Предпочитать группировку задач добавлению строки\n"
"(в настоящий момент поддерживается только компоновкой «Ограниченное "
"уменьшение»)."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
msgid "&Prefer Grouping"
msgstr "&Предпочитать группировку"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:171
msgid "Tool Tip"
msgstr "&Подсказка"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:174
msgid "Preview St&yle:"
msgstr "&Стиль предпросмотра:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:604
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:177
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""
"
Классический
\n"
"
\n"
"\n"
"
Новый
\n"
"
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:611
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:184
msgid "Preview Si&ze:"
msgstr "&Размер предпросмотра:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:621
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:187
msgid ""
"This value defines the maximum length of one side of window previews."
msgstr "Максимальное значение ширины и высоты окна предпросмотра"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:654
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:193
msgid "Tool Tip &Type:"
msgstr "&Тип подсказки:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:671
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:196
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""
"
Нет
\n"
"
Не показывать подсказки.
\n"
"\n"
"
Smooth
\n"
"
Использовать расширенные подсказки к элементам панели задач.\n"
"Данные подсказки показывают окно предпросмотра,\n"
"на котором щелчком можно активировать требуемое окно.\n"
"При перемещении указателя мыши над окном предпросмотра отображаемые окна "
"подсвечиваются.\n"
"Расширенные подсказки плохо интегрированы в Plasma.
\n"
"\n"
"
Plasma
\n"
"
Использовать стандартные подсказки Plasma.\n"
"Стандартные подсказки не имеют возможностей, описанных выше,\n"
"зато хорошо интегрированы в Plasma.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:785
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:206 rc.cpp:215 rc.cpp:233
msgid "ms"
msgstr " мс"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:706
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:209
msgid "Move &Duration:"
msgstr "&Продолжительность анимации:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:716
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:212
msgid "&Highlight Delay:"
msgstr "&Задержка подсветки:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:740
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:218
msgid "Animation"
msgstr "&Анимация"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:746
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:221
msgid "&Frames per Second:"
msgstr "&Кадров в секунду:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:756
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:224
msgid "fps"
msgstr " к/с"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:772
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:227
msgid "&Animation Duration:"
msgstr "&Продолжительность анимации:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:782
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:230
msgid ""
"This defines the duration of animations like the expansion of tasks and "
"the delay for which a tool tip will be shown after you stopped hovering the "
"task item or tool tip."
msgstr ""
"Определяет продолжительность анимации разворачивания элемента панели задач\n"
"и задержку отображения подсказки для элемента, на котором остановился "
"указатель мыши."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:801
#. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel)
#: rc.cpp:236
#, fuzzy
msgid "Animation Speed:"
msgstr "&Анимация"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:825
#. i18n: ectx: attribute (title), widget (QWidget, lightsTab)
#: rc.cpp:239
#, fuzzy
msgid "Lights"
msgstr "&Подсветка"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:843
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:242
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""
"Включает эффект подсвечивания элементов, \n"
"когда на них наводится указатель мыши или они требуют внимания пользователя.."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:846
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:245
msgid "&Lights"
msgstr "&Подсветка"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:859
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:248
msgid "&Color:"
msgstr "&Цвет:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:893
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:251
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""
"Если включено, основной цвет значка задачи будет использован в качествецвета "
"подсветки. Если значок серый и/или грязный, будет использован цвет,указанный "
"ниже."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:896
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:254
msgid "Color From &Icon"
msgstr "Цвет значка"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:257
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""
"Использовать подсветку только в качестве эффекта при наведении указателя "
"&мыши на элемент панели задач\n"
"(не подсвечивать соседние элементы)"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:912
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:260
msgid "As &Only Hover Effect"
msgstr "Только при &наведении"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:925
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:263
msgid "Anchor Light:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:955
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled)
#: rc.cpp:266
msgid "Anchor horizontally at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:965
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled)
#: rc.cpp:269
msgid "Anchor vertically at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:286
msgid "Grouping & Sorting"
msgstr "Группировка и сортировка"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:289
msgid "&Grouping:"
msgstr "&Группировка:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:292
msgid "Only when the taskbar is &full"
msgstr "Только когда нет &места на панели задач"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:295
msgid "&Sorting:"
msgstr "&Сортировка:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:298
msgid "Filters"
msgstr "Фильтры"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:301
msgid "Only show tasks that are &minimized"
msgstr "Показывать только &свёрнутые задачи"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:304
msgid "Only show tasks from the current &desktop"
msgstr "Показывать задачи только с &текущего рабочего стола"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:307
msgid "Only show tasks from the current s&creen"
msgstr "Показывать задачи только с текущего &экрана"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:310
msgid "Middle Click &Action:"
msgstr "&Действие по щелчку средней кнопкой:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:313
msgid "Action that should be performed when a task item is middle clicked."
msgstr "Действие, которое требуется выполнить по щелчку средней кнопкой мыши:"

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds)
#: rc.cpp:316
msgid "Form"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:319
msgid ""
"The margin sizes for task bar buttons are not designed for having a light "
"effect in the middle of a button. If the light effect looks strange you can "
"define custom button margins for the light here."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36
#. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom)
#: rc.cpp:322
msgid "enable custom margin sizes"
msgstr ""

#: rc.cpp:323
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Ritt K."

#: rc.cpp:324
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "ritt.ks@gmail.com"
plasma-widget-smooth-tasks/po/hu.po000644 000765 000765 00000061155 11724514472 020203 0ustar00salvosalvo000000 000000 # 2009-08-28
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n"
"POT-Creation-Date: 2010-01-12 22:42+0100\n"
"PO-Revision-Date: 2009-08-28 03:29+0200\n"
"Last-Translator: Nitai \n"
"Language-Team: hu \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 1.0\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, General)
#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, General)
#: ../applet/SmoothTasks/Applet.cpp:641 rc.cpp:280 rc.cpp:283
msgid "General"
msgstr "Általános"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6
#. i18n: ectx: property (windowTitle), widget (QWidget, Appearance)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9
#. i18n: ectx: property (accessibleName), widget (QWidget, Appearance)
#: ../applet/SmoothTasks/Applet.cpp:645 rc.cpp:3 rc.cpp:6
msgid "Appearance"
msgstr "Megjelenés"

#: ../applet/SmoothTasks/Applet.cpp:649
msgid "Workarounds"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:660
msgid "Do Not Group"
msgstr "Ne legyenek csoportok"

#: ../applet/SmoothTasks/Applet.cpp:662
msgid "By Program Name"
msgstr "Program nevek szerint"

#: ../applet/SmoothTasks/Applet.cpp:672
msgid "Do Not Sort"
msgstr "Ne legyen rendezés"

#: ../applet/SmoothTasks/Applet.cpp:673
msgid "Manually"
msgstr "Kézzel"

#: ../applet/SmoothTasks/Applet.cpp:674
msgid "Alphabetically"
msgstr "Betűrendben"

#: ../applet/SmoothTasks/Applet.cpp:675
msgid "By Desktop"
msgstr "Asztalok szerint"

#: ../applet/SmoothTasks/Applet.cpp:679
msgid "No Action"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:680
msgid "Close Task"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:681
#, fuzzy
msgid "Move to Current Desktop"
msgstr "Aktuális asztalon"

#: ../applet/SmoothTasks/Applet.cpp:685
msgid "Rectangle"
msgstr "Téglalap"

#: ../applet/SmoothTasks/Applet.cpp:686
msgid "Square"
msgstr "Négyzet"

#: ../applet/SmoothTasks/Applet.cpp:721 ../applet/SmoothTasks/Applet.cpp:740
msgid "None"
msgstr "Egyik sem"

#: ../applet/SmoothTasks/Applet.cpp:722
msgid "Smooth"
msgstr "Smooth"

#: ../applet/SmoothTasks/Applet.cpp:723
msgid "Plasma"
msgstr "Plazma"

#: ../applet/SmoothTasks/Applet.cpp:727
msgid "By Taskbar Shape"
msgstr "Tálca mérete szerint"

#: ../applet/SmoothTasks/Applet.cpp:728
msgid "Maximum Squeeze"
msgstr "Maximális összenyomás"

#: ../applet/SmoothTasks/Applet.cpp:729
msgid "Fixed Item Number per Row"
msgstr "Soronként állandó elem szám"

#: ../applet/SmoothTasks/Applet.cpp:730
#, fuzzy
msgid "Limited Squeeze"
msgstr "Maximális összenyomás"

#: ../applet/SmoothTasks/Applet.cpp:731
msgid "Fixed Maximum Item Height"
msgstr "Elem állandó maximális magassága"

#: ../applet/SmoothTasks/Applet.cpp:741
msgid "Active"
msgstr "Aktív"

#: ../applet/SmoothTasks/Applet.cpp:742
msgid "From the current desktop"
msgstr "Aktuális asztalon"

#: ../applet/SmoothTasks/Applet.cpp:743
msgid "All"
msgstr "Összes"

#: ../applet/SmoothTasks/Applet.cpp:749
msgid "Classic"
msgstr "Klasszikus"

#: ../applet/SmoothTasks/Applet.cpp:750
msgid "New"
msgstr "Új"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:81
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:105
#: ../applet/SmoothTasks/Task.cpp:122
#: ../applet/SmoothTasks/WindowPreview.cpp:270
msgid "On all desktops"
msgstr "Az összes asztalon"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:82
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:108
#: ../applet/SmoothTasks/Task.cpp:123
#: ../applet/SmoothTasks/WindowPreview.cpp:271
msgctxt "Which virtual desktop a window is currently on"
msgid "On %1"
msgstr "%1"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:107
msgid "On various desktops"
msgstr "Különböző asztalokon"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:114
#: ../applet/SmoothTasks/Task.cpp:117
#: ../applet/SmoothTasks/WindowPreview.cpp:268
msgid "Starting application..."
msgstr "Induló alkalmazás..."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16
#. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab)
#: rc.cpp:9
msgid "Task Items"
msgstr "Feladat beállitása"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22
#. i18n: ectx: property (text), widget (QLabel, taskShapeLabel)
#: rc.cpp:12
msgid "Task &Shape:"
msgstr "&Feladat alakja:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:38
#. i18n: ectx: property (toolTip), widget (QComboBox, shape)
#: rc.cpp:15
msgid ""
"
This setting is only effective when there is enough room in the taskbar "
"to display the task items in the according shape.
\n"
"\n"
"
Rectangle
\n"
"
Displays collapsed task items as rectangles.
\n"
"\n"
"
Square
\n"
"
Displays collapsed task items as squares.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:45
#. i18n: ectx: property (text), widget (QLabel, spaceLabel)
#: rc.cpp:24
msgid "Space &Between Tasks:"
msgstr "&Feladatok közötti távolság:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:55
#. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:79
#. i18n: ectx: property (suffix), widget (QSpinBox, minTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:96
#. i18n: ectx: property (suffix), widget (QSpinBox, maxTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:216
#. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284
#. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:525
#. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:624
#. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:27 rc.cpp:36 rc.cpp:42 rc.cpp:76 rc.cpp:88 rc.cpp:156 rc.cpp:190
msgid "px"
msgstr " px"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:65
#. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel)
#: rc.cpp:30
msgid "minimal icon space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:72
#. i18n: ectx: property (text), widget (QLabel, minTextSpaceLabel)
#: rc.cpp:33
msgid "minimal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:89
#. i18n: ectx: property (text), widget (QLabel, maxTextSpaceLabel)
#: rc.cpp:39
msgid "maximal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:109
#. i18n: ectx: property (text), widget (QLabel, iconScaleLabel)
#: rc.cpp:45
msgid "&Icon Scale:"
msgstr "Ikon Méret:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119
#. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale)
#: rc.cpp:48
msgid ""
"The scale of the task icons in relation to the height/width (whatever is "
"smaller) of the task item."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122
#. i18n: ectx: property (suffix), widget (QSpinBox, iconScale)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:991
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical)
#: rc.cpp:52 rc.cpp:273 rc.cpp:277
#, no-c-format
msgid "%"
msgstr "%"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:138
#. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:55
msgid ""
"For some plasma themes task items might look better when their frames "
"are not rotated. This only concerns vertical layouts, e.g. when you place "
"the taskbar at the left (or right) screen edge."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:141
#. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:58
msgid "Don't &Rotate Frames"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:148
#. i18n: ectx: property (text), widget (QCheckBox, textShadow)
#: rc.cpp:61
msgid "Draw &Text-Shadow"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:158
#. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks)
#: rc.cpp:64
msgid "Switch Tasks using &Wheel"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:190
#. i18n: ectx: property (text), widget (QCheckBox, expandTasks)
#: rc.cpp:67
msgid "&Expand Tasks"
msgstr "&Alkalmazások kinyújtása"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:200
#. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel)
#: rc.cpp:70
msgid "E&xpanding Size:"
msgstr "Kinyújtás hossza"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:213
#. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize)
#: rc.cpp:73
msgid ""
"This is the additional size that gets added to a task item when it "
"expands. Keep in mind that the task items might not be able to expand fully "
"when there is not enough room."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:235
#. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel)
#: rc.cpp:79
msgid "&Keep Expanded:"
msgstr "&Maradjon kinyújtva:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:264
#. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention)
#: rc.cpp:82
msgid "Expand on &Attention"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274
#. i18n: ectx: property (text), widget (QCheckBox, expandOnHover)
#: rc.cpp:85
msgid "Expand on &Hover"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:298
#. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab)
#: rc.cpp:91
msgid "Taskbar Layout"
msgstr "Tálca beállítása"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:310
#. i18n: ectx: property (text), widget (QLabel, label_2)
#: rc.cpp:94
msgid "Row Constraints"
msgstr "Sor korlátozások"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:317
#. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel)
#: rc.cpp:97
msgid "&Minimum Rows:"
msgstr "&Sorok száma minimum:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:327
#. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows)
#: rc.cpp:100
msgid ""
"This defines the minimum row count. Some layouts stretch the filled rows "
"in order to fill any empty space. This way the displayed rows might be still "
"fewer than this value."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:340
#. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel)
#: rc.cpp:103
msgid "Ma&ximum Rows:"
msgstr "Sorok száma maximum:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:350
#. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows)
#: rc.cpp:106
msgid "This defines the maximum row count."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:390
#. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel)
#: rc.cpp:109
msgid "&Layout:"
msgstr "Elrendezés"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:423
#. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout)
#: rc.cpp:112
msgid ""
"
The layout is responsible for the size and placement of the task items.\n"
"Each of the provided layouts has other advantages and disadvantages.\n"
"Because I can't decide which layouting strategy is best suited for this "
"purpose I include several choices for now.
\n"
"\n"
"
By Taskbar Shape
\n"
"
This layout creates as much rows as are needed so that following "
"condition is met:
\n"
"
row height × row aspect ratio ≤ row width
\n"
"
However, if this would yield empty rows the filled rows are scaled in "
"height so that the whole task bar space is covered.
\n"
"\n"
"
Maximum Squeeze
\n"
"
Because the width of the task items depends of their height the more rows "
"there are the less room the items occupy.\n"
"This layout sets the width of the task items always to the width they would "
"have when the row count would have reached the maximally allowed value.\n"
"\n"
"
Fixed Item Number per Row
\n"
"
This layout always put the configured number of task items into one row, "
"unless there would not be enough room for all task items.\n"
"Then the items are distributed evenly over the rows.
\n"
"\n"
"
Limited Squeeze
\n"
"
This layout tries to squeeze the task items only up to a given maximum "
"squeeze ratio. If it would have to squeeze them more than that it creates a "
"new row. Currently this layout is the only one that respects the “Prefer "
"Grouping” setting.
\n"
"\n"
"
Fixed Maximum Item Height
\n"
"
This layout always assumes the configured height of the task items.\n"
"Through the dependency between the width and height of the task items this "
"leads to a specific distribution of the items.\n"
"This layout does not fill empty space by up-scaling the rows.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:448
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:138
msgid "Row &Aspect Ratio:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:461
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:141
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:144
msgid "&Items per Row:"
msgstr "Soronkénti elemek:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:496
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:147
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:509
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:150
msgid "Maximum Item &Height:"
msgstr "Elemek maximális magassága:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:522
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:153
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the "
"size of the task items."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:538
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:159
#, fuzzy
msgid "Maximum &Squeeze Ratio:"
msgstr "Maximális összenyomás"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:551
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:162
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:573
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:165
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
#, fuzzy
msgid "&Prefer Grouping"
msgstr "Csoportosítás:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:171
msgid "Tool Tip"
msgstr "&Gyorsnézet"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:174
msgid "Preview St&yle:"
msgstr "&Gyorsnézet stílusa:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:604
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:177
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:611
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:184
msgid "Preview Si&ze:"
msgstr "&Gyorsnézet mérete:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:621
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:187
msgid ""
"This value defines the maximum length of one side of window previews."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:654
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:193
msgid "Tool Tip &Type:"
msgstr "&Gyorsnézet típusa:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:671
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:196
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:785
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:206 rc.cpp:215 rc.cpp:233
msgid "ms"
msgstr " mp"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:706
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:209
#, fuzzy
msgid "Move &Duration:"
msgstr "Animáció sebessége:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:716
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:212
msgid "&Highlight Delay:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:740
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:218
msgid "Animation"
msgstr "&Animáció"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:746
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:221
msgid "&Frames per Second:"
msgstr "Képkocka per másodperc:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:756
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:224
msgid "fps"
msgstr " fps"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:772
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:227
msgid "&Animation Duration:"
msgstr "Animáció sebessége:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:782
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:230
msgid ""
"This defines the duration of animations like the expansion of tasks and "
"the delay for which a tool tip will be shown after you stopped hovering the "
"task item or tool tip."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:801
#. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel)
#: rc.cpp:236
#, fuzzy
msgid "Animation Speed:"
msgstr "&Animáció"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:825
#. i18n: ectx: attribute (title), widget (QWidget, lightsTab)
#: rc.cpp:239
#, fuzzy
msgid "Lights"
msgstr "Ragyogás"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:843
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:242
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:846
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:245
msgid "&Lights"
msgstr "Ragyogás"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:859
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:248
msgid "&Color:"
msgstr "Szín"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:893
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:251
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:896
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:254
msgid "Color From &Icon"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:257
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:912
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:260
msgid "As &Only Hover Effect"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:925
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:263
msgid "Anchor Light:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:955
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled)
#: rc.cpp:266
msgid "Anchor horizontally at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:965
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled)
#: rc.cpp:269
msgid "Anchor vertically at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:286
msgid "Grouping & Sorting"
msgstr "Csoportosítás és Rendezés"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:289
msgid "&Grouping:"
msgstr "Csoportosítás:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:292
msgid "Only when the taskbar is &full"
msgstr "Csak ha a tálca tele van"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:295
msgid "&Sorting:"
msgstr "Rendezés:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:298
msgid "Filters"
msgstr "Szűrők"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:301
msgid "Only show tasks that are &minimized"
msgstr "Csak a minimalizált feladatokat mutassa"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:304
msgid "Only show tasks from the current &desktop"
msgstr "Csak a jelenlegi asztal feladatait mutassa"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:307
msgid "Only show tasks from the current s&creen"
msgstr "Csak a jelenlegi képernyő feladatait mutassa"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:310
msgid "Middle Click &Action:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:313
msgid "Action that should be performed when a task item is middle clicked."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds)
#: rc.cpp:316
msgid "Form"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:319
msgid ""
"The margin sizes for task bar buttons are not designed for having a light "
"effect in the middle of a button. If the light effect looks strange you can "
"define custom button margins for the light here."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36
#. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom)
#: rc.cpp:322
msgid "enable custom margin sizes"
msgstr ""

#: rc.cpp:323
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Nitai"

#: rc.cpp:324
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "sitan@index.hu"
plasma-widget-smooth-tasks/po/cs.po000644 000765 000765 00000071074 11724514472 020175 0ustar00salvosalvo000000 000000 # 2009-08-28
# Daniel Schemala <28364@web.de>, 2010.
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: grosser.meister.morti@gmx.net\n"
"POT-Creation-Date: 2010-01-12 22:42+0100\n"
"PO-Revision-Date: 2010-01-12 21:58+0100\n"
"Last-Translator: Daniel Schemala <28364@web.de>\n"
"Language-Team: Deutsch \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 1.0\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Language: cs_CZ\n"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, General)
#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:17
#. i18n: ectx: property (accessibleName), widget (QWidget, General)
#: ../applet/SmoothTasks/Applet.cpp:641 rc.cpp:280 rc.cpp:283
msgid "General"
msgstr "Obecné"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:6
#. i18n: ectx: property (windowTitle), widget (QWidget, Appearance)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:9
#. i18n: ectx: property (accessibleName), widget (QWidget, Appearance)
#: ../applet/SmoothTasks/Applet.cpp:645 rc.cpp:3 rc.cpp:6
msgid "Appearance"
msgstr "Vzhled"

#: ../applet/SmoothTasks/Applet.cpp:649
msgid "Workarounds"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:660
msgid "Do Not Group"
msgstr "Neseskupovat"

#: ../applet/SmoothTasks/Applet.cpp:662
msgid "By Program Name"
msgstr "Podle názvu programu"

#: ../applet/SmoothTasks/Applet.cpp:672
msgid "Do Not Sort"
msgstr "Neseřazovat"

#: ../applet/SmoothTasks/Applet.cpp:673
msgid "Manually"
msgstr "Ručně"

#: ../applet/SmoothTasks/Applet.cpp:674
msgid "Alphabetically"
msgstr "Podle abecedy"

#: ../applet/SmoothTasks/Applet.cpp:675
msgid "By Desktop"
msgstr "Podle plochy"

#: ../applet/SmoothTasks/Applet.cpp:679
msgid "No Action"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:680
msgid "Close Task"
msgstr ""

#: ../applet/SmoothTasks/Applet.cpp:681
#, fuzzy
msgid "Move to Current Desktop"
msgstr "Z aktivní plochy"

#: ../applet/SmoothTasks/Applet.cpp:685
msgid "Rectangle"
msgstr "Obdélník"

#: ../applet/SmoothTasks/Applet.cpp:686
msgid "Square"
msgstr "Čtverec"

#: ../applet/SmoothTasks/Applet.cpp:721 ../applet/SmoothTasks/Applet.cpp:740
msgid "None"
msgstr "Žádné"

#: ../applet/SmoothTasks/Applet.cpp:722
msgid "Smooth"
msgstr "Plynulé"

#: ../applet/SmoothTasks/Applet.cpp:723
msgid "Plasma"
msgstr "Plasma"

#: ../applet/SmoothTasks/Applet.cpp:727
msgid "By Taskbar Shape"
msgstr "Podle velikosti"

#: ../applet/SmoothTasks/Applet.cpp:728
msgid "Maximum Squeeze"
msgstr "Podle maximální velikosti"

#: ../applet/SmoothTasks/Applet.cpp:729
msgid "Fixed Item Number per Row"
msgstr "Pevný počet položek v řadě"

#: ../applet/SmoothTasks/Applet.cpp:730
msgid "Limited Squeeze"
msgstr "Omezené stlačení"

#: ../applet/SmoothTasks/Applet.cpp:731
msgid "Fixed Maximum Item Height"
msgstr "Pevná maximální výška položky"

#: ../applet/SmoothTasks/Applet.cpp:741
msgid "Active"
msgstr "Aktivní"

#: ../applet/SmoothTasks/Applet.cpp:742
msgid "From the current desktop"
msgstr "Z aktivní plochy"

#: ../applet/SmoothTasks/Applet.cpp:743
msgid "All"
msgstr "Všechny"

#: ../applet/SmoothTasks/Applet.cpp:749
msgid "Classic"
msgstr "Klasické"

#: ../applet/SmoothTasks/Applet.cpp:750
msgid "New"
msgstr "Nový"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:81
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:105
#: ../applet/SmoothTasks/Task.cpp:122
#: ../applet/SmoothTasks/WindowPreview.cpp:270
msgid "On all desktops"
msgstr "Na všech plochách"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:82
#: ../applet/SmoothTasks/PlasmaToolTip.cpp:108
#: ../applet/SmoothTasks/Task.cpp:123
#: ../applet/SmoothTasks/WindowPreview.cpp:271
msgctxt "Which virtual desktop a window is currently on"
msgid "On %1"
msgstr "Na %1"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:107
msgid "On various desktops"
msgstr "Na různých plochách"

#: ../applet/SmoothTasks/PlasmaToolTip.cpp:114
#: ../applet/SmoothTasks/Task.cpp:117
#: ../applet/SmoothTasks/WindowPreview.cpp:268
msgid "Starting application..."
msgstr "Spouští se aplikace..."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:16
#. i18n: ectx: attribute (title), widget (QWidget, taskItemsTab)
#: rc.cpp:9
msgid "Task Items"
msgstr "Položky"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:22
#. i18n: ectx: property (text), widget (QLabel, taskShapeLabel)
#: rc.cpp:12
msgid "Task &Shape:"
msgstr "&Tvar položek:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:38
#. i18n: ectx: property (toolTip), widget (QComboBox, shape)
#: rc.cpp:15
msgid ""
"
This setting is only effective when there is enough room in the taskbar "
"to display the task items in the according shape.
\n"
"\n"
"
Rectangle
\n"
"
Displays collapsed task items as rectangles.
\n"
"\n"
"
Square
\n"
"
Displays collapsed task items as squares.
"
msgstr ""
"
Toto nastavení je použito pouze pokud je má applet dost místa, aby "
"zobrazil ikony ve správném tvaru
\n"
"\n"
"
Obdelník
\n"
"
Zobrazí nerozšířené úlohy jako obdélníky 
\n"
"\n"
"
Čtverec
\n"
"
Zobrazí nerozšířené úlohy jako čverce
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:45
#. i18n: ectx: property (text), widget (QLabel, spaceLabel)
#: rc.cpp:24
msgid "Space &Between Tasks:"
msgstr "Prostor mezi ikonami:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:55
#. i18n: ectx: property (suffix), widget (QSpinBox, taskSpacing)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:79
#. i18n: ectx: property (suffix), widget (QSpinBox, minTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:96
#. i18n: ectx: property (suffix), widget (QSpinBox, maxTextSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:216
#. i18n: ectx: property (suffix), widget (QSpinBox, expandingSize)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:284
#. i18n: ectx: property (suffix), widget (QSpinBox, minIconSpace)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:525
#. i18n: ectx: property (suffix), widget (QSpinBox, itemHeight)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:624
#. i18n: ectx: property (suffix), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:27 rc.cpp:36 rc.cpp:42 rc.cpp:76 rc.cpp:88 rc.cpp:156 rc.cpp:190
msgid "px"
msgstr "px"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:65
#. i18n: ectx: property (text), widget (QLabel, minIconSpaceLabel)
#: rc.cpp:30
msgid "minimal icon space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:72
#. i18n: ectx: property (text), widget (QLabel, minTextSpaceLabel)
#: rc.cpp:33
msgid "minimal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:89
#. i18n: ectx: property (text), widget (QLabel, maxTextSpaceLabel)
#: rc.cpp:39
msgid "maximal text space:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:109
#. i18n: ectx: property (text), widget (QLabel, iconScaleLabel)
#: rc.cpp:45
msgid "&Icon Scale:"
msgstr "&Velikost ikony:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:119
#. i18n: ectx: property (toolTip), widget (QSpinBox, iconScale)
#: rc.cpp:48
msgid ""
"The scale of the task icons in relation to the height/width (whatever is "
"smaller) of the task item."
msgstr "Měřítko velikosti ikony podle výšky/šířky (co je menší) položky"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:122
#. i18n: ectx: property (suffix), widget (QSpinBox, iconScale)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:975
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorHorizontal)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:991
#. i18n: ectx: property (suffix), widget (QSpinBox, lightAnchorVertical)
#: rc.cpp:52 rc.cpp:273 rc.cpp:277
#, no-c-format
msgid "%"
msgstr "%"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:138
#. i18n: ectx: property (toolTip), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:55
msgid ""
"For some plasma themes task items might look better when their frames "
"are not rotated. This only concerns vertical layouts, e.g. when you place "
"the taskbar at the left (or right) screen edge."
msgstr ""
"Pro některé motivy plasmy můžou neotočené rámečky vypadat lépe. \n"
"Týká se to pouze případů, kdy je panel umístěný po stranách obrazovky"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:141
#. i18n: ectx: property (text), widget (QCheckBox, dontRotateFrame)
#: rc.cpp:58
msgid "Don't &Rotate Frames"
msgstr "Neotáčet rámečky"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:148
#. i18n: ectx: property (text), widget (QCheckBox, textShadow)
#: rc.cpp:61
msgid "Draw &Text-Shadow"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:158
#. i18n: ectx: property (text), widget (QCheckBox, scrollSwitchTasks)
#: rc.cpp:64
msgid "Switch Tasks using &Wheel"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:190
#. i18n: ectx: property (text), widget (QCheckBox, expandTasks)
#: rc.cpp:67
msgid "&Expand Tasks"
msgstr "&Rozšířit položky"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:200
#. i18n: ectx: property (text), widget (QLabel, expandingSizeLabel)
#: rc.cpp:70
msgid "E&xpanding Size:"
msgstr "Velikost rozšíření"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:213
#. i18n: ectx: property (toolTip), widget (QSpinBox, expandingSize)
#: rc.cpp:73
msgid ""
"This is the additional size that gets added to a task item when it "
"expands. Keep in mind that the task items might not be able to expand fully "
"when there is not enough room."
msgstr ""
"Velikost o kterou je položka rozšířená.\n"
"Tato hodnota je dosažena, pouze pokud je dostatek místa"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:235
#. i18n: ectx: property (text), widget (QLabel, keepExpandedLabel)
#: rc.cpp:79
msgid "&Keep Expanded:"
msgstr "Ponechat rozšířené:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:264
#. i18n: ectx: property (text), widget (QCheckBox, expandOnAttention)
#: rc.cpp:82
msgid "Expand on &Attention"
msgstr "Rozšířit při označení"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:274
#. i18n: ectx: property (text), widget (QCheckBox, expandOnHover)
#: rc.cpp:85
msgid "Expand on &Hover"
msgstr "Rozšířit při označení"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:298
#. i18n: ectx: attribute (title), widget (QWidget, taskbarLayoutTab)
#: rc.cpp:91
msgid "Taskbar Layout"
msgstr "Uspořádání panelu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:310
#. i18n: ectx: property (text), widget (QLabel, label_2)
#: rc.cpp:94
msgid "Row Constraints"
msgstr "Omezení počtu řad"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:317
#. i18n: ectx: property (text), widget (QLabel, minimumRowsLabel)
#: rc.cpp:97
msgid "&Minimum Rows:"
msgstr "&Minimální počet řad"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:327
#. i18n: ectx: property (toolTip), widget (QSpinBox, minimumRows)
#: rc.cpp:100
msgid ""
"This defines the minimum row count. Some layouts stretch the filled rows "
"in order to fill any empty space. This way the displayed rows might be still "
"fewer than this value."
msgstr ""
"Toto definuje minimální počet řad. Některé uspořádání\n"
" roztahují naplněné řady, aby obsadili prázdný prostor"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:340
#. i18n: ectx: property (text), widget (QLabel, maximumRowsLabel)
#: rc.cpp:103
msgid "Ma&ximum Rows:"
msgstr "Ma&ximální počet řad"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:350
#. i18n: ectx: property (toolTip), widget (QSpinBox, maximumRows)
#: rc.cpp:106
msgid "This defines the maximum row count."
msgstr "Definuje maximální počet řad"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:390
#. i18n: ectx: property (text), widget (QLabel, taskbarLayoutLabel)
#: rc.cpp:109
msgid "&Layout:"
msgstr "Uspořádání:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:423
#. i18n: ectx: property (toolTip), widget (QComboBox, taskbarLayout)
#: rc.cpp:112
msgid ""
"
The layout is responsible for the size and placement of the task items.\n"
"Each of the provided layouts has other advantages and disadvantages.\n"
"Because I can't decide which layouting strategy is best suited for this "
"purpose I include several choices for now.
\n"
"\n"
"
By Taskbar Shape
\n"
"
This layout creates as much rows as are needed so that following "
"condition is met:
\n"
"
row height × row aspect ratio ≤ row width
\n"
"
However, if this would yield empty rows the filled rows are scaled in "
"height so that the whole task bar space is covered.
\n"
"\n"
"
Maximum Squeeze
\n"
"
Because the width of the task items depends of their height the more rows "
"there are the less room the items occupy.\n"
"This layout sets the width of the task items always to the width they would "
"have when the row count would have reached the maximally allowed value.\n"
"\n"
"
Fixed Item Number per Row
\n"
"
This layout always put the configured number of task items into one row, "
"unless there would not be enough room for all task items.\n"
"Then the items are distributed evenly over the rows.
\n"
"\n"
"
Limited Squeeze
\n"
"
This layout tries to squeeze the task items only up to a given maximum "
"squeeze ratio. If it would have to squeeze them more than that it creates a "
"new row. Currently this layout is the only one that respects the “Prefer "
"Grouping” setting.
\n"
"\n"
"
Fixed Maximum Item Height
\n"
"
This layout always assumes the configured height of the task items.\n"
"Through the dependency between the width and height of the task items this "
"leads to a specific distribution of the items.\n"
"This layout does not fill empty space by up-scaling the rows.
"
msgstr ""
"
Uspořádání je odpovědné za velikost a umístění položek.\n"
"Každé poskytované uspořádání má své výhody a nevýhody.\n"
"Protože nelze určit, které je nejlepší, \n"
"tak si můžete sami vybrat.
\n"
"\n"
"
Podle velikosti
\n"
"
Toto uspořádání vytváří tolik řad, kolik je potřeba, \n"
"aby byla splněna podmínka:
\n"
"
šířka řady × poměr délky řady ≤ délka řady
\n"
"\n"
"
Podle maximální velikosti
\n"
"
Jelikož šířka položek závisí na jejich výšce,\n"
" tak čím více je řad, tím měně místa položky zabírají.\n"
"Toto uspořádání nastavuje šířku úloh takovou jakou,\n"
" jakou by měly pokud by počet řad dosáhl svého maximální počtu\n"
"\n"
"
Omezené stlačení ikon
\n"
"
Toto uspořádání se snaží udržet stlačení ikon pod určitou mez. Pokud\n"
"jsou ikony moc stlačené (jak moc si můžete nastavit) tak se vytvoří nová "
"řada. \n"
"Pokud chcete, aby se při nedostatku místa nejdříve ikony seskupily, tak "
"vyberte \n"
"volbu ”Preferovat seskupování”. 
\n"
"\n"
"
Pevný počet položek v řadě
\n"
"
Toto uspořádání dá do jedné řády maximálně přednastavený počet položek\n"
"
Pevná maximální výška položky
\n"
"
Toto uspořádání vždy předpokládá nastavenou výšku položky.\n"
"Pomocí závislosti mezi výškou a šířkou položky se to pokusí správně rozdělit "
"položky.\n"
"Toto uspořádání nevyplňuje prázdný prostor způsobený zvětšením řad.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:448
#. i18n: ectx: property (text), widget (QLabel, rowAspectRatioLabel)
#: rc.cpp:138
msgid "Row &Aspect Ratio:"
msgstr "Poměr délky řady"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:461
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, rowAspectRatio)
#: rc.cpp:141
msgid ""
"The “By Taskbar Shape” layout uses this value to determine how many rows "
"should be created."
msgstr ""
"Uspořádní “Podle velikosti“ používá tuto hodnotu\n"
" ke zjištění kolik řad by mělo být vytvořeno"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:483
#. i18n: ectx: property (text), widget (QLabel, itemsPerRowLabel)
#: rc.cpp:144
msgid "&Items per Row:"
msgstr "Počet položek na řadu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:496
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemsPerRow)
#: rc.cpp:147
msgid ""
"The “Fixed Item Number per Row” layout uses this amount to fill the rows "
"with task items."
msgstr ""
"Uspořádání “Pevný počet položek v řadě“  používá tuto hodnotu pro naplnění "
"řady"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:509
#. i18n: ectx: property (text), widget (QLabel, itemHeightLabel)
#: rc.cpp:150
msgid "Maximum Item &Height:"
msgstr "Maximální výška položky"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:522
#. i18n: ectx: property (toolTip), widget (QSpinBox, itemHeight)
#: rc.cpp:153
msgid ""
"The “Fixed Maximum Item Height” layout uses this value to determine the "
"size of the task items."
msgstr ""
"Uspořádní “Pevná maximální výška položky“ používá tuto hodnotu\n"
"ke zjištění velikosti položek"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:538
#. i18n: ectx: property (text), widget (QLabel, squeezeRatioLabel)
#: rc.cpp:159
msgid "Maximum &Squeeze Ratio:"
msgstr "Podle maximální velikosti"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:551
#. i18n: ectx: property (toolTip), widget (QDoubleSpinBox, squeezeRatio)
#: rc.cpp:162
msgid ""
"
The “Limited Squeeze” layout tries not to squeeze items so that "
"squeezed item width / item width ≥ maximum squeeze ratio.
"
msgstr ""
"
Uspořádání “Omezené stlačení” se snaží aby stlačení ikon odpovídalo "
"podmínce stlačená šířka položky / šířka položky ≥ maximální stlačení.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:573
#. i18n: ectx: property (toolTip), widget (QCheckBox, preferGrouping)
#: rc.cpp:165
msgid ""
"Prefere grouping of tasks over the creation of new rows (currently only "
"supported by the Limited Squeeze” layout)."
msgstr ""
"Preferovat seskupování ikon před vytvořením nové řady (podporováno pouze "
"uspořádáním “Omezené stlačení”)."

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:576
#. i18n: ectx: property (text), widget (QCheckBox, preferGrouping)
#: rc.cpp:168
msgid "&Prefer Grouping"
msgstr "&Preferovat seskupování"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:584
#. i18n: ectx: attribute (title), widget (QWidget, toolTipTab)
#: rc.cpp:171
msgid "Tool Tip"
msgstr "Nástrojové tipy"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:590
#. i18n: ectx: property (text), widget (QLabel, previewLayoutLabel)
#: rc.cpp:174
msgid "Preview St&yle:"
msgstr "&Styl náhledu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:604
#. i18n: ectx: property (toolTip), widget (QComboBox, previewLayout)
#: rc.cpp:177
msgid ""
"
Classic
\n"
"
\n"
"\n"
"
New
\n"
"
"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:611
#. i18n: ectx: property (text), widget (QLabel, maxPreviewSizeLabel)
#: rc.cpp:184
msgid "Preview Si&ze:"
msgstr "&Velikost náhledu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:621
#. i18n: ectx: property (toolTip), widget (QSpinBox, maxPreviewSize)
#: rc.cpp:187
msgid ""
"This value defines the maximum length of one side of window previews."
msgstr "Maximální sířka/výška náhledu"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:654
#. i18n: ectx: property (text), widget (QLabel, toolTipKindLabel)
#: rc.cpp:193
msgid "Tool Tip &Type:"
msgstr "&Typ náhledu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:671
#. i18n: ectx: property (toolTip), widget (QComboBox, toolTipKind)
#: rc.cpp:196
msgid ""
"
None
\n"
"
Don't display tool tips.
\n"
"\n"
"
Smooth
\n"
"
Use advanced tool tips for the task items. These tool tips show window "
"previews that can be clicked to activate the corresponding window. When you "
"hover the preview the window gets highlighted. However, this kind of tool "
"tip is not well integrated with plasma.
\n"
"\n"
"
Plasma
\n"
"
Use native plasma tool tips. This kind of tool tips do not provide the "
"features described above. Instead they integrate well with other applet's "
"tool tips and move animated across applets.
"
msgstr ""
"
Žádný
\n"
"
Nezobrazuje žádné náhledy.
\n"
"\n"
"
Plynulé
\n"
"
Používá vylepšené náhledy, na náhledy se dá klikonout pro vybrání.\n"
"Po najetí myší se vybrané onko zvýrazní (kwin efekt).\n"
"Bohužel tyto vylepšené náhledy nejou plně integrovány v plasmé
\n"
"\n"
"
Plasma
\n"
"
Originální náhledy správce aplikací. Neposkytují takové možnosti\n"
"jako předchozí, ale jsou lépe integrovány.
"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:693
#. i18n: ectx: property (suffix), widget (QSpinBox, tooltipMoveDuration)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:726
#. i18n: ectx: property (suffix), widget (QSpinBox, highlightDelay)
#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:785
#. i18n: ectx: property (suffix), widget (QSpinBox, animationDuration)
#: rc.cpp:206 rc.cpp:215 rc.cpp:233
msgid "ms"
msgstr "ms"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:706
#. i18n: ectx: property (text), widget (QLabel, tooltipMoveDurationLabel)
#: rc.cpp:209
#, fuzzy
msgid "Move &Duration:"
msgstr "Doba trvání animace"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:716
#. i18n: ectx: property (text), widget (QLabel, highlightDelayLabel)
#: rc.cpp:212
msgid "&Highlight Delay:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:740
#. i18n: ectx: attribute (title), widget (QWidget, animationTab)
#: rc.cpp:218
msgid "Animation"
msgstr "Animace"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:746
#. i18n: ectx: property (text), widget (QLabel, fpsLabel)
#: rc.cpp:221
msgid "&Frames per Second:"
msgstr "Snímků za sekundu:"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:756
#. i18n: ectx: property (suffix), widget (QSpinBox, fps)
#: rc.cpp:224
msgid "fps"
msgstr "fps"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:772
#. i18n: ectx: property (text), widget (QLabel, animationDurationLabel)
#: rc.cpp:227
msgid "&Animation Duration:"
msgstr "Doba trvání animace"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:782
#. i18n: ectx: property (toolTip), widget (QSpinBox, animationDuration)
#: rc.cpp:230
msgid ""
"This defines the duration of animations like the expansion of tasks and "
"the delay for which a tool tip will be shown after you stopped hovering the "
"task item or tool tip."
msgstr ""
"Toto definuje trvání animace jako je rozšíření úlohy a zpoždění\n"
" po které bude náhled zobrazován po odsunití myši"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:801
#. i18n: ectx: property (text), widget (QLabel, animationSpeedLabel)
#: rc.cpp:236
#, fuzzy
msgid "Animation Speed:"
msgstr "Animace"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:825
#. i18n: ectx: attribute (title), widget (QWidget, lightsTab)
#: rc.cpp:239
#, fuzzy
msgid "Lights"
msgstr "Podsvícení"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:843
#. i18n: ectx: property (toolTip), widget (QCheckBox, lights)
#: rc.cpp:242
msgid ""
"When this is checked a blob of light is drawn on the task items when you "
"hover them or when they demand attention."
msgstr ""
"Povolí zobrazení podsvícení pod položkami, \n"
"když jsou označeny nebo vyžadují pozornost"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:846
#. i18n: ectx: property (text), widget (QCheckBox, lights)
#: rc.cpp:245
msgid "&Lights"
msgstr "Podsvícení"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:859
#. i18n: ectx: property (text), widget (QLabel, colorLabel)
#: rc.cpp:248
msgid "&Color:"
msgstr "Barva"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:893
#. i18n: ectx: property (toolTip), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:251
msgid ""
"When this is checked the dominant color of the task icon is used as the "
"light color. When only an ugly (grayish) color could be extracted the color "
"specified above is used instead."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:896
#. i18n: ectx: property (text), widget (QCheckBox, lightColorFromIcon)
#: rc.cpp:254
msgid "Color From &Icon"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:909
#. i18n: ectx: property (toolTip), widget (QCheckBox, onlyLights)
#: rc.cpp:257
msgid ""
"Usually a different frame for hovered task items is used. But for some "
"plasma themes this might look ugly in combination with the light effect. "
"Using this option you can deactivate the usage of a different task item "
"frame on hover."
msgstr ""
"Použije pouze efekt “podsvícení“ pouze při najetí myší \n"
"(tzn. nezmění tvar a zvýraznění rámečku)"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:912
#. i18n: ectx: property (text), widget (QCheckBox, onlyLights)
#: rc.cpp:260
msgid "As &Only Hover Effect"
msgstr "Pouze efekt podsvícení"

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:925
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:263
msgid "Anchor Light:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:955
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorHorizontalEnabled)
#: rc.cpp:266
msgid "Anchor horizontally at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Appearance.ui:965
#. i18n: ectx: property (text), widget (QCheckBox, lightAnchorVerticalEnabled)
#: rc.cpp:269
msgid "Anchor vertically at:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:44
#. i18n: ectx: property (text), widget (QLabel, groupingAndSportingLabel)
#: rc.cpp:286
msgid "Grouping & Sorting"
msgstr "Seskupování & řazení"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:51
#. i18n: ectx: property (text), widget (QLabel, groupingLabel)
#: rc.cpp:289
msgid "&Grouping:"
msgstr "&Seskupování:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:89
#. i18n: ectx: property (text), widget (QCheckBox, onlyGroupWhenFull)
#: rc.cpp:292
msgid "Only when the taskbar is &full"
msgstr "Pouze pokud je taskbar plný"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:98
#. i18n: ectx: property (text), widget (QLabel, sortingLabel)
#: rc.cpp:295
msgid "&Sorting:"
msgstr "Řa&zení:"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:136
#. i18n: ectx: property (text), widget (QLabel, filtersLabel)
#: rc.cpp:298
msgid "Filters"
msgstr "Filtry"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:161
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyMinimized)
#: rc.cpp:301
msgid "Only show tasks that are &minimized"
msgstr "Ukaž pouze &minimalizované úlohy"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:188
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentDesktop)
#: rc.cpp:304
msgid "Only show tasks from the current &desktop"
msgstr "Ukaž úlohy pouze ze &současné plochy"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:215
#. i18n: ectx: property (text), widget (QCheckBox, showOnlyCurrentScreen)
#: rc.cpp:307
msgid "Only show tasks from the current s&creen"
msgstr "Ukaž úlohy pouze z &aktuální obrazovky"

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:237
#. i18n: ectx: property (text), widget (QLabel, middleClickActionLabel)
#: rc.cpp:310
msgid "Middle Click &Action:"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/General.ui:247
#. i18n: ectx: property (toolTip), widget (QComboBox, middleClickAction)
#: rc.cpp:313
msgid "Action that should be performed when a task item is middle clicked."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:14
#. i18n: ectx: property (windowTitle), widget (QWidget, Workarounds)
#: rc.cpp:316
msgid "Form"
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:26
#. i18n: ectx: property (text), widget (QLabel, label)
#: rc.cpp:319
msgid ""
"The margin sizes for task bar buttons are not designed for having a light "
"effect in the middle of a button. If the light effect looks strange you can "
"define custom button margins for the light here."
msgstr ""

#. i18n: file: ../applet/SmoothTasks/Ui/Workarounds.ui:36
#. i18n: ectx: property (text), widget (QCheckBox, taskButtonMarginsCustom)
#: rc.cpp:322
msgid "enable custom margin sizes"
msgstr ""

#: rc.cpp:323
msgctxt "NAME OF TRANSLATORS"
msgid "Your names"
msgstr "Michal Odstrčil"

#: rc.cpp:324
msgctxt "EMAIL OF TRANSLATORS"
msgid "Your emails"
msgstr "michal@qmail.com"
plasma-widget-smooth-tasks/CMakeLists.txt000644 000765 000765 00000000141 11724514472 021335 0ustar00salvosalvo000000 000000 find_package(KDE4 REQUIRED)
include(KDE4Defaults)

add_subdirectory(po)
add_subdirectory(applet)
plasma-widget-smooth-tasks/COPYING000644 000765 000765 00000035427 11724514472 017647 0ustar00salvosalvo000000 000000 		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

			    NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

		     END OF TERMS AND CONDITIONS
plasma-widget-smooth-tasks/INSTALL000644 000765 000765 00000001102 11724514472 017624 0ustar00salvosalvo000000 000000 To install plasmoid unpack archive, go to the directory
where this INSTALL file is and execute commands:

mkdir build
cd build
cmake .. -DCMAKE_INSTALL_PREFIX=`kde4-config --prefix`
make -j 2
sudo make install
kquitapp plasma-desktop && sleep 2 && plasma-desktop

Replace the "2" with the number of cores your computer has
to speed up the compile process (the runtime speed of the
compiled applet is unaffected by this).

On some installations the last line has to be this instead:
kquitapp plasma && sleep 2 && plasma

After that plasmoid should show up in add widgets dialog.
plasma-widget-smooth-tasks/smooth-tasks-9999.ebuild000644 000765 000765 00000001242 11724514472 023043 0ustar00salvosalvo000000 000000 # 
# Distributed under the terms of the GNU General Public License v2
# $Header: $

EAPI=3

KDE_LINGUAS="cs de fr hu pl ru tr uk_UA zh_CN"
KDE_MINIMAL="4.8"
inherit kde4-base
inherit mercurial

DESCRIPTION="Alternate taskbar KDE plasmoid, similar to Windows 7"
HOMEPAGE="http://bitbucket.org/flupp/smooth-tasks-fork"
EHG_REPO_URI="http://bitbucket.org/flupp/smooth-tasks-fork"
EHG_REVISION="kde-4.8"

LICENSE="GPL-2"
SLOT="4"
KEYWORDS="~amd64 ~x86"
IUSE="debug"

DEPEND="
        $(add_kdebase_dep libtaskmanager)
"
RDEPEND="${DEPEND}
        $(add_kdebase_dep plasma-workspace)
"

src_prepare() {
        mv ${WORKDIR}/${PN} ${WORKDIR}/${P}
        kde4-base_src_prepare
}