Ubuntu UI Toolkit

components.api (+9/-12)
modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml (+30/-29)
modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml (+0/-1)
modules/Ubuntu/Components/plugin/plugin.cpp (+1/-0)
modules/Ubuntu/Components/plugin/plugin.pro (+4/-3)
modules/Ubuntu/Components/plugin/ucaction.h (+1/-1)
modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp (+132/-0)
modules/Ubuntu/Components/plugin/uclistitem.cpp (+250/-168)
modules/Ubuntu/Components/plugin/uclistitem.h (+58/-7)
modules/Ubuntu/Components/plugin/uclistitem_p.h (+75/-13)
modules/Ubuntu/Components/plugin/uclistitemactions.cpp (+26/-271)
modules/Ubuntu/Components/plugin/uclistitemactions.h (+1/-65)
modules/Ubuntu/Components/plugin/uclistitemactions_p.h (+0/-16)
modules/Ubuntu/Components/plugin/uclistitemattached.cpp (+93/-159)
modules/Ubuntu/Components/plugin/uclistitemstyle.h (+1/-1)
modules/Ubuntu/Components/plugin/ucviewitemsattached.cpp (+34/-29)
tests/resources/listitems/ListItemTest.qml (+8/-3)
tests/unit_x11/tst_components/tst_listitem.qml (+13/-4)

To merge this branch:

bzr merge lp:~zsombi/ubuntu-ui-toolkit/76-refactoring

Related bugs:

Bug #1403005: New ListItem TypeError

Medium

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2015-01-19
Tim Peeters		2015-01-07	Approve on 2015-01-19
Review via email: mp+245714@code.launchpad.net

Commit message

Small refactoring to follow upstream concept on naming attached properties. Panels visualising ListItemActions are owned by ListItem and not being shared by the ListItemActiomns. In this way the same ListItemActions instance can be used on both leading and trailing side.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-07:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1348/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-08:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1350/rebuild

review: Approve (continuous-integration)

lp:~zsombi/ubuntu-ui-toolkit/76-refactoring updated on 2015-01-12

1394. By Zsombor Egri on 2015-01-12: missing reset function

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-12:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1354/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-12:

ubuntuuitoolkit.tests.custom_proxy_objects.test_header.ActionsTestCase.test_click_header_action_button_with_hidden_header(actions)
Failure ain't has anything to do with the changes in this MR.

lp:~zsombi/ubuntu-ui-toolkit/76-refactoring updated on 2015-01-12

1395. By Zsombor Egri on 2015-01-12: staging sync
1396. By Zsombor Egri on 2015-01-12: binding loop on swiping fixed; multiple panel swiping fixed

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

62 - ListItemActions.visibleActions.length * MathUtils.clamp(visualizedActionWidth, height, actionsRow.maxItemWidth))
63 + ListItem.visibleActions.length * MathUtils.clamp(visualizedActionWidth, height, actionsRow.maxItemWidth))

visualizedActionWidth was there before, but I noticed this only now:
would it be more consistent with other QML classes if we named this paintedActionWidth? For example, Image has a paintedWidth.

Text had paintedWidth also.. but it seems to be removed in QtQuick 2.4? I don't see it here any more http://doc.qt.io/qt-5/qml-qtquick-text.html

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-12:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1355/rebuild

review: Approve (continuous-integration)

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

76 - readonly property bool leading: panel.ListItemActions.status == panel.ListItemActions.Leading
77 + readonly property bool leading: ListItem.panelStatus == ListItem.Leading

I like that a bunch of pieces of code become shorter :)

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

79 + /*
80 + Swiped offset.
81 + */
82 + readonly property real swipedOffset: leading ? width + x : ListItem.item.width - x;

would this be panelOffset? Or maybe just offset since we are inside ListItemPanel?

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

79 + /*
80 + Swiped offset.
81 + */
82 + readonly property real swipedOffset: leading ? width + x : ListItem.item.width - x;
83 +
84 + /*
85 + Swiping
86 + */
87 + readonly property bool swiping: ListItem.item.highlighted && ListItem.item.contentMoving

The comments here don't add any information so can be removed.

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

94 + left: (leading ? undefined : ListItem.item.contentItem.right)
95 + right: (leading ? ListItem.item.contentItem.left : undefined)

remove the '(' and ')' here.

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

118 + Connections {
119 + target: panel.ListItem.item
120 + onContentMovementEnded: {
121 + if (actionsRow.selectedAction) {
122 + actionsRow.selectedAction.trigger(actionsRow.listItemIndex >= 0 ? actionsRow.listItemIndex : null);
123 + actionsRow.selectedAction = null;
124 + }

I'm just wondering if it would make sense to return -1 when listItemIndex < 0 (or listItemIndex is undefined?). That way in the Action.trigger(), the developer only has to deal with integer values.

review: Needs Information

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

143 - var snapPos = (ListItemActions.offset > ListItemActions.listItem.swipeOvershoot && snapIn) ? panel.width : 0.0;
144 - ListItemActions.snapToPosition(snapPos);
145 + var snapPos = (swipedOffset > units.gu(2) && snapIn) ? panel.width : 0.0;
146 + ListItem.snapToPosition(snapPos);
147 }

You replaced swipeOvershoot by a hard-coded value here. Is that an improvement? It is better to have a constant defined.

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

245 --- modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp 1970-01-01 00:00:00 +0000
246 +++ modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp 2015-01-12 15:45:30 +0000
247 @@ -0,0 +1,132 @@
248 +/*
249 + * Copyright 2014 Canonical Ltd.

I don't remember when was the first version of this file (no idea why the diff shows 1970), but let's make it 2015.

review: Needs Fixing

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

412 + // make sure teh animation is not running

your favorite typo ;)

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

412 + // make sure teh animation is not running
413 + snap->stop();
414 snap->setFrom(listItem->contentItem->property(snap->property().toLocal8Bit().constData()));
415 snap->setTo(to);
416 - snap->setAlwaysRunToEnd(true);
417 + snap->setAlwaysRunToEnd(false);

do you still need this now that you removed

195 - alwaysRunToEnd: true

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

423 +void UCListItemSnapAnimator::stop()
424 +{
425 + QQuickPropertyAnimation *snap = getDefaultAnimation();
426 + if (snap && snap->isRunning()) {
427 + snap->stop();
428 + }
429 +}

where do you use this?
perhaps you should be calling this function in snap() instead of calling snap->stop() there.

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

void UCListItem::setHighlightColor(const QColor &color)
{
    Q_D(UCListItem);
    if (d->highlightColor == color) {
        return;
    }
    d->highlightColor = color;
    // no more theme change watch
    d->customColor = true;
    update();
    Q_EMIT highlightColorChanged();
}
void UCListItem::resetHighlightColor()
{
    Q_D(UCListItem);
    d->customColor = false;
    d->highlightColor = getPaletteColor("selected", "background");
    update();
    Q_EMIT highlightColorChanged();
}

if you call setHighlightColor(color) // color == getPaletteColor("selected", "background") then customColor is not set to true, and you are still watching for palette updates, while it may be purely coincidence that you set the color to the palette color. So customColor = true should be moved before the if() (maybe update() too).

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

Since we only have an overshoot for swiping,
1131 +void UCListItemPrivate::resetSwipeOvershoot()
may be called resetOvershoot()?

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

1193 + Q_PROPERTY(UCListItemActions *actions READ actions NOTIFY actionsChanged)
1194 + Q_PROPERTY(QQmlListProperty<UCAction> visibleActions READ visibleActions NOTIFY visibleActionsChanged)
1195 + Q_PROPERTY(UCListItem *item READ item NOTIFY itemChanged)
1196 + Q_PROPERTY(int index READ index NOTIFY indexChanged)
1197 + Q_PROPERTY(UCListItem::PanelStatus panelStatus READ panelStatus NOTIFY panelStatusChanged)

why do we need to expose all of these publicly?

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

2459 ListItem {
2460 Label {
2461 + id: label2
2462 anchors.fill: parent
2463 - text: "Another standalone ListItem"
2464 + text: "Another standalone ListItem\nStarted with custom style, reset to theme style on first click"
2465 }
2466 leadingActions: testItem.leadingActions
2467 trailingActions: ListItemActions {
2468 actions: leading.actions
2469 }
2470 + style: ListItemStyle {}
2471 + onClicked: { style = undefined; label2.text = "Another standalone ListItem" }
2472 }

This example would be more interesting if the custom style did something. Now it is basically an Item.

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-12:

2526 + Component { id: customStyle; ListItemStyle {} }
2527 +
2528 + function test_style_reset() {
2529 + testItem.style = customStyle;
2530 + testItem.style = undefined;
2531 + verify(testItem.style != 0, "Style set back to theme")
2532 + }

; missing

You only verify here that the style is not 0. Can we get the type of the style and validate that?

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> void UCListItem::setHighlightColor(const QColor &color)
> {
> Q_D(UCListItem);
> if (d->highlightColor == color) {
> return;
> }
> d->highlightColor = color;
> // no more theme change watch
> d->customColor = true;
> update();
> Q_EMIT highlightColorChanged();
> }
> void UCListItem::resetHighlightColor()
> {
> Q_D(UCListItem);
> d->customColor = false;
> d->highlightColor = getPaletteColor("selected", "background");
> update();
> Q_EMIT highlightColorChanged();
> }
>
>
> if you call setHighlightColor(color) // color == getPaletteColor("selected",
> "background") then customColor is not set to true, and you are still watching
> for palette updates, while it may be purely coincidence that you set the color
> to the palette color. So customColor = true should be moved before the if()
> (maybe update() too).

Well, if a property's default value is set again as value, there will be no change done either.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 62 - ListItemActions.visibleActions.length *
> MathUtils.clamp(visualizedActionWidth, height, actionsRow.maxItemWidth))
> 63 + ListItem.visibleActions.length *
> MathUtils.clamp(visualizedActionWidth, height, actionsRow.maxItemWidth))
>
> visualizedActionWidth was there before, but I noticed this only now:
> would it be more consistent with other QML classes if we named this
> paintedActionWidth? For example, Image has a paintedWidth.
>
> Text had paintedWidth also.. but it seems to be removed in QtQuick 2.4? I
> don't see it here any more http://doc.qt.io/qt-5/qml-qtquick-text.html

Ack, revno 1397.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 79 + /*
> 80 + Swiped offset.
> 81 + */
> 82 + readonly property real swipedOffset: leading ? width + x :
> ListItem.item.width - x;
>
> would this be panelOffset? Or maybe just offset since we are inside
> ListItemPanel?

The property tells what it is: the offset the swipe happened. I think it is good as is.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 79 + /*
> 80 + Swiped offset.
> 81 + */
> 82 + readonly property real swipedOffset: leading ? width + x :
> ListItem.item.width - x;
> 83 +
> 84 + /*
> 85 + Swiping
> 86 + */
> 87 + readonly property bool swiping: ListItem.item.highlighted &&
> ListItem.item.contentMoving
>
> The comments here don't add any information so can be removed.

Ok... revno 1398.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 94 + left: (leading ? undefined : ListItem.item.contentItem.right)
> 95 + right: (leading ? ListItem.item.contentItem.left : undefined)
>
> remove the '(' and ')' here.

Ack. revno 1399.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 118 + Connections {
> 119 + target: panel.ListItem.item
> 120 + onContentMovementEnded: {
> 121 + if (actionsRow.selectedAction) {
> 122 +
> actionsRow.selectedAction.trigger(actionsRow.listItemIndex >= 0 ?
> actionsRow.listItemIndex : null);
> 123 + actionsRow.selectedAction = null;
> 124 + }
>
>
> I'm just wondering if it would make sense to return -1 when listItemIndex < 0
> (or listItemIndex is undefined?). That way in the Action.trigger(), the
> developer only has to deal with integer values.

Fair point! I guess it is a remainder from times when it was checking the parameterType. revno 1400.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 143 - var snapPos = (ListItemActions.offset >
> ListItemActions.listItem.swipeOvershoot && snapIn) ? panel.width : 0.0;
> 144 - ListItemActions.snapToPosition(snapPos);
> 145 + var snapPos = (swipedOffset > units.gu(2) && snapIn) ?
> panel.width : 0.0;
> 146 + ListItem.snapToPosition(snapPos);
> 147 }
>
> You replaced swipeOvershoot by a hard-coded value here. Is that an
> improvement? It is better to have a constant defined.

The thing is that if we use swipeOvershoot, and that one is set to 10GU, it will snap out even if the first 2 actions will be visible, as those get visible on <10GU swiped offset. So as last time discussed, the magic number for the swipe is 2GU, that's why I have it.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 245 --- modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp
> 1970-01-01 00:00:00 +0000
> 246 +++ modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp
> 2015-01-12 15:45:30 +0000
> 247 @@ -0,0 +1,132 @@
> 248 +/*
> 249 + * Copyright 2014 Canonical Ltd.
>
>
> I don't remember when was the first version of this file (no idea why the diff
> shows 1970), but let's make it 2015.

Ok... I hope you won't change all the new files which were added last year in the future MRs... :) revno 1401

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 412 + // make sure teh animation is not running
>
> your favorite typo ;)

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 412 + // make sure teh animation is not running
> 413 + snap->stop();
> 414 snap->setFrom(listItem->contentItem->property(snap->property().to
> Local8Bit().constData()));
> 415 snap->setTo(to);
> 416 - snap->setAlwaysRunToEnd(true);
> 417 + snap->setAlwaysRunToEnd(false);
>
> do you still need this now that you removed
>
> 195 - alwaysRunToEnd: true

Just to make sure whenever I call complete() or stop() it will stop the animation.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 423 +void UCListItemSnapAnimator::stop()
> 424 +{
> 425 + QQuickPropertyAnimation *snap = getDefaultAnimation();
> 426 + if (snap && snap->isRunning()) {
> 427 + snap->stop();
> 428 + }
> 429 +}
>
> where do you use this?
> perhaps you should be calling this function in snap() instead of calling
> snap->stop() there.

Check the code :) It is used when mousePressed() is called, so if there is an animation, it will stop it => no binding loop on swiped property

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> Since we only have an overshoot for swiping,
> 1131 +void UCListItemPrivate::resetSwipeOvershoot()
> may be called resetOvershoot()?

The property is called swipeOvershoot afaik, so teh reset follows the naming follows the getter/setter/reset naming convention.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 1193 + Q_PROPERTY(UCListItemActions *actions READ actions NOTIFY
> actionsChanged)
> 1194 + Q_PROPERTY(QQmlListProperty<UCAction> visibleActions READ
> visibleActions NOTIFY visibleActionsChanged)
> 1195 + Q_PROPERTY(UCListItem *item READ item NOTIFY itemChanged)
> 1196 + Q_PROPERTY(int index READ index NOTIFY indexChanged)
> 1197 + Q_PROPERTY(UCListItem::PanelStatus panelStatus READ panelStatus
> NOTIFY panelStatusChanged)
>
> why do we need to expose all of these publicly?

How would you implement a panel without them?
- actions contains the ListItemActions the panell is about to visualize
- visibleActions is a helper property, which is updated automatically whenever an action.visible is changed, without this the QML code would be a bit painful
- index provides info about the ListItem index, however that can be accessed as well as context property, perhaps we can remove it
- the panelStatus is needed in order to know which panel is the instance

So apart from 'index' I don't know what to remove.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 2459 ListItem {
> 2460 Label {
> 2461 + id: label2
> 2462 anchors.fill: parent
> 2463 - text: "Another standalone ListItem"
> 2464 + text: "Another standalone ListItem\nStarted with
> custom style, reset to theme style on first click"
> 2465 }
> 2466 leadingActions: testItem.leadingActions
> 2467 trailingActions: ListItemActions {
> 2468 actions: leading.actions
> 2469 }
> 2470 + style: ListItemStyle {}
> 2471 + onClicked: { style = undefined; label2.text = "Another
> standalone ListItem" }
> 2472 }
>
> This example would be more interesting if the custom style did something. Now
> it is basically an Item.

Perhaps. I did not wanted to deal with any complicated there, it is enough to see that it doesn't do anything if nothing is set.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-13:

> 2526 + Component { id: customStyle; ListItemStyle {} }
> 2527 +
> 2528 + function test_style_reset() {
> 2529 + testItem.style = customStyle;
> 2530 + testItem.style = undefined;
> 2531 + verify(testItem.style != 0, "Style set back to theme")
> 2532 + }
>
> ; missing
>
> You only verify here that the style is not 0. Can we get the type of the style
> and validate that?

Fixed in revno 1402.

lp:~zsombi/ubuntu-ui-toolkit/76-refactoring updated on 2015-01-13

1397. By Zsombor Egri on 2015-01-13: property rename
1398. By Zsombor Egri on 2015-01-13: comments removed
1399. By Zsombor Egri on 2015-01-13: parenthesis removed
1400. By Zsombor Egri on 2015-01-13: parameter when action triggered fixed
1401. By Zsombor Egri on 2015-01-13: year changed
1402. By Zsombor Egri on 2015-01-13: theme restoration test fixed

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1359/rebuild

review: Approve (continuous-integration)

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-15:

> > void UCListItem::setHighlightColor(const QColor &color)
> > {
> > Q_D(UCListItem);
> > if (d->highlightColor == color) {
> > return;
> > }
> > d->highlightColor = color;
> > // no more theme change watch
> > d->customColor = true;
> > update();
> > Q_EMIT highlightColorChanged();
> > }
> > void UCListItem::resetHighlightColor()
> > {
> > Q_D(UCListItem);
> > d->customColor = false;
> > d->highlightColor = getPaletteColor("selected", "background");
> > update();
> > Q_EMIT highlightColorChanged();
> > }
> >
> >
> > if you call setHighlightColor(color) // color == getPaletteColor("selected",
> > "background") then customColor is not set to true, and you are still
> watching
> > for palette updates, while it may be purely coincidence that you set the
> color
> > to the palette color. So customColor = true should be moved before the if()
> > (maybe update() too).
>
> Well, if a property's default value is set again as value, there will be no
> change done either.

But the link to the theme color should be broken, when you set a manual color (same as the theme color), the color should not be updated automatically any more when the theme color changes.

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-15:

> > 2526 + Component { id: customStyle; ListItemStyle {} }
> > 2527 +
> > 2528 + function test_style_reset() {
> > 2529 + testItem.style = customStyle;
> > 2530 + testItem.style = undefined;
> > 2531 + verify(testItem.style != 0, "Style set back to theme")
> > 2532 + }
> >
> > ; missing
> >
> > You only verify here that the style is not 0. Can we get the type of the
> style
> > and validate that?
>
> Fixed in revno 1402.

All changes are good, except this one. What I meant is to check the actual type of the component, but that can be difficult. The approach with the objectName can work, but I propose to use a more descriptive objectName ("ListItemThemeStyle"?), and to add a comment in uclistitem.cpp when you set the objectName, saying that you use it in tst_listitem.qml because from reading only the cpp now it is not clear why this code is there. Perhaps even comment in tst_listitem.qml that the objectName is set in UCListItemPrivate.resetStyle().

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-15:

> > > void UCListItem::setHighlightColor(const QColor &color)
> > > {
> > > Q_D(UCListItem);
> > > if (d->highlightColor == color) {
> > > return;
> > > }
> > > d->highlightColor = color;
> > > // no more theme change watch
> > > d->customColor = true;
> > > update();
> > > Q_EMIT highlightColorChanged();
> > > }
> > > void UCListItem::resetHighlightColor()
> > > {
> > > Q_D(UCListItem);
> > > d->customColor = false;
> > > d->highlightColor = getPaletteColor("selected", "background");
> > > update();
> > > Q_EMIT highlightColorChanged();
> > > }
> > >
> > >
> > > if you call setHighlightColor(color) // color ==
> getPaletteColor("selected",
> > > "background") then customColor is not set to true, and you are still
> > watching
> > > for palette updates, while it may be purely coincidence that you set the
> > color
> > > to the palette color. So customColor = true should be moved before the
> if()
> > > (maybe update() too).
> >
> > Well, if a property's default value is set again as value, there will be no
> > change done either.
>
> But the link to the theme color should be broken, when you set a manual color
> (same as the theme color), the color should not be updated automatically any
> more when the theme color changes.

We need to check how font.family is handled. That one gets its value from the default value set - the one we patched in the plugin. I need to check what happens if I set that default value in C++ to something else, while having the same value assigned to the property value in QML. If changing the default value changes the Text font, then we're good as we are now, e behave the same way. If it doesn't change, then we fix our code as well.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-15:

> > > 2526 + Component { id: customStyle; ListItemStyle {} }
> > > 2527 +
> > > 2528 + function test_style_reset() {
> > > 2529 + testItem.style = customStyle;
> > > 2530 + testItem.style = undefined;
> > > 2531 + verify(testItem.style != 0, "Style set back to
> theme")
> > > 2532 + }
> > >
> > > ; missing
> > >
> > > You only verify here that the style is not 0. Can we get the type of the
> > style
> > > and validate that?
> >
> > Fixed in revno 1402.
>
>
> All changes are good, except this one. What I meant is to check the actual
> type of the component, but that can be difficult. The approach with the
> objectName can work, but I propose to use a more descriptive objectName
> ("ListItemThemeStyle"?), and to add a comment in uclistitem.cpp when you set
> the objectName, saying that you use it in tst_listitem.qml because from
> reading only the cpp now it is not clear why this code is there. Perhaps even
> comment in tst_listitem.qml that the objectName is set in
> UCListItemPrivate.resetStyle().

Ok, will do that tomorrow.

Revision history for this message

Zsombor Egri (zsombi) wrote on 2015-01-16:

> > > > void UCListItem::setHighlightColor(const QColor &color)
> > > > {
> > > > Q_D(UCListItem);
> > > > if (d->highlightColor == color) {
> > > > return;
> > > > }
> > > > d->highlightColor = color;
> > > > // no more theme change watch
> > > > d->customColor = true;
> > > > update();
> > > > Q_EMIT highlightColorChanged();
> > > > }
> > > > void UCListItem::resetHighlightColor()
> > > > {
> > > > Q_D(UCListItem);
> > > > d->customColor = false;
> > > > d->highlightColor = getPaletteColor("selected", "background");
> > > > update();
> > > > Q_EMIT highlightColorChanged();
> > > > }
> > > >
> > > >
> > > > if you call setHighlightColor(color) // color ==
> > getPaletteColor("selected",
> > > > "background") then customColor is not set to true, and you are still
> > > watching
> > > > for palette updates, while it may be purely coincidence that you set the
> > > color
> > > > to the palette color. So customColor = true should be moved before the
> > if()
> > > > (maybe update() too).
> > >
> > > Well, if a property's default value is set again as value, there will be
> no
> > > change done either.
> >
> > But the link to the theme color should be broken, when you set a manual
> color
> > (same as the theme color), the color should not be updated automatically any
> > more when the theme color changes.
>
> We need to check how font.family is handled. That one gets its value from the
> default value set - the one we patched in the plugin. I need to check what
> happens if I set that default value in C++ to something else, while having the
> same value assigned to the property value in QML. If changing the default
> value changes the Text font, then we're good as we are now, e behave the same
> way. If it doesn't change, then we fix our code as well.

Seems the font.family was a bad example, as it does not change the font of the text even if the font.family is not having any static value bound. So let's do the way that we mark it as custom color even if it is the same as the default one.

> > > > void UCListItem::setHighlightColor(const QColor &color)
> > > > {
> > > >     Q_D(UCListItem);
> > > >     if (d->highlightColor == color) {
> > > >         return;
> > > >     }
> > > >     d->highlightColor = color;
> > > >     // no more theme change watch
> > > >     d->customColor = true;
> > > >     update();
> > > >     Q_EMIT highlightColorChanged();
> > > > }
> > > > void UCListItem::resetHighlightColor()
> > > > {
> > > >     Q_D(UCListItem);
> > > >     d->customColor = false;
> > > >     d->highlightColor = getPaletteColor("selected", "background");
> > > >     update();
> > > >     Q_EMIT highlightColorChanged();
> > > > }
> > > >
> > > >
> > > > if you call setHighlightColor(color) // color ==
> > getPaletteColor("selected",
> > > > "background") then customColor is not set to true, and you are still
> > > watching
> > > > for palette updates, while it may be purely coincidence that you set the
> > > color
> > > > to the palette color. So customColor = true should be moved before the
> > if()
> > > > (maybe update() too).
> > >
> > > Well, if a property's default value is set again as value, there will be
> no
> > > change done either.
> >
> > But the link to the theme color should be broken, when you set a manual
> color
> > (same as the theme color), the color should not be updated automatically any
> > more when the theme color changes.
> 
> We need to check how font.family is handled. That one gets its value from the
> default value set - the one we patched in the plugin. I need to check what
> happens if I set that default value in C++ to something else, while having the
> same value assigned to the property value in QML. If changing the default
> value changes the Text font, then we're good as we are now, e behave the same
> way. If it doesn't change, then we fix our code as well.

lp:~zsombi/ubuntu-ui-toolkit/76-refactoring updated on 2015-01-16

1403. By Zsombor Egri on 2015-01-16: style testing made more descriptive
1404. By Zsombor Egri on 2015-01-16: final comments applied
1405. By Zsombor Egri on 2015-01-16: staging merge

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-16:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1368/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Tim Peeters (tpeeters) wrote on 2015-01-19:

great, thanks! :)

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) on 2015-01-19:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Dan Chapman 

Tom Mirmar

Ubuntu SDK team

Zsombor Egri

 === modified file 'components.api'
 --- components.api	2014-12-18 10:08:56 +0000
 +++ components.api	2015-01-16 14:53:38 +0000
@@ -867,6 +867,7 @@
      name: "UCListItem"
      prototype: "UCStyledItemBase"
      exports: ["ListItem 1.2"]
++    name: "PanelStatus"
      Property { name: "contentItem"; type: "QQuickItem"; isReadonly: true; isPointer: true }
      Property { name: "divider"; type: "UCListItemDivider"; isReadonly: true; isPointer: true }
      Property { name: "leadingActions"; type: "UCListItemActions"; isPointer: true }
@@ -886,26 +887,19 @@
      name: "UCListItemActions"
      prototype: "QObject"
      exports: ["ListItemActions 1.2"]
--    name: "Status"
      Property { name: "delegate"; type: "QQmlComponent"; isPointer: true }
      Property { name: "actions"; type: "UCAction"; isList: true; isReadonly: true }
      Property { name: "data"; type: "QObject"; isList: true; isReadonly: true }
--    Signal {
--    name: "statusChanged"
--    Parameter { name: "status"; type: "Status" }
--    name: "UCListItemActionsAttached"
++    name: "UCListItemAttached"
      prototype: "QObject"
--    Property { name: "container"; type: "UCListItemActions"; isReadonly: true; isPointer: true }
++    Property { name: "actions"; type: "UCListItemActions"; isReadonly: true; isPointer: true }
      Property { name: "visibleActions"; type: "UCAction"; isList: true; isReadonly: true }
--    Property { name: "listItem"; type: "UCListItem"; isReadonly: true; isPointer: true }
--    Property { name: "listItemIndex"; type: "int"; isReadonly: true }
--    Property { name: "offset"; type: "double"; isReadonly: true }
--    Property { name: "status"; type: "UCListItemActions::Status"; isReadonly: true }
--    Property { name: "swiping"; type: "bool"; isReadonly: true }
++    Property { name: "item"; type: "UCListItem"; isReadonly: true; isPointer: true }
++    Property { name: "index"; type: "int"; isReadonly: true }
++    Property { name: "panelStatus"; type: "UCListItem::PanelStatus"; isReadonly: true }
      Method {
      name: "snapToPosition"
      Parameter { name: "position"; type: "double" }
--    Component { name: "UCListItemAttached"; prototype: "QObject" }
      name: "UCListItemDivider"
      prototype: "QObject"
      Property { name: "visible"; type: "bool" }
@@ -1010,6 +1004,9 @@
      Signal {
      name: "opened"
      Parameter { name: "uris"; type: "QStringList" }
++    name: "UCViewItemsAttached"
++    prototype: "QObject"
++    exports: ["ViewItems 1.2"]
      name: "UbuntuI18n"
      prototype: "QObject"
      exports: ["i18n 0.1", "i18n 1.0"]
 === modified file 'modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml'
 --- modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml	2014-12-17 07:06:31 +0000
 +++ modules/Ubuntu/Components/Themes/Ambiance/ListItemPanel.qml	2015-01-16 14:53:38 +0000
@@ -38,32 +38,29 @@
      /*
        Specifies the width of the component visualizing the action.
        */
--    property real visualizedActionWidth: units.gu(2.5)
++    property real paintedActionWidth: units.gu(2.5)
      // panel implementation
      id: panel
      width: Math.max(
                 actionsRow.childrenRect.width,
--               ListItemActions.visibleActions.length * MathUtils.clamp(visualizedActionWidth, height, actionsRow.maxItemWidth))
++               ListItem.visibleActions.length * MathUtils.clamp(paintedActionWidth, height, actionsRow.maxItemWidth))
      // used for module/autopilot testing
      objectName: "ListItemPanel" + (leading ? "Leading" : "Trailing")
      /*
--      Property holding the ListItem's contentItem instance
--      */
--    readonly property Item contentItem: parent ? parent.contentItem : null
--
--    /*
        Specifies whether the panel is used to visualize leading or trailing actions.
        */
--    readonly property bool leading: panel.ListItemActions.status == panel.ListItemActions.Leading
++    readonly property bool leading: ListItem.panelStatus == ListItem.Leading
++    readonly property real swipedOffset: leading ? width + x : ListItem.item.width - x;
++    readonly property bool swiping: ListItem.item.highlighted && ListItem.item.contentMoving
      anchors {
--        left: contentItem ? (leading ? undefined : contentItem.right) : undefined
--        right: contentItem ? (leading ? contentItem.left : undefined) : undefined
--        top: contentItem ? contentItem.top : undefined
--        bottom: contentItem ? contentItem.bottom : undefined
++        left: leading ? undefined : ListItem.item.contentItem.right
++        right: leading ? ListItem.item.contentItem.left : undefined
++        top: ListItem.item.contentItem.top
++        bottom: ListItem.item.contentItem.bottom
+     }
      Rectangle {
@@ -71,17 +68,21 @@
          anchors {
              fill: parent
              // add 4 times the overshoot margins to cover the background when tugged
--            leftMargin: (leading && panel.ListItemActions.listItem) ? -units.gu(4 * panel.ListItemActions.listItem.swipeOvershoot) : 0
--            rightMargin: (!leading && panel.ListItemActions.listItem) ? -units.gu(4 * panel.ListItemActions.listItem.swipeOvershoot) : 0
++            leftMargin: (leading && panel.ListItem.item) ? -units.gu(4 * panel.ListItem.item.swipeOvershoot) : 0
++            rightMargin: (!leading && panel.ListItem.item) ? -units.gu(4 * panel.ListItem.item.swipeOvershoot) : 0
+         }
          color: panel.backgroundColor
+     }
      // handle action triggering
--    ListItemActions.onStatusChanged: {
--        if (ListItemActions.status === ListItemActions.Disconnected && actionsRow.selectedAction) {
--            actionsRow.selectedAction.trigger(actionsRow.listItemIndex >= 0 ? actionsRow.listItemIndex : null);
--            actionsRow.selectedAction = null;
++    Connections {
++        target: panel.ListItem.item
++        onContentMovementEnded: {
++            if (actionsRow.selectedAction) {
++                actionsRow.selectedAction.trigger(actionsRow.listItemIndex);
++                actionsRow.listItemIndex = -1;
++                actionsRow.selectedAction = null;
++            }
+         }
+     }
@@ -101,8 +102,8 @@
          prevX = x;
+     }
      // default snapping!
--    ListItemActions.onSwipingChanged: {
--        if (ListItemActions.swiping) {
++    onSwipingChanged: {
++        if (swiping) {
              // the dragging got started, set prevX
              prevX = panel.x;
              return;
@@ -111,8 +112,8 @@
              return;
+         }
          // snap in if the offset is bigger than the overshoot and the direction of the drag is to reveal the panel
--        var snapPos = (ListItemActions.offset > ListItemActions.listItem.swipeOvershoot && snapIn) ? panel.width : 0.0;
--        ListItemActions.snapToPosition(snapPos);
++        var snapPos = (swipedOffset > units.gu(2) && snapIn) ? panel.width : 0.0;
++        ListItem.snapToPosition(snapPos);
+     }
      Row {
@@ -124,13 +125,13 @@
              leftMargin: spacing
+         }
--        property real maxItemWidth: panel.parent ? (panel.parent.width / panel.ListItemActions.visibleActions.length) : 0
++        property real maxItemWidth: panel.ListItem.item.width / panel.ListItem.visibleActions.length
          property Action selectedAction
--        property int listItemIndex
++        property int listItemIndex: -1
          Repeater {
--            model: panel.ListItemActions.visibleActions
++            model: panel.ListItem.visibleActions
              AbstractButton {
                  id: actionButton
                  action: modelData
@@ -143,8 +144,8 @@
+                 }
                  function trigger() {
                      actionsRow.selectedAction = modelData;
--                    actionsRow.listItemIndex = panel.ListItemActions.listItemIndex;
--                    panel.ListItemActions.snapToPosition(0.0);
++                    actionsRow.listItemIndex = panel.ListItem.index;
++                    panel.ListItem.snapToPosition(0.0);
+                 }
                  Rectangle {
@@ -156,7 +157,7 @@
                  Loader {
                      id: delegateLoader
                      height: parent.height
--                    sourceComponent: panel.ListItemActions.container.delegate ? panel.ListItemActions.container.delegate : defaultDelegate
++                    sourceComponent: panel.ListItem.actions.delegate ? panel.ListItem.actions.delegate : defaultDelegate
                      property Action action: modelData
                      property int index: index
                      property bool pressed: actionButton.pressed
@@ -177,7 +178,7 @@
          Item {
              width: height
              Icon {
--                width: panel.visualizedActionWidth
++                width: panel.paintedActionWidth
                  height: width
                  name: action.iconName
                  color: panel.foregroundColor
 === modified file 'modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml'
 --- modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml	2014-12-01 11:13:10 +0000
 +++ modules/Ubuntu/Components/Themes/Ambiance/ListItemStyle.qml	2015-01-16 14:53:38 +0000
@@ -30,7 +30,6 @@
              period: 0.5
+         }
          duration: UbuntuAnimation.BriskDuration
--        alwaysRunToEnd: true
+     }
+ }
 === modified file 'modules/Ubuntu/Components/plugin/plugin.cpp'
 --- modules/Ubuntu/Components/plugin/plugin.cpp	2014-12-03 14:43:27 +0000
 +++ modules/Ubuntu/Components/plugin/plugin.cpp	2015-01-16 14:53:38 +0000
@@ -171,6 +171,7 @@
      qmlRegisterType<UCListItem, 2>(uri, 1, 2, "ListItem");
      qmlRegisterType<UCListItemDivider>();
      qmlRegisterType<UCListItemActions, 2>(uri, 1, 2, "ListItemActions");
++    qmlRegisterUncreatableType<UCViewItemsAttached, 2>(uri, 1, 2, "ViewItems", "Not instantiable");
+ }
  void UbuntuComponentsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
 === modified file 'modules/Ubuntu/Components/plugin/plugin.pro'
 --- modules/Ubuntu/Components/plugin/plugin.pro	2014-12-03 14:43:27 +0000
 +++ modules/Ubuntu/Components/plugin/plugin.pro	2015-01-16 14:53:38 +0000
@@ -111,10 +111,11 @@
      adapters/actionsproxy_p.cpp \
      uclistitem.cpp \
      uclistitemactions.cpp \
--    uclistitemactionsattached.cpp \
++    propertychange_p.cpp \
++    uclistitemstyle.cpp \
++    ucviewitemsattached.cpp \
      uclistitemattached.cpp \
--    propertychange_p.cpp \
--    uclistitemstyle.cpp
++    ucactionpanel_p.cpp
  # adapters
  SOURCES += adapters/alarmsadapter_organizer.cpp
 === modified file 'modules/Ubuntu/Components/plugin/ucaction.h'
 --- modules/Ubuntu/Components/plugin/ucaction.h	2014-12-01 13:42:47 +0000
 +++ modules/Ubuntu/Components/plugin/ucaction.h	2015-01-16 14:53:38 +0000
@@ -87,7 +87,7 @@
      Type m_parameterType;
      friend class UCActionContext;
--    friend class UCListItemActionsAttached;
++    friend class UCListItemAttached;
      friend class UCListItemActionsPrivate;
      bool isValidType(QVariant::Type valueType);
 === added file 'modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp'
 --- modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp	1970-01-01 00:00:00 +0000
 +++ modules/Ubuntu/Components/plugin/ucactionpanel_p.cpp	2015-01-16 14:53:38 +0000
@@ -0,0 +1,132 @@
++/*
++ * Copyright 2015 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "uclistitemactions.h"
++#include "uclistitemactions_p.h"
++#include "uclistitem_p.h"
++#include "quickutils.h"
++#include "i18n.h"
++#include "plugin.h"
++#include <QtQml/QQmlInfo>
++#include "ucaction.h"
++#include "ucunits.h"
++#include "uclistitemstyle.h"
++
++UCActionPanel::UCActionPanel(UCListItem *item, bool leading)
++    : QObject(item)
++    , listItem(item)
++    , panelItem(0)
++    , status(UCListItem::None)
++    , leading(leading)
++    , connected(false)
++{
++
++}
++
++UCActionPanel::~UCActionPanel()
++{
++}
++
++UCListItemAttached *UCActionPanel::attachedObject()
++{
++    if (!panelItem) {
++        return 0;
++    }
++    return static_cast<UCListItemAttached*>(
++                qmlAttachedPropertiesObject<UCListItem>(panelItem, false));
++}
++
++bool UCActionPanel::createPanel(QQmlComponent *panelDelegate)
++{
++    if (panelItem || !panelDelegate) {
++        return false;
++    }
++    if (!panelDelegate->isError()) {
++        QQmlContext *context = new QQmlContext(qmlContext(listItem));
++        panelItem = qobject_cast<QQuickItem*>(panelDelegate->beginCreate(context));
++        if (!panelItem) {
++            qmlInfo(listItem) << UbuntuI18n::tr("Error creating ListItem actions panel");
++        } else {
++            context->setParent(panelItem);
++            QQml_setParent_noEvent(panelItem, listItem);
++            panelItem->setParentItem(listItem);
++            // create attached property!
++            UCListItemAttached *attached = static_cast<UCListItemAttached*>(
++                        qmlAttachedPropertiesObject<UCListItem>(panelItem));
++            if (!attached->actions()) {
++                attached->setList(listItem, leading, true);
++            } else {
++                // container is set, but we need to emit the signal again so we get the
++                // attached props updated for those cases when the attached property is
++                // created before the statement above
++                Q_EMIT attached->actionsChanged();
++            }
++            panelDelegate->completeCreate();
++        }
++    } else {
++        qmlInfo(listItem) << panelDelegate->errorString();
++    }
++    return panelItem != 0;
++}
++
++UCListItemActions *UCActionPanel::actions()
++{
++    return leading ? UCListItemPrivate::get(listItem)->leadingActions :
++                     UCListItemPrivate::get(listItem)->trailingActions;
++}
++
++QQuickItem *UCActionPanel::panel() const
++{
++    return panelItem;
++}
++
++bool UCActionPanel::grabPanel(UCActionPanel **panel, UCListItem *item, bool leading)
++{
++    if (!(*panel) && item) {
++        UCListItemActions *actions = leading ? UCListItemPrivate::get(item)->leadingActions :
++                                             UCListItemPrivate::get(item)->trailingActions;
++        if (actions) {
++            (*panel) = new UCActionPanel(item, leading);
++            UCListItemPrivate *pItem = UCListItemPrivate::get((*panel)->listItem);
++            pItem->initStyleItem();
++            if (!pItem->styleItem ||
++                    (pItem->styleItem && !(*panel)->createPanel(pItem->styleItem->m_actionsDelegate))) {
++                delete (*panel);
++                (*panel) = 0;
++            }
++        }
++    }
++    if (*panel) {
++        (*panel)->connected = true;
++        (*panel)->status = leading ? UCListItem::Leading : UCListItem::Trailing;
++        Q_EMIT (*panel)->statusChanged();
++    }
++    return (*panel) != 0;
++}
++
++void UCActionPanel::ungrabPanel(UCActionPanel *panel)
++{
++    if (!panel || !panel->connected) {
++        return;
++    }
++    panel->connected = false;
++    panel->panelItem->setVisible(false);
++}
++
++bool UCActionPanel::isConnected(UCActionPanel *panel)
++{
++    return panel && panel->connected;
++}
 === modified file 'modules/Ubuntu/Components/plugin/uclistitem.cpp'
 --- modules/Ubuntu/Components/plugin/uclistitem.cpp	2015-01-07 06:42:09 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitem.cpp	2015-01-16 14:53:38 +0000
@@ -32,10 +32,6 @@
  #include <QtQuick/private/qquickmousearea_p.h>
  #include "uclistitemstyle.h"
--#define MIN(x, y)           ((x < y) ? x : y)
--#define MAX(x, y)           ((x > y) ? x : y)
--#define CLAMP(v, min, max)  (min <= max) ? MAX(min, MIN(v, max)) : MAX(max, MIN(v, min))
--
  QColor getPaletteColor(const char *profile, const char *color)
+ {
      QColor result;
@@ -85,6 +81,12 @@
      if (!snap) {
          // no animation, so we simply position the component
          listItem->contentItem->setX(to);
++        // and complete snap logic
++        if (to == 0.0) {
++            snapOut();
++        } else {
++            snapIn();
++        }
          return false;
+     }
      snap->setTargetObject(listItem->contentItem);
@@ -98,14 +100,24 @@
      if (snap->properties().isEmpty() && snap->property().isEmpty()) {
          snap->setProperty("x");
+     }
++    // make sure the animation is not running
++    snap->stop();
      snap->setFrom(listItem->contentItem->property(snap->property().toLocal8Bit().constData()));
      snap->setTo(to);
--    snap->setAlwaysRunToEnd(true);
++    snap->setAlwaysRunToEnd(false);
      listItem->setContentMoving(true);
      snap->start();
      return true;
+ }
++void UCListItemSnapAnimator::stop()
++{
++    QQuickPropertyAnimation *snap = getDefaultAnimation();
++    if (snap && snap->isRunning()) {
++        snap->stop();
++    }
++}
++
  /*
   * The function completes a running snap animation.
   */
@@ -131,17 +143,19 @@
          QObject::disconnect(snap, 0, 0, 0);
+     }
      UCListItemPrivate *listItem = UCListItemPrivate::get(item);
--    if (listItem->attachedProperties) {
++    if (listItem->parentAttached) {
          // restore flickable's interactive and cleanup
--        listItem->attachedProperties->disableInteractive(item, false);
++        listItem->parentAttached->disableInteractive(item, false);
          // no need to listen flickables any longer
          listItem->listenToRebind(false);
+     }
      // disconnect actions
--    listItem->grabPanel(listItem->leadingActions, false);
--    listItem->grabPanel(listItem->trailingActions, false);
++    UCActionPanel::ungrabPanel(listItem->leadingPanel);
++    UCActionPanel::ungrabPanel(listItem->trailingPanel);
      // set contentMoved to false
      listItem->setContentMoving(false);
++    // lock contentItem left/right edges
++    listItem->lockContentItem(true);
+ }
  /*
@@ -176,8 +190,6 @@
  UCListItemDivider::UCListItemDivider(QObject *parent)
      : QObject(parent)
      , m_visible(true)
--    , m_leftMarginChanged(false)
--    , m_rightMarginChanged(false)
      , m_colorFromChanged(false)
      , m_colorToChanged(false)
      , m_thickness(0)
@@ -202,14 +214,9 @@
  void UCListItemDivider::unitsChanged()
+ {
--    m_thickness = UCUnits::instance().dp(2);
--    if (!m_leftMarginChanged) {
--        m_leftMargin = UCUnits::instance().dp(2);
--    }
--    if (!m_rightMarginChanged) {
--        m_rightMargin = UCUnits::instance().dp(2);
--    }
++    m_thickness = UCUnits::instance().dp(DIVIDER_THICKNESS_DP);
      if (m_listItem) {
++        m_listItem->adjustContentItemHeight();
          m_listItem->update();
+     }
+ }
@@ -273,9 +280,9 @@
          return;
+     }
      m_visible = visible;
--    m_listItem->resize();
--    m_listItem->update();
      Q_EMIT visibleChanged();
++    // set/reset contentItem's bottomMargin
++    m_listItem->adjustContentItemHeight();
+ }
  void UCListItemDivider::setLeftMargin(qreal leftMargin)
@@ -284,7 +291,6 @@
          return;
+     }
      m_leftMargin = leftMargin;
--    m_leftMarginChanged = true;
      m_listItem->update();
      Q_EMIT leftMarginChanged();
+ }
@@ -295,7 +301,6 @@
          return;
+     }
      m_rightMargin = rightMargin;
--    m_rightMarginChanged = true;
      m_listItem->update();
      Q_EMIT rightMarginChanged();
+ }
@@ -329,25 +334,26 @@
      : UCStyledItemBasePrivate()
      , highlighted(false)
      , contentMoved(false)
--    , highlightColorChanged(false)
      , swiped(false)
      , suppressClick(false)
      , ready(false)
--    , customStyle(false)
      , customColor(false)
      , customOvershoot(false)
      , flicked(false)
--    , xAxisMoveThresholdGU(1.5)
++    , xAxisMoveThresholdGU(DEFAULT_SWIPE_THRESHOLD_GU)
      , overshoot(0)
      , color(Qt::transparent)
      , highlightColor(Qt::transparent)
--    , attachedProperties(0)
++    , parentAttached(0)
      , contentItem(new QQuickItem)
      , divider(new UCListItemDivider)
      , leadingActions(0)
      , trailingActions(0)
++    , leadingPanel(0)
++    , trailingPanel(0)
      , animator(0)
      , styleComponent(0)
++    , implicitStyleComponent(0)
      , styleItem(0)
+ {
+ }
@@ -391,13 +397,17 @@
  void UCListItemPrivate::_q_updateThemedData()
+ {
++    Q_Q(UCListItem);
++    // we reload the implicit style only if the custom style is not set, and
++    // the component is ready
++    if (!styleComponent && ready) {
++        resetStyle();
++    }
++
      // update colors, panels
      if (!customColor) {
--        Q_Q(UCListItem);
--        highlightColor = getPaletteColor("selected", "background");
--        q->update();
++        q->resetHighlightColor();
+     }
--    loadStyle(true);
+ }
  void UCListItemPrivate::_q_rebound()
@@ -405,8 +415,8 @@
      setHighlighted(false);
      // initiate rebinding only if there were actions tugged
      Q_Q(UCListItem);
--    if (!UCListItemActionsPrivate::isConnectedTo(leadingActions, q) &&
--        !UCListItemActionsPrivate::isConnectedTo(trailingActions, q)) {
++    if (!UCActionPanel::isConnected(leadingPanel) &&
++        !UCActionPanel::isConnected(trailingPanel)) {
          return;
+     }
      setSwiped(false);
@@ -430,7 +440,7 @@
   */
  QQmlComponent *UCListItemPrivate::style() const
+ {
--    return styleComponent;
++    return styleComponent ? styleComponent : implicitStyleComponent;
+ }
  void UCListItemPrivate::setStyle(QQmlComponent *delegate)
+ {
@@ -438,54 +448,89 @@
          return;
+     }
      Q_Q(UCListItem);
++    if (!delegate) {
++        // undefined or null delegate resets the style to theme
++        resetStyle();
++        return;
++    }
      // make sure we're rebound before we change the panel component
      promptRebound();
++    bool reloadStyle = styleItem != 0;
      if (styleItem) {
--        delete styleItem;
++        styleItem->deleteLater();
          styleItem = 0;
          Q_EMIT q->__styleInstanceChanged();
+     }
--    delete styleComponent;
--    customStyle = (delegate == 0);
      styleComponent = delegate;
--    loadStyle(false);
++    // delete theme style for now
++    if (implicitStyleComponent) {
++        implicitStyleComponent->deleteLater();
++        implicitStyleComponent = 0;
++    }
++    if (reloadStyle) {
++        initStyleItem();
++    }
      Q_EMIT q->styleChanged();
+ }
--
--// update themed components
--bool UCListItemPrivate::loadStyle(bool reload)
++void UCListItemPrivate::resetStyle()
+ {
--    if (!ready) {
--        return false;
--    }
--    if (!customStyle) {
--        Q_Q(UCListItem);
--        if (reload && styleItem) {
--            delete styleItem;
++    if (styleComponent || !implicitStyleComponent) {
++        styleComponent = 0;
++        // rebound as the current panels are not gonna be valid anymore
++        if (swiped) {
++            promptRebound();
++        }
++        bool reloadStyle = styleItem != 0;
++        if (styleItem) {
++            styleItem->deleteLater();
              styleItem = 0;
--            Q_EMIT q->__styleInstanceChanged();
--        }
--        delete styleComponent;
--        styleComponent = UCTheme::instance().createStyleComponent("ListItemStyle.qml", q);
++        }
++        delete implicitStyleComponent;
++        Q_Q(UCListItem);
++        implicitStyleComponent = UCTheme::instance().createStyleComponent("ListItemStyle.qml", q);
++        // set the objectnane for testing in tst_listitems.qml
++        implicitStyleComponent->setObjectName("ListItemThemeStyle");
++        // re-create style instance if it was created using the implicit style
++        if (reloadStyle) {
++            initStyleItem();
++        }
++        Q_EMIT q->styleChanged();
+     }
--    return (styleComponent != NULL);
+ }
++
  // creates the style item
  void UCListItemPrivate::initStyleItem()
+ {
--    if (!styleItem && !loadStyle(false)) {
++    if (!ready || styleItem) {
          return;
+     }
++    // get the component the style instance is created from
      Q_Q(UCListItem);
--    QObject *object = styleComponent->beginCreate(qmlContext(q));
++    QQmlComponent *delegate = style();
++    if (!delegate) {
++        // the style is not loaded from the theme yet
++        _q_updateThemedData();
++        delegate = style();
++    }
++    if (!delegate) {
++        return;
++    }
++    if (delegate->isError()) {
++        qmlInfo(q) << delegate->errorString();
++        return;
++    }
++    QQmlContext *context = new QQmlContext(qmlContext(q));
++    QObject *object = delegate->beginCreate(context);
      styleItem = qobject_cast<UCListItemStyle*>(object);
      if (!styleItem) {
          delete object;
--        styleComponent->completeCreate();
++        delegate->completeCreate();
++        delete context;
          return;
+     }
++    context->setParent(styleItem);
      QQml_setParent_noEvent(styleItem, q);
--    styleComponent->completeCreate();
++    delegate->completeCreate();
      Q_EMIT q->__styleInstanceChanged();
      // get the overshoot value from the style!
@@ -519,8 +564,8 @@
+ {
      Q_Q(UCListItem);
      QQuickItem *owner = flickable ? flickable : parentItem;
--    q->setImplicitWidth(owner ? owner->width() : UCUnits::instance().gu(40));
--    q->setImplicitHeight(UCUnits::instance().gu(7));
++    q->setImplicitWidth(owner ? owner->width() : UCUnits::instance().gu(IMPLICIT_LISTITEM_WIDTH_GU));
++    q->setImplicitHeight(UCUnits::instance().gu(IMPLICIT_LISTITEM_HEIGHT_GU));
+ }
  // returns the index of the list item when used in model driven views,
@@ -580,40 +625,37 @@
+     }
+ }
--// grabs the panels from the leading/trailing actions and disables all ascending flickables
--bool UCListItemPrivate::grabPanel(UCListItemActions *actionsList, bool isTugged)
--{
--    Q_Q(UCListItem);
--    if (isTugged) {
--        bool grab = UCListItemActionsPrivate::connectToListItem(actionsList, q, (actionsList == leadingActions));
--        if (attachedProperties) {
--            attachedProperties->disableInteractive(q, true);
--        }
--        return grab;
--    } else {
--        UCListItemActionsPrivate::disconnectFromListItem(actionsList);
--        return false;
--    }
--}
--
--
  // connects/disconnects from the Flickable anchestor to get notified when to do rebound
  void UCListItemPrivate::listenToRebind(bool listen)
+ {
--    if (attachedProperties) {
++    if (parentAttached) {
          Q_Q(UCListItem);
--        attachedProperties->listenToRebind(q, listen);
--    }
--}
--
--void UCListItemPrivate::resize()
--{
--    Q_Q(UCListItem);
--    QRectF rect(q->boundingRect());
--    if (divider && divider->m_visible) {
--        rect.setHeight(rect.height() - divider->m_thickness);
--    }
--    contentItem->setSize(rect.size());
++        parentAttached->listenToRebind(q, listen);
++    }
++}
++
++// lock/unlock contentItem's left and right anchors to the ListItem's left and right
++void UCListItemPrivate::lockContentItem(bool lock)
++{
++    QQuickAnchors *contentAnchors = QQuickItemPrivate::get(contentItem)->anchors();
++    if (lock) {
++        contentAnchors->setLeft(left());
++        contentAnchors->setRight(right());
++    } else {
++        contentAnchors->resetLeft();
++        contentAnchors->resetRight();
++    }
++}
++
++// adjust contentItem height depending on teh divider's visibility
++void UCListItemPrivate::adjustContentItemHeight()
++{
++    QQuickAnchors *contentAnchors = QQuickItemPrivate::get(contentItem)->anchors();
++    if (divider->m_visible) {
++        contentAnchors->setBottomMargin(divider->m_thickness);
++    } else {
++        contentAnchors->resetBottomMargin();
++    }
+ }
  void UCListItemPrivate::update()
@@ -628,13 +670,13 @@
  // clamps the X value and moves the contentItem to the new X value
  void UCListItemPrivate::clampAndMoveX(qreal &x, qreal dx)
+ {
--    UCListItemActionsPrivate *leading = UCListItemActionsPrivate::get(leadingActions);
--    UCListItemActionsPrivate *trailing = UCListItemActionsPrivate::get(trailingActions);
      x += dx;
      // min cannot be less than the trailing's panel width
--    qreal min = (trailing && trailing->panelItem) ? -trailing->panelItem->width() - overshoot: 0;
++    QQuickItem *leadingPanelItem = leadingPanel ? leadingPanel->panel() : 0;
++    QQuickItem *trailingPanelItem = trailingPanel ? trailingPanel->panel() : 0;
++    qreal min = (trailingPanelItem) ? -trailingPanelItem->width() - overshoot: 0;
      // max cannot be bigger than 0 or the leading's width in case we have leading panel
--    qreal max = (leading && leading->panelItem) ? leading->panelItem->width() + overshoot: 0;
++    qreal max = (leadingPanelItem) ? leadingPanelItem->width() + overshoot: 0;
      x = CLAMP(x, min, max);
+ }
@@ -722,11 +764,14 @@
   * When used in \c ListView or \l UbuntuListView, the last list item will not
   * show the divider no matter of the visible property value set.
+  *
-- * ListItem can handle actions that can get tugged from front to back of the item.
++ * ListItem can handle actions that can get swiped from front to back of the item.
   * These actions are Action elements visualized in panels attached to the front
   * or to the back of the item, and are revealed by swiping the item horizontally.
-- * The tug is started only after the mouse/touch move had passed a given threshold.
-- * These actions are configured through the \l leadingActions as well as \l
++ * The swipe is started only after the mouse/touch move had passed a given threshold.
++ * The actions are visualized by a panel, which is configurable through the \l
++ * ListItemStyle::actionsDelegate style property.
++ *
++ * The actions are configured through the \l leadingActions as well as \l
   * trailingActions properties.
   * \qml
   * ListItem {
@@ -751,13 +796,11 @@
   *     }
   * }
   * \endqml
-- * \note When a list item is tugged, it automatically connects both leading and
-- * trailing actions to the list item. This implies that a ListItem cannot use
-- * the same ListItemActions instance for both leading and trailing actions. If
-- * it is desired to have the same action present in both leading and trailing
-- * actions, one of the ListItemActions actions list can use the other's list. In
-- * the following example the list item can be deleted through both leading and
-- * trailing actions:
++ * \note When a list item is swiped, it automatically connects both leading and
++ * trailing actions to the list item. If needed, the same ListItemActions instance
++ * can be used in both leading and trailing side. In the following example the
++ * list item can be deleted through both leading and trailing actions using the
++ * same container:
   * \qml
   * ListItem {
   *     id: listItem
@@ -769,13 +812,15 @@
   *             }
   *         ]
   *     }
-- *     trailingActions: ListItemActions {
-- *         actions: leadingActions.actions
-- *     }
++ *     trailingActions: leadingActions
   * }
   * \endqml
++ * The action is triggered only after all the animations are completed.
   * \sa ListItemActions
+  *
++ * ListItem provides a set of attached properties which are attached to each panel
++ * of the ListItem. However not all properties are valid in all the circumstances.
++ *
   * The component is styled using the \l ListItemStyle style interface.
   */
@@ -799,13 +844,37 @@
  UCListItemAttached *UCListItem::qmlAttachedProperties(QObject *owner)
+ {
--    return new UCListItemAttached(owner);
++    /*
++     * Detect the attachee, whether is it a child item of the panelItem. The panelItem
++     * itself cannot be detected, as the object can be attached during the call of
++     * component.beginCreate().
++     */
++    UCListItemAttached *attached = new UCListItemAttached(owner);
++    QQuickItem *item = qobject_cast<QQuickItem*>(owner);
++    while (item) {
++        // has item our attached property?
++        UCListItemAttached *itemAttached = static_cast<UCListItemAttached*>(
++                    qmlAttachedPropertiesObject<UCListItem>(item, false));
++        if (itemAttached) {
++            attached->connectToAttached(itemAttached);
++            break;
++        }
++        item = item->parentItem();
++    }
++    return attached;
+ }
  void UCListItem::componentComplete()
+ {
      UCStyledItemBase::componentComplete();
      Q_D(UCListItem);
++    // anchor contentItem prior doing anything else
++    QQuickAnchors *contentAnchors = QQuickItemPrivate::get(d->contentItem)->anchors();
++    contentAnchors->setTop(d->top());
++    contentAnchors->setBottom(d->bottom());
++    d->adjustContentItemHeight();
++    d->lockContentItem(true);
++
      d->ready = true;
      /* We only deal with ListView, as for other cases we would need to check the children
       * changes, which would have an enormous impact on performance in case of huge amount
@@ -838,21 +907,23 @@
              d->flickable = qobject_cast<QQuickFlickable*>(data.item->parentItem());
+         }
--        // attach ListItem properties to the flickable or to the parent item
--        if (d->flickable) {
--            // connect to flickable to get width changes
--            d->attachedProperties = static_cast<UCListItemAttached*>(qmlAttachedPropertiesObject<UCListItem>(d->flickable));
++        // attach ViewItems to parent item or to ListView
++        QQuickItem *parentAttachee = data.item;
++        if (d->flickable && d->flickable->inherits("QQuickListView")) {
++            // attach to ListView
++            d->parentAttached = static_cast<UCViewItemsAttached*>(qmlAttachedPropertiesObject<UCViewItemsAttached>(d->flickable));
++            parentAttachee = d->flickable;
          } else if (data.item) {
--            d->attachedProperties = static_cast<UCListItemAttached*>(qmlAttachedPropertiesObject<UCListItem>(data.item));
++            d->parentAttached = static_cast<UCViewItemsAttached*>(qmlAttachedPropertiesObject<UCViewItemsAttached>(data.item));
          } else {
              // mark as not ready, so no action should be performed which depends on readyness
              d->ready = false;
              // about to be deleted or reparented, disable attached
--            d->attachedProperties = 0;
++            d->parentAttached = 0;
+         }
--        if (data.item) {
--            QObject::connect(d->flickable ? d->flickable : data.item, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()));
++        if (parentAttachee) {
++            QObject::connect(parentAttachee, SIGNAL(widthChanged()), this, SLOT(_q_updateSize()), Qt::DirectConnection);
+         }
          // update size
@@ -860,14 +931,6 @@
+     }
+ }
--void UCListItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
--{
--    UCStyledItemBase::geometryChanged(newGeometry, oldGeometry);
--    // resize contentItem item
--    Q_D(UCListItem);
--    d->resize();
--}
--
  QSGNode *UCListItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
+ {
      Q_UNUSED(data);
@@ -924,19 +987,26 @@
+ {
      UCStyledItemBase::mousePressEvent(event);
      Q_D(UCListItem);
--    if (d->attachedProperties && d->attachedProperties->isMoving()) {
++    if (d->parentAttached && d->parentAttached->isMoving()) {
          // while moving, we cannot select any items
          return;
+     }
      if (event->button() == Qt::LeftButton && d->canHighlight(event)) {
++        // stop any ongoing animation!
++        if (d->animator) {
++            d->animator->stop();
++        }
          d->setHighlighted(true);
          d->lastPos = d->pressedPos = event->localPos();
          // connect the Flickable to know when to rebound
          d->listenToRebind(true);
          // if it was moved, grab the panels
          if (d->swiped) {
--            d->grabPanel(d->leadingActions, true);
--            d->grabPanel(d->trailingActions, true);
++            UCActionPanel::grabPanel(&d->leadingPanel, this, true);
++            UCActionPanel::grabPanel(&d->trailingPanel, this, false);
++            if (d->parentAttached) {
++                d->parentAttached->disableInteractive(this, true);
++            }
+         }
+     }
      // accept the event so we get the rest of the events as well
@@ -950,8 +1020,8 @@
      // set released
      if (d->highlighted) {
          d->listenToRebind(false);
--        if (d->attachedProperties) {
--            d->attachedProperties->disableInteractive(this, false);
++        if (d->parentAttached) {
++            d->parentAttached->disableInteractive(this, false);
+         }
          if (!d->suppressClick) {
@@ -968,8 +1038,8 @@
      UCStyledItemBase::mouseMoveEvent(event);
      // accept the tugging only if the move is within the threshold
--    bool leadingAttached = UCListItemActionsPrivate::isConnectedTo(d->leadingActions, this);
--    bool trailingAttached = UCListItemActionsPrivate::isConnectedTo(d->trailingActions, this);
++    bool leadingAttached = UCActionPanel::isConnected(d->leadingPanel);
++    bool trailingAttached = UCActionPanel::isConnected(d->trailingPanel);
      if (d->highlighted && !(leadingAttached || trailingAttached)) {
          // check if we can initiate the drag at all
          // only X direction matters, if Y-direction leaves the threshold, but X not, the tug is not valid
@@ -984,8 +1054,13 @@
              // got connected ad which not; this may fail in case of shared ListItemActions,
              // as then the panel is shared between the list items, and the panel might be
              // still in use in other panels. See UCListItemActionsPrivate::connectToListItem
--            leadingAttached = d->grabPanel(d->leadingActions, true);
--            trailingAttached = d->grabPanel(d->trailingActions, true);
++            leadingAttached = UCActionPanel::grabPanel(&d->leadingPanel, this, true);
++            trailingAttached = UCActionPanel::grabPanel(&d->trailingPanel, this, false);
++            // unlock contentItem's left/right edges
++            d->lockContentItem(false);
++            if (d->parentAttached) {
++                d->parentAttached->disableInteractive(this, true);
++            }
              // create animator if not created yet
              if (!d->animator) {
                  d->animator = new UCListItemSnapAnimator(this);
@@ -1007,19 +1082,19 @@
              d->contentItem->setX(x);
              // decide which panel is visible by checking the contentItem's X coordinates
              if (d->contentItem->x() > 0) {
--                if (leadingAttached) {
--                    UCListItemActionsPrivate::get(d->leadingActions)->panelItem->setVisible(true);
++                if (d->leadingPanel) {
++                    d->leadingPanel->panel()->setVisible(true);
+                 }
--                if (trailingAttached) {
--                    UCListItemActionsPrivate::get(d->trailingActions)->panelItem->setVisible(false);
++                if (d->trailingPanel) {
++                    d->trailingPanel->panel()->setVisible(false);
+                 }
              } else if (d->contentItem->x() < 0) {
                  // trailing revealed
--                if (leadingAttached) {
--                    UCListItemActionsPrivate::get(d->leadingActions)->panelItem->setVisible(false);
++                if (d->leadingPanel) {
++                    d->leadingPanel->panel()->setVisible(false);
+                 }
--                if (trailingAttached) {
--                    UCListItemActionsPrivate::get(d->trailingActions)->panelItem->setVisible(true);
++                if (d->trailingPanel) {
++                    d->trailingPanel->panel()->setVisible(true);
+                 }
+             }
+         }
@@ -1093,16 +1168,10 @@
+     }
      // snap out before we change the actions
      d->promptRebound();
--    // then delete panelItem
--    if (d->leadingActions) {
--        UCListItemActionsPrivate *list = UCListItemActionsPrivate::get(d->leadingActions);
--        delete list->panelItem;
--        list->panelItem = 0;
--    }
++    // then delete panel
++    delete d->leadingPanel;
++    d->leadingPanel = 0;
      d->leadingActions = actions;
--    if (d->leadingActions == d->trailingActions && d->leadingActions) {
--        qmlInfo(this) << UbuntuI18n::tr("leadingActions and trailingActions cannot share the same object!");
--    }
      Q_EMIT leadingActionsChanged();
+ }
@@ -1127,16 +1196,10 @@
+     }
      // snap out before we change the actions
      d->promptRebound();
--    // then delete panelItem
--    if (d->trailingActions) {
--        UCListItemActionsPrivate *list = UCListItemActionsPrivate::get(d->trailingActions);
--        delete list->panelItem;
--        list->panelItem = 0;
--    }
++    // then delete panel
++    delete d->trailingPanel;
++    d->trailingPanel = 0;
      d->trailingActions = actions;
--    if (d->leadingActions == d->trailingActions && d->trailingActions) {
--        qmlInfo(this) << UbuntuI18n::tr("leadingActions and trailingActions cannot share the same object!");
--    }
      Q_EMIT trailingActionsChanged();
+ }
@@ -1171,8 +1234,8 @@
   * The default values for the properties are:
   * \list
   * \li \c visible: true
-- * \li \c leftMargin: 2 GU
-- * \li \c rightMargin: 2 GU
++ * \li \c leftMargin: 0
++ * \li \c rightMargin: 0
   * \endlist
   */
  UCListItemDivider* UCListItem::divider() const
@@ -1253,7 +1316,8 @@
  /*!
   * \qmlproperty color ListItem::highlightColor
-- * Configures the color when highlighted. Defaults to the theme palette's background color.
++ * Configures the color when highlighted. Defaults to the theme palette's background
++ * color. If changed, it can be reset by assigning undefined as value.
   */
  QColor UCListItem::highlightColor() const
+ {
@@ -1263,12 +1327,20 @@
  void UCListItem::setHighlightColor(const QColor &color)
+ {
      Q_D(UCListItem);
++    // mark it as custom even if the value is the same as the previous one
++    d->customColor = true;
      if (d->highlightColor == color) {
          return;
+     }
      d->highlightColor = color;
--    // no more theme change watch
--    d->customColor = true;
++    update();
++    Q_EMIT highlightColorChanged();
++}
++void UCListItem::resetHighlightColor()
++{
++    Q_D(UCListItem);
++    d->customColor = false;
++    d->highlightColor = getPaletteColor("selected", "background");
      update();
      Q_EMIT highlightColorChanged();
+ }
@@ -1277,7 +1349,7 @@
   * \qmlproperty real ListItem::swipeOvershoot
   * The property configures the overshoot value on swiping. Its default value is
   * configured by the \l {ListItemStyle}{style}. Any positive value overrides the
-- * default value, and any negative value resets it back to the default.
++ * default value, and any negative or undefined value resets it back to the default.
   */
  qreal UCListItemPrivate::swipeOvershoot() const
+ {
@@ -1285,16 +1357,26 @@
+ }
  void UCListItemPrivate::setSwipeOvershoot(qreal overshoot)
+ {
++    // mark any positive value as custom even if it is the same as the previous one
++    customOvershoot = (overshoot >= 0.0);
      // same value should be guarded only if the style hasn't been loaded yet
      // swipeOvershoot can be set to 0 prior the style is loaded.
      if (this->overshoot == overshoot && styleItem) {
          return;
+     }
--    customOvershoot = (overshoot >= 0.0);
--    this->overshoot = (overshoot < 0.0) ?
--                // reset, use style to get the overshoot value
--                (styleItem ? styleItem->m_swipeOvershoot : 0.0) :
--                overshoot;
++    if (!customOvershoot) {
++        resetSwipeOvershoot();
++        return;
++    }
++    this->overshoot = overshoot;
++    update();
++    Q_Q(UCListItem);
++    Q_EMIT q->swipeOvershootChanged();
++}
++void UCListItemPrivate::resetSwipeOvershoot()
++{
++    customOvershoot = false;
++    overshoot = styleItem ? styleItem->m_swipeOvershoot : 0.0;
      update();
      Q_Q(UCListItem);
      Q_EMIT q->swipeOvershootChanged();
 === modified file 'modules/Ubuntu/Components/plugin/uclistitem.h'
 --- modules/Ubuntu/Components/plugin/uclistitem.h	2014-12-18 10:08:56 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitem.h	2015-01-16 14:53:38 +0000
@@ -34,17 +34,23 @@
      Q_PROPERTY(UCListItemActions *leadingActions READ leadingActions WRITE setLeadingActions NOTIFY leadingActionsChanged DESIGNABLE false)
      Q_PROPERTY(UCListItemActions *trailingActions READ trailingActions WRITE setTrailingActions NOTIFY trailingActionsChanged DESIGNABLE false)
      Q_PROPERTY(bool highlighted READ highlighted NOTIFY highlightedChanged)
--    Q_PRIVATE_PROPERTY(UCListItem::d_func(), qreal swipeOvershoot READ swipeOvershoot WRITE setSwipeOvershoot NOTIFY swipeOvershootChanged)
++    Q_PRIVATE_PROPERTY(UCListItem::d_func(), qreal swipeOvershoot READ swipeOvershoot WRITE setSwipeOvershoot RESET resetSwipeOvershoot NOTIFY swipeOvershootChanged)
      Q_PRIVATE_PROPERTY(UCListItem::d_func(), bool contentMoving READ contentMoving NOTIFY contentMovingChanged)
      Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
--    Q_PROPERTY(QColor highlightColor READ highlightColor WRITE setHighlightColor NOTIFY highlightColorChanged)
++    Q_PROPERTY(QColor highlightColor READ highlightColor WRITE setHighlightColor RESET resetHighlightColor NOTIFY highlightColorChanged)
      Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlListProperty<QObject> listItemData READ data DESIGNABLE false)
      Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlListProperty<QQuickItem> listItemChildren READ children NOTIFY listItemChildrenChanged DESIGNABLE false)
      // FIXME move these to StyledItemBase with subtheming
--    Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlComponent *style READ style WRITE setStyle NOTIFY styleChanged)
++    Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQmlComponent *style READ style WRITE setStyle RESET resetStyle NOTIFY styleChanged)
      Q_PRIVATE_PROPERTY(UCListItem::d_func(), QQuickItem *__styleInstance READ styleInstance NOTIFY __styleInstanceChanged)
      Q_CLASSINFO("DefaultProperty", "listItemData")
++    Q_ENUMS(PanelStatus)
  public:
++    enum PanelStatus {
++        None,
++        Leading,
++        Trailing
++    };
      explicit UCListItem(QQuickItem *parent = 0);
      ~UCListItem();
@@ -61,12 +67,12 @@
      void setColor(const QColor &color);
      QColor highlightColor() const;
      void setHighlightColor(const QColor &color);
++    void resetHighlightColor();
  protected:
      void componentComplete();
      QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data);
      void itemChange(ItemChange change, const ItemChangeData &data);
--    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
      void mousePressEvent(QMouseEvent *event);
      void mouseReleaseEvent(QMouseEvent *event);
      void mouseMoveEvent(QMouseEvent *event);
@@ -103,13 +109,57 @@
  QML_DECLARE_TYPEINFO(UCListItem, QML_HAS_ATTACHED_PROPERTIES)
++class UCAction;
++class UCListItemActions;
  class UCListItemAttachedPrivate;
  class UCListItemAttached : public QObject
+ {
      Q_OBJECT
++    Q_PROPERTY(UCListItemActions *actions READ actions NOTIFY actionsChanged)
++    Q_PROPERTY(QQmlListProperty<UCAction> visibleActions READ visibleActions NOTIFY visibleActionsChanged)
++    Q_PROPERTY(UCListItem *item READ item NOTIFY itemChanged)
++    Q_PROPERTY(int index READ index NOTIFY indexChanged)
++    Q_PROPERTY(UCListItem::PanelStatus panelStatus READ panelStatus NOTIFY panelStatusChanged)
  public:
--    explicit UCListItemAttached(QObject *owner);
++    UCListItemAttached(QObject *parent = 0);
      ~UCListItemAttached();
++    void setList(UCListItem *list, bool leading, bool visualizeActions);
++    void connectToAttached(UCListItemAttached *parentAttached);
++
++    UCListItemActions *actions() const;
++    QQmlListProperty<UCAction> visibleActions();
++    UCListItem *item();
++    int index();
++    UCListItem::PanelStatus panelStatus();
++
++public Q_SLOTS:
++    void snapToPosition(qreal position);
++
++Q_SIGNALS:
++    void actionsChanged();
++    void visibleActionsChanged();
++    void itemChanged();
++    void indexChanged();
++    void panelStatusChanged();
++
++private:
++    Q_DECLARE_PRIVATE(UCListItemAttached)
++    friend class UCListItemAction;
++
++private Q_SLOTS:
++    void updateVisibleActions();
++};
++
++
++class UCViewItemsAttachedPrivate;
++class UCViewItemsAttached : public QObject
++{
++    Q_OBJECT
++public:
++    explicit UCViewItemsAttached(QObject *owner);
++    ~UCViewItemsAttached();
++
++    static UCViewItemsAttached *qmlAttachedProperties(QObject *owner);
      bool listenToRebind(UCListItem *item, bool listen);
      void disableInteractive(UCListItem *item, bool disable);
@@ -119,8 +169,9 @@
  private Q_SLOTS:
      void unbindItem();
  private:
--    Q_DECLARE_PRIVATE(UCListItemAttached)
--    QScopedPointer<UCListItemAttachedPrivate> d_ptr;
++    Q_DECLARE_PRIVATE(UCViewItemsAttached)
++    QScopedPointer<UCViewItemsAttachedPrivate> d_ptr;
  };
++QML_DECLARE_TYPEINFO(UCViewItemsAttached, QML_HAS_ATTACHED_PROPERTIES)
  #endif // UCLISTITEM_H
 === modified file 'modules/Ubuntu/Components/plugin/uclistitem_p.h'
 --- modules/Ubuntu/Components/plugin/uclistitem_p.h	2015-01-07 06:42:09 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitem_p.h	2015-01-16 14:53:38 +0000
@@ -22,6 +22,15 @@
  #include <QtCore/QPointer>
  #include <QtQuick/private/qquickrectangle_p.h>
++#define MIN(x, y)           ((x < y) ? x : y)
++#define MAX(x, y)           ((x > y) ? x : y)
++#define CLAMP(v, min, max)  (min <= max) ? MAX(min, MIN(v, max)) : MAX(max, MIN(v, min))
++
++#define IMPLICIT_LISTITEM_WIDTH_GU      40
++#define IMPLICIT_LISTITEM_HEIGHT_GU     7
++#define DIVIDER_THICKNESS_DP            2
++#define DEFAULT_SWIPE_THRESHOLD_GU      1.5
++
  class QQuickFlickable;
  class QQuickPropertyAnimation;
  class UCListItemContent;
@@ -29,6 +38,7 @@
  class UCListItemActions;
  class UCListItemSnapAnimator;
  class UCListItemStyle;
++class UCActionPanel;
  class UCListItemPrivate : public UCStyledItemBasePrivate
+ {
      Q_DECLARE_PUBLIC(UCListItem)
@@ -53,19 +63,17 @@
      bool canHighlight(QMouseEvent *event);
      void setHighlighted(bool pressed);
      void setSwiped(bool tugged);
--    bool grabPanel(UCListItemActions *optionList, bool isTugged);
      void listenToRebind(bool listen);
--    void resize();
++    void lockContentItem(bool lock);
++    void adjustContentItemHeight();
      void update();
      void clampAndMoveX(qreal &x, qreal dx);
      bool highlighted:1;
      bool contentMoved:1;
--    bool highlightColorChanged:1;
      bool swiped:1;
      bool suppressClick:1;
      bool ready:1;
--    bool customStyle:1;
      bool customColor:1;
      bool customOvershoot:1;
      bool flicked:1;
@@ -77,45 +85,65 @@
      QColor highlightColor;
      QPointer<QQuickItem> countOwner;
      QPointer<QQuickFlickable> flickable;
--    QPointer<UCListItemAttached> attachedProperties;
++    QPointer<UCViewItemsAttached> parentAttached;
      QQuickItem *contentItem;
      UCListItemDivider *divider;
      UCListItemActions *leadingActions;
      UCListItemActions *trailingActions;
++    UCActionPanel *leadingPanel;
++    UCActionPanel *trailingPanel;
      UCListItemSnapAnimator *animator;
      // FIXME move these to StyledItemBase togehther with subtheming.
      QQmlComponent *styleComponent;
++    QQmlComponent *implicitStyleComponent;
      UCListItemStyle *styleItem;
      // getters/setters
      qreal swipeOvershoot() const;
      void setSwipeOvershoot(qreal overshoot);
++    void resetSwipeOvershoot();
      QQmlListProperty<QObject> data();
      QQmlListProperty<QQuickItem> children();
      bool contentMoving() const;
      void setContentMoving(bool moved);
      QQmlComponent *style() const;
      void setStyle(QQmlComponent *delegate);
--    bool loadStyle(bool reload);
++    void resetStyle();
      void initStyleItem();
      QQuickItem *styleInstance() const;
  };
++class UCListItemAttachedPrivate : public QObjectPrivate
++{
++    Q_DECLARE_PUBLIC(UCListItemAttached)
++public:
++    UCListItemAttachedPrivate() : QObjectPrivate(), panel(0), listItem(0) {}
++
++    static UCListItemAttachedPrivate* get(UCListItemAttached *that)
++    {
++        return that->d_func();
++    }
++
++    UCActionPanel *panel;
++    UCListItem *listItem;
++    QList<UCAction*> visibleActions;
++};
++
  class PropertyChange;
--class UCListItemAttachedPrivate
++class UCViewItemsAttachedPrivate
+ {
--    Q_DECLARE_PUBLIC(UCListItemAttached)
++    Q_DECLARE_PUBLIC(UCViewItemsAttached)
  public:
--    UCListItemAttachedPrivate(UCListItemAttached *qq);
--    ~UCListItemAttachedPrivate();
++    UCViewItemsAttachedPrivate(UCViewItemsAttached *qq);
++    ~UCViewItemsAttachedPrivate();
      void clearFlickablesList();
      void buildFlickablesList();
      void clearChangesList();
      void buildChangesList(const QVariant &newValue);
--    UCListItemAttached *q_ptr;
++    UCViewItemsAttached *q_ptr;
      bool globalDisabled;
      QList< QPointer<QQuickFlickable> > flickables;
      QList< PropertyChange* > changes;
@@ -123,6 +151,41 @@
      QPointer<UCListItem> disablerItem;
  };
++class UCActionPanel : public QObject
++{
++    Q_OBJECT
++public:
++    ~UCActionPanel();
++    static bool grabPanel(UCActionPanel **panel, UCListItem *item, bool leading);
++    static void ungrabPanel(UCActionPanel *panel);
++    static bool isConnected(UCActionPanel *panel);
++
++    UCListItemActions *actions();
++    QQuickItem *panel() const;
++    UCListItem::PanelStatus panelStatus()
++    {
++        return status;
++    }
++    bool isLeading() const
++    {
++        return leading;
++    }
++
++Q_SIGNALS:
++    void statusChanged();
++
++private:
++    UCActionPanel(UCListItem *item, bool leading);
++    bool createPanel(QQmlComponent *panelDelegate);
++    UCListItemAttached *attachedObject();
++
++    UCListItem *listItem;
++    QQuickItem *panelItem;
++    UCListItem::PanelStatus status;
++    bool leading:1;
++    bool connected:1;
++};
++
  class UCListItemDivider : public QObject
+ {
      Q_OBJECT
@@ -159,8 +222,6 @@
      void setColorTo(const QColor &color);
      bool m_visible:1;
--    bool m_leftMarginChanged:1;
--    bool m_rightMarginChanged:1;
      bool m_colorFromChanged:1;
      bool m_colorToChanged:1;
      qreal m_thickness;
@@ -187,6 +248,7 @@
      ~UCListItemSnapAnimator();
      bool snap(qreal to);
++    void stop();
      void complete();
  public Q_SLOTS:
 === modified file 'modules/Ubuntu/Components/plugin/uclistitemactions.cpp'
 --- modules/Ubuntu/Components/plugin/uclistitemactions.cpp	2014-12-01 14:50:13 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitemactions.cpp	2015-01-16 14:53:38 +0000
@@ -27,167 +27,13 @@
  UCListItemActionsPrivate::UCListItemActionsPrivate()
      : QObjectPrivate()
--    , status(UCListItemActions::Disconnected)
--    , offsetDragged(0)
--    , optionSlotWidth(0.0)
      , delegate(0)
--    , panelDelegate(0)
--    , panelItem(0)
+ {
+ }
  UCListItemActionsPrivate::~UCListItemActionsPrivate()
+ {
+ }
--void UCListItemActionsPrivate::_q_updateDraggedOffset()
--{
--    UCListItem *listItem = qobject_cast<UCListItem*>(panelItem->parentItem());
--    if (!listItem) {
--        return;
--    }
--
--    Q_Q(UCListItemActions);
--    offsetDragged = (status == UCListItemActions::Leading) ? panelItem->width() + panelItem->x() :
--                         listItem->width() - panelItem->x();
--    if (offsetDragged < 0.0) {
--        offsetDragged = 0.0;
--    }
--}
--
--UCListItemActionsAttached *UCListItemActionsPrivate::attachedObject()
--{
--    if (!panelItem) {
--        return 0;
--    }
--    return static_cast<UCListItemActionsAttached*>(
--                qmlAttachedPropertiesObject<UCListItemActions>(panelItem, false));
--}
--
--/*
-- * Connects a ListItem to the ListItemActions' panel and returns true upon successful connection.
-- * Connection may fail if there is a different ListItem connected. In this case the new ListItem
-- * will be queued and automatically connected when the previous ListItem disconnects.
-- * The panel is only re-created when a different Component is used to create it.
-- * FIXME - despite each ListItem uses the same document to create the panel, theming engine
-- * provides different Component objects for each, due to not caching the components created.
-- * This must be fixed to optimize memory usage.
-- */
--bool UCListItemActionsPrivate::connectToListItem(UCListItemActions *actions, UCListItem *listItem, bool leading)
--{
--    UCListItemActionsPrivate *_this = get(actions);
--    if (!_this) {
--        return false;
--    }
--    // do we have a panel created already?
--    if (_this->panelItem) {
--        if (isConnectedTo(actions, listItem)) {
--            return true;
--        }
--        if (_this->panelItem->parentItem() && _this->panelItem->parentItem() != listItem) {
--            // set the requesting listItem as queuedItem
--            _this->queuedItem = listItem;
--            return false;
--        }
--    }
--    // no parent set or panelItem yet, proceed with panel creation
--    UCListItemPrivate *pItem = UCListItemPrivate::get(listItem);
--    pItem->initStyleItem();
--    if (!pItem->styleItem || (pItem->styleItem && !_this->createPanelItem(pItem->styleItem->m_actionsDelegate))) {
--        return false;
--    }
--
--    // check if the panel is still connected to a ListItem
--    // this may happen if there is a swipe over an other item while the previous
--    // one is rebounding
--    _this->panelItem->setParentItem(listItem);
--    if (_this->attachedObject()) {
--        _this->attachedObject()->connectListItem(listItem, true);
--    }
--    _this->offsetDragged = 0.0;
--    _this->status = leading ? UCListItemActions::Leading : UCListItemActions::Trailing;
--    Q_EMIT actions->statusChanged(_this->status);
--    return true;
--}
--
--void UCListItemActionsPrivate::disconnectFromListItem(UCListItemActions *actions)
--{
--    UCListItemActionsPrivate *_this = get(actions);
--    if (!_this || !_this->panelItem || !_this->panelItem->parentItem()) {
--        return;
--    }
--
--    if (_this->attachedObject()) {
--        _this->attachedObject()->connectListItem(static_cast<UCListItem*>(_this->panelItem->parentItem()), false);
--    }
--    _this->panelItem->setParentItem(0);
--    _this->status = UCListItemActions::Disconnected;
--    Q_EMIT actions->statusChanged(_this->status);
--    // if there was a queuedItem, make it grab the actions list
--    if (_this->queuedItem) {
--        UCListItemPrivate::get(_this->queuedItem.data())->grabPanel(actions, true);
--        // remove item from queue
--        _this->queuedItem.clear();
--    }
--}
--
--bool UCListItemActionsPrivate::isConnectedTo(UCListItemActions *actions, UCListItem *listItem)
--{
--    UCListItemActionsPrivate *_this = get(actions);
--    return _this && _this->panelItem &&
--            (_this->status != UCListItemActions::Disconnected) &&
--            (_this->panelItem->parentItem() == listItem);
--}
--
--QQuickItem *UCListItemActionsPrivate::createPanelItem(QQmlComponent *panel)
--{
--    if (panelItem && panelDelegate == panel) {
--        return panelItem;
--    }
--    // delete the panel if the next item's actionsDelegate differs from the
--    // one this panel was created from
--    if (panelDelegate != panel) {
--        delete panelItem;
--        panelItem = 0;
--    }
--
--    Q_Q(UCListItemActions);
--    if (!panel) {
--        qmlInfo(q) << UbuntuI18n::instance().tr("actionsDelegate not set!");
--        return 0;
--    }
--
--    panelDelegate = panel;
--    if (!panelDelegate->isError()) {
--        panelItem = qobject_cast<QQuickItem*>(panelDelegate->beginCreate(qmlContext(q)));
--        if (panelItem) {
--            QQml_setParent_noEvent(panelItem, q);
--            // add panelItem to data so we can access it in case is needed (i.e. tests)
--            data.append(panelItem);
--            // create attached property!
--            UCListItemActionsAttached *attached = static_cast<UCListItemActionsAttached*>(
--                        qmlAttachedPropertiesObject<UCListItemActions>(panelItem));
--            if (!attached->container()) {
--                attached->setList(q);
--            } else {
--                // container is set, but we need to emit the signal again so we get the
--                // attached props updated for those cases when the attached property is
--                // created before the statement above
--                Q_EMIT attached->containerChanged();
--            }
--            panelDelegate->completeCreate();
--
--            // calculate option's slot size
--            offsetDragged = 0.0;
--            // connect to panel to catch dragging
--            QObject::connect(panelItem, SIGNAL(xChanged()), q, SLOT(_q_updateDraggedOffset()));
--        }
--    } else {
--        qmlInfo(q) << panelDelegate->errorString();
--    }
--
--    return panelItem;
--}
--
  /*!
   * \qmltype ListItemActions
   * \instantiates UCListItemActions
@@ -199,86 +45,22 @@
+  *
   * ListItem accepts actions that can be configured to appear when swiped to left
   * or right. The API does not limit the number of actions to be assigned for leading
-- * or trailing actions, however the design constrains are allowing a maximum of
++ * or trailing actions, however the design constraints are allowing a maximum of
   * 1 action on leading- and a maximum of 3 actions on trailing side of the ListItem.
+  *
   * The \l actions are Action instances or elements derived from Action. The default
   * visualization of the actions can be overridden using the \l delegate property,
   * and the default implementation uses the \c name property of the Action.
+  *
-- * The leading and trailing actions are placed on a panel item, which is created
-- * the first time the actions are accessed. The colors of the panel is taken from
-- * the theme's palette.
-- *
-- * When swiped, panels reveal the actions one by one. In case an action is revealed
-- * more than 50%, the action will be snapped and revealed completely. This is also
-- * valid for the case when the action is visible less than 50%, in which case the
-- * action is hidden. Actions can be triggered by tapping.
-- *
-- * \note You can use the same ListItemActions for leading and for trailing actions
-- * the same time only if the instance is used by different groups of list items,
-- * where one group uses it as leading and other group as trailing. In any other
-- * circumstances use separate ListItemActions for leading and trailing actions.
-- * \qml
-- * import QtQuick 2.2
-- * import Ubuntu.Components 1.2
-- * MainView {
-- *     width: units.gu(40)
-- *     height: units.gu(71)
-- *
-- *     ListItemActions {
-- *         id: sharedActions
-- *         actions: [
-- *             Action {
-- *                 iconName: "search"
-- *             },
-- *             Action {
-- *                 iconName: "edit"
-- *             },
-- *             Action {
-- *                 iconName: "copy"
-- *             }
-- *         ]
-- *     }
-- *
-- *     Column {
-- *         ListItem {
-- *             leadingActions: sharedActions
-- *         }
-- *         UbuntuListView {
-- *             anchors.fill: parent
-- *             model: 10000
-- *             delegate: ListItem {
-- *                 trailingActions: sharedActions
-- *             }
-- *         }
-- *     }
-- * }
-- * \endqml
-- *
   * \section3 Using with ListViews
   * ListItemActions instances can be shared between ListItem instances within the
   * same view. When shared, the memory footprint of the view will be lot smaller,
-- * as there will be no individual panel created for each list's actions visualization.
-- * Depending on how long the initialization of the component used in \l {ListItemStyle::actionsDelegate}
-- * {actionsDelegate} takes, creation time will be also reduced to one time per view.
-- * However, this implies that swiping a new ListItem content while another one is
-- * swiped will result in showing the newly swiped item's panel delayed, as the
-- * panel can be shown only after the previous item's snapping is completed. Depending
-- * on the \l {ListItemStyle::snapAnimation}{snapAnimation} duration, this may take some time, and the
-- * response time of the UI can become unacceptable.
-- *
++ * as there will be no individual action container created for each list's actions.
   * Having individual ListItemActions instances increases the memory footprint,
-- * however the UI will be more responsive as swiping individual ListItems will
-- * not have to wait till the previous ListItem's panel is snapped out (rebound).
-- * On the other hand, memory consumption will increase significantly due to
-- * separate panel creation, and performance may decrease with up to 40%, depending
-- * on what way are the actions declared, within the ListItemActions or as shared
-- * actions.
++ * and also has performance impact on kinetic scrolling.
+  *
-- * The example above illustrates how to share ListItemActions between ListItem
-- * delegates, which can be the worst-performant but most lightwaight memory consumer
-- * setup. The following example illustrates the worst case:
++ * The examples below illustrate the worst and best practice when used in a ListView.
++ * The worst case:
   * \qml
   * import QtQuick 2.2
   * import Ubuntu.Components 1.2
@@ -323,33 +105,33 @@
   *     width: units.gu(40)
   *     height: units.gu(71)
+  *
-- *     property list<Action> leading: [
-- *         Action {
++ *     ListItemActions {
++ *         id: leading
++ *         actions: Action {
   *             iconName: "delete"
   *         }
-- *     ]
-- *     property list<Action> trailing: [
-- *         Action {
-- *             iconName: "search"
-- *         },
-- *         Action {
-- *             iconName: "edit"
-- *         },
-- *         Action {
-- *             iconName: "copy"
-- *         }
-- *     ]
++ *     }
++ *     ListItemActions {
++ *         id: trailing
++ *         actions: [
++ *             Action {
++ *                 iconName: "search"
++ *             },
++ *             Action {
++ *                 iconName: "edit"
++ *             },
++ *             Action {
++ *                 iconName: "copy"
++ *             }
++ *         ]
++ *     }
+  *
   *     UbuntuListView {
   *         anchors.fill: parent
   *         model: 10000
   *         delegate: ListItem {
-- *             leadingActions: ListItemActions {
-- *                 actions: leading
-- *             }
-- *             trailingActions: ListItemActions {
-- *                 actions: trailing
-- *             }
++ *             leadingActions: leading
++ *             trailingActions: trailing
   *         }
   *     }
   * }
@@ -362,11 +144,6 @@
   * parameter to identify the instance of the ListItem on which it was executed,
   * in which case ListItem will change the type from \c Actions.None to \c Actions.Integer
   * when it is triggered.
-- *
-- * \section3 Attached properties
-- * ListItemActions provides a set of attached properties to the panels visualizing
-- * the actions. These properties can be used by implementations visualizing the
-- * actions.
   */
  UCListItemActions::UCListItemActions(QObject *parent)
@@ -377,28 +154,6 @@
+ {
+ }
--UCListItemActionsAttached *UCListItemActions::qmlAttachedProperties(QObject *owner)
--{
--    /*
--     * Detect the attachee, whether is it a child item of the panelItem. The panelItem
--     * itself cannot be detected, as the object can be attached during the call of
--     * component.beginCreate().
--     */
--    UCListItemActionsAttached *attached = new UCListItemActionsAttached(owner);
--    QQuickItem *item = qobject_cast<QQuickItem*>(owner);
--    while (item) {
--        // has item our attached property?
--        UCListItemActionsAttached *itemAttached = static_cast<UCListItemActionsAttached*>(
--                    qmlAttachedPropertiesObject<UCListItemActions>(item, false));
--        if (itemAttached) {
--            attached->setList(itemAttached->container());
--            break;
--        }
--        item = item->parentItem();
--    }
--    return attached;
--}
--
  /*!
   * \qmlproperty Component ListItemActions::delegate
   * The property holds the custom delegate to visualize the actions listed in the
@@ -461,7 +216,7 @@
   * }
   * \endqml
   * \note Putting a Rectangle in the delegate can be used to override the color
-- * of the panel.
++ * of the panel. Also all ListItem attached properties can be used in the delegates.
+  *
   * Defaults to null.
   */
 === modified file 'modules/Ubuntu/Components/plugin/uclistitemactions.h'
 --- modules/Ubuntu/Components/plugin/uclistitemactions.h	2014-12-01 12:20:02 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitemactions.h	2015-01-16 14:53:38 +0000
@@ -22,7 +22,6 @@
  class QQmlComponent;
  class UCAction;
--class UCListItemActionsAttached;
  class UCListItemActionsPrivate;
  class UCListItemActions : public QObject
+ {
@@ -31,18 +30,10 @@
      Q_PROPERTY(QQmlListProperty<UCAction> actions READ actions CONSTANT)
      Q_PROPERTY(QQmlListProperty<QObject> data READ data)
      Q_CLASSINFO("DefaultProperty", "data")
--    Q_ENUMS(Status)
  public:
--    enum Status {
--        Disconnected,
--        Leading,
--        Trailing
--    };
      explicit UCListItemActions(QObject *parent = 0);
      ~UCListItemActions();
--    static UCListItemActionsAttached *qmlAttachedProperties(QObject *owner);
--
      QQmlComponent *delegate() const;
      void setDelegate(QQmlComponent *delegate);
      QQmlListProperty<UCAction> actions();
@@ -50,64 +41,9 @@
  Q_SIGNALS:
      void delegateChanged();
--    void statusChanged(Status status);
  private:
      Q_DECLARE_PRIVATE(UCListItemActions)
--    Q_PRIVATE_SLOT(d_func(), void _q_updateDraggedOffset())
--};
--
--class UCListItemActionsAttached : public QObject
--{
--    Q_OBJECT
--    Q_PROPERTY(UCListItemActions *container READ container NOTIFY containerChanged)
--    Q_PROPERTY(QQmlListProperty<UCAction> visibleActions READ visibleActions NOTIFY visibleActionsChanged)
--    Q_PROPERTY(UCListItem *listItem READ listItem NOTIFY listItemChanged)
--    Q_PROPERTY(int listItemIndex READ listItemIndex NOTIFY listItemIndexChanged)
--    Q_PROPERTY(qreal offset READ offset NOTIFY offsetChanged)
--    Q_PROPERTY(UCListItemActions::Status status READ status NOTIFY statusChanged)
--    Q_PROPERTY(bool swiping READ swiping NOTIFY swipingChanged)
--public:
--    UCListItemActionsAttached(QObject *parent = 0);
--    ~UCListItemActionsAttached();
--    void setList(UCListItemActions *list);
--    void connectListItem(UCListItem *item, bool connect);
--
--    UCListItemActions *container() const
--    {
--        return m_container.data();
--    }
--    QQmlListProperty<UCAction> visibleActions();
--    UCListItem *listItem();
--    int listItemIndex();
--    bool swiping();
--    qreal offset();
--    UCListItemActions::Status status();
--
--
--public Q_SLOTS:
--    void snapToPosition(qreal position);
--
--Q_SIGNALS:
--    void containerChanged();
--    void visibleActionsChanged();
--    void listItemChanged();
--    void listItemIndexChanged();
--    void offsetChanged();
--    void statusChanged();
--    void swipingChanged();
--
--private:
--    QPointer<UCListItemActions> m_container;
--    QList<UCAction*> m_visibleActions;
--    bool m_swiping;
--    friend class UCListItemAction;
--
--private Q_SLOTS:
--    void updateVisibleActions();
--    void updateSwipeState();
--};
--
--QML_DECLARE_TYPEINFO(UCListItemActions, QML_HAS_ATTACHED_PROPERTIES)
++};
  #endif // UCLISTITEMACTIONS_H
 === modified file 'modules/Ubuntu/Components/plugin/uclistitemactions_p.h'
 --- modules/Ubuntu/Components/plugin/uclistitemactions_p.h	2014-12-01 13:42:47 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitemactions_p.h	2015-01-16 14:53:38 +0000
@@ -32,30 +32,14 @@
          return actions ? actions->d_func() : 0;
+     }
--    UCListItemActions::Status status;
--    qreal offsetDragged;
--    qreal optionSlotWidth;
--
      QQmlComponent *delegate;
--    QQmlComponent *panelDelegate;
--    QQuickItem *panelItem;
      QList<UCAction*> actions;
      QList<QObject*> data;
--    QPointer<UCListItem> queuedItem;
--
--    void _q_updateDraggedOffset();
--    UCListItemActionsAttached *attachedObject();
--
--    static bool connectToListItem(UCListItemActions *options, UCListItem *listItem, bool leading);
--    static void disconnectFromListItem(UCListItemActions *options);
--    static bool isConnectedTo(UCListItemActions *options, UCListItem *listItem);
      static int actions_count(QQmlListProperty<UCAction> *p);
      static void actions_append(QQmlListProperty<UCAction> *p, UCAction *v);
      static UCAction *actions_at(QQmlListProperty<UCAction>*, int);
      static void actions_clear(QQmlListProperty<UCAction>*);
--
--    QQuickItem *createPanelItem(QQmlComponent *delegate);
  };
  #endif // UCLISTITEMACTIONS_P_H
 === renamed file 'modules/Ubuntu/Components/plugin/uclistitemactionsattached.cpp' => 'modules/Ubuntu/Components/plugin/uclistitemattached.cpp'
 --- modules/Ubuntu/Components/plugin/uclistitemactionsattached.cpp	2014-12-18 10:08:56 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitemattached.cpp	2015-01-16 14:53:38 +0000
@@ -21,218 +21,154 @@
  #include "ucunits.h"
  #include "ucaction.h"
--UCListItemActionsAttached::UCListItemActionsAttached(QObject *parent)
--    : QObject(parent)
--    , m_swiping(false)
--{
--}
--
--UCListItemActionsAttached::~UCListItemActionsAttached()
--{
--}
--
--/*!
-- * \qmlattachedproperty ListItemActions ListItemActions::container
-- * \readonly
-- * The property holds the instance of the \l ListItemActions the ListItem's actions
-- * panel is visualizing.
-- */
--void UCListItemActionsAttached::setList(UCListItemActions *list)
--{
--    if (list == m_container) {
++UCListItemAttached::UCListItemAttached(QObject *parent)
++    : QObject(*(new UCListItemAttachedPrivate()), parent)
++{
++}
++
++UCListItemAttached::~UCListItemAttached()
++{
++}
++
++void UCListItemAttached::connectToAttached(UCListItemAttached *parentAttached)
++{
++    bool visualizeActions = UCListItemAttachedPrivate::get(parentAttached)->panel;
++    bool isLeading = visualizeActions ? UCListItemAttachedPrivate::get(parentAttached)->panel->isLeading() : false;
++    setList(parentAttached->item(), isLeading, visualizeActions);
++}
++
++void UCListItemAttached::setList(UCListItem *list, bool leading, bool visualizeActions)
++{
++    Q_D(UCListItemAttached);
++    if (d->listItem == list) {
          return;
+     }
--    m_container = list;
--    if (!m_container.isNull()) {
++    d->listItem = list;
++    Q_EMIT itemChanged();
++
++    if (visualizeActions) {
++        d->panel = leading ? UCListItemPrivate::get(d->listItem)->leadingPanel : UCListItemPrivate::get(d->listItem)->trailingPanel;
++    } else {
++        d->panel = 0;
++    }
++    if (d->panel) {
          // connect statusChanged() to update status, listItem, listItemIndex and overshoot values
--        QObject::connect(m_container.data(), &UCListItemActions::statusChanged,
--                         this, &UCListItemActionsAttached::statusChanged);
--        QObject::connect(m_container.data(), &UCListItemActions::statusChanged,
--                         this, &UCListItemActionsAttached::listItemChanged);
--        QObject::connect(m_container.data(), &UCListItemActions::statusChanged,
--                         this, &UCListItemActionsAttached::listItemIndexChanged);
--
--        UCListItemActionsPrivate *actions = UCListItemActionsPrivate::get(m_container.data());
--        // connect panel's xChanged to update the dragged offset
--        QObject::connect(actions->panelItem, &QQuickItem::xChanged,
--                         this, &UCListItemActionsAttached::offsetChanged);
++        QObject::connect(d->panel, &UCActionPanel::statusChanged,
++                         this, &UCListItemAttached::panelStatusChanged);
          // connect actions to get updates about visible changes
--        Q_FOREACH(UCAction *action, UCListItemActionsPrivate::get(m_container)->actions) {
++        Q_FOREACH(UCAction *action, UCListItemActionsPrivate::get(d->panel->actions())->actions) {
              QObject::connect(action, &UCAction::visibleChanged,
--                             this, &UCListItemActionsAttached::updateVisibleActions);
++                             this, &UCListItemAttached::updateVisibleActions);
+         }
          updateVisibleActions();
--    }
--    Q_EMIT containerChanged();
--    Q_EMIT visibleActionsChanged();
--}
--
--void UCListItemActionsAttached::connectListItem(UCListItem *item, bool connect)
--{
--    if (!item) {
--        return;
--    }
--    if (connect) {
--        QObject::connect(item, &UCListItem::highlightedChanged,
--                         this, &UCListItemActionsAttached::updateSwipeState);
--        QObject::connect(item, &UCListItem::contentMovingChanged,
--                         this, &UCListItemActionsAttached::updateSwipeState);
--    } else {
--        QObject::disconnect(item, &UCListItem::highlightedChanged,
--                            this, &UCListItemActionsAttached::updateSwipeState);
--        QObject::disconnect(item, &UCListItem::contentMovingChanged,
--                            this, &UCListItemActionsAttached::updateSwipeState);
++        Q_EMIT actionsChanged();
++        Q_EMIT visibleActionsChanged();
+     }
+ }
  // private slot to update visible actions
--void UCListItemActionsAttached::updateVisibleActions()
++void UCListItemAttached::updateVisibleActions()
+ {
--    m_visibleActions.clear();
--    if (!m_container.isNull()) {
--        Q_FOREACH(UCAction *action, UCListItemActionsPrivate::get(m_container)->actions) {
++    Q_D(UCListItemAttached);
++    if (d->panel) {
++        d->visibleActions.clear();
++        Q_FOREACH(UCAction *action, UCListItemActionsPrivate::get(d->panel->actions())->actions) {
              if (action->m_visible) {
--                m_visibleActions << action;
++                d->visibleActions << action;
+             }
+         }
++        Q_EMIT visibleActionsChanged();
+     }
--    Q_EMIT visibleActionsChanged();
+ }
--// private slot updating swipe state
--void UCListItemActionsAttached::updateSwipeState()
++/*!
++ * \qmlattachedproperty ListItemActions ListItem::actions
++ * \readonly
++ * The property holds the instance of the \l ListItemActions the ListItem's actions
++ * panel is visualizing. The property holds a valid value only when attached to
++ * the action visualizing panel defined in \l ListItemStyle::actionsDelegate style
++ * property.
++ */
++UCListItemActions *UCListItemAttached::actions() const
+ {
--    if (m_container.isNull()) {
--        return;
--    }
--    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
--    if (!panelItem || !panelItem->parentItem()) {
--        return;
--    }
--    UCListItem *item = static_cast<UCListItem*>(panelItem->parentItem());
--    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
--    bool swiped = listItem->highlighted && listItem->contentMoved;
--    if (swiped != m_swiping) {
--        m_swiping = swiped;
--        Q_EMIT swipingChanged();
--    }
++    Q_D(const UCListItemAttached);
++    return d->panel ? d->panel->actions() : 0;
+ }
  /*!
-- * \qmlattachedproperty list<Action> ListItemActions::visibleActions
++ * \qmlattachedproperty list<Action> ListItem::visibleActions
   * Holds the list of visible actions. This is a convenience property to help action
-- * visualization panel implementations to consider only visible actions.
++ * visualization panel implementations to consider only visible actions. Similar to
++ * \l actions attached property, it is only valid when attached to \l ListItemStyle::actionsDelegate
++ * component.
   */
--QQmlListProperty<UCAction> UCListItemActionsAttached::visibleActions()
++QQmlListProperty<UCAction> UCListItemAttached::visibleActions()
+ {
--    return QQmlListProperty<UCAction>(this, m_visibleActions);
++    Q_D(UCListItemAttached);
++    return QQmlListProperty<UCAction>(this, d->visibleActions);
+ }
  /*!
-- * \qmlattachedproperty ListItem ListItemActions::listItem
++ * \qmlattachedproperty ListItem ListItem::item
   * \readonly
-- * The property reports the connected \l ListItem to the list of actions.
++ * The property reports the connected \l ListItem to the panel. Valid in every attachee.
   */
--UCListItem *UCListItemActionsAttached::listItem()
++UCListItem *UCListItemAttached::item()
+ {
--    if (m_container.isNull()) {
--        return NULL;
--    }
--    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
--    if (!panelItem) {
--        return NULL;
--    }
--    QQuickItem *listItem = panelItem->parentItem();
--    return static_cast<UCListItem*>(listItem);
++    Q_D(UCListItemAttached);
++    return d->listItem;
+ }
  /*!
-- * \qmlattachedproperty int ListItemActions::listItemIndex
++ * \qmlattachedproperty int ListItem::index
   * \readonly
   * Holds the index of the \l ListItem within a view, if the \l ListItem is used
-- * in a model driven view. Otherwise it is set to -1.
-- */
--int UCListItemActionsAttached::listItemIndex() {
--    if (m_container.isNull()) {
--        return -1;
--    }
--    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
--    if (!panelItem) {
--        return -1;
--    }
--    QQuickItem *listItem = panelItem->parentItem();
--    return listItem ? UCListItemPrivate::get(static_cast<UCListItem*>(listItem))->index() : -1;
--}
--
--/*!
-- * \qmlattachedproperty bool ListItemActions::swiping
-- * \readonly
-- * The property notifies whether the panel is swiped or not. The property does
-- * not notify the rebounding.
-- */
--bool UCListItemActionsAttached::swiping()
--{
--    return m_swiping;
--}
--
--/*!
-- * \qmlattachedproperty real ListItemActions::offset
-- * The property returns the offset the panel item holding the visualized actions
-- * is visible. This can be used to do different animations on the panel and on
-- * the action visualizations.
-- */
--qreal UCListItemActionsAttached::offset()
--{
--    if (m_container.isNull()) {
--        return 0.0;
--    }
--    return UCListItemActionsPrivate::get(m_container)->offsetDragged;
--}
--
--/*!
-- * \qmlattachedproperty enum ListItemActions::status
++ * in a model driven view, or the child index otherwise. Valid in every attachee.
++ */
++int UCListItemAttached::index() {
++    Q_D(UCListItemAttached);
++    return d->listItem ? UCListItemPrivate::get(d->listItem)->index() : -1;
++}
++
++/*!
++ * \qmlattachedproperty enum ListItem::panelStatus
   * \readonly
   * The property holds the status of the ListItemActions, whether is connected
   * as leading or as trailing action list to a \l ListItem. Possible valueas are:
   * \list A
-- *  \li \b Disconnected - default, the actions list is not connected to any \l ListItem
++ *  \li \b None - default, the actions list is not connected to any \l ListItem
   *  \li \b Leading - the actions list is connected as leading list
   *  \li \b Trailing - the actions list is connected as trailing list
   * \endlist
++ * The property is valid only when attached to \l ListItemStyle::actionsDelegate component.
   */
--UCListItemActions::Status UCListItemActionsAttached::status()
++UCListItem::PanelStatus UCListItemAttached::panelStatus()
+ {
--    if (m_container.isNull()) {
--        return UCListItemActions::Disconnected;
++    Q_D(UCListItemAttached);
++    if (!d->panel) {
++        return UCListItem::None;
+     }
--    return UCListItemActionsPrivate::get(m_container)->status;
++    return d->panel->panelStatus();
+ }
  /*!
-- * \qmlattachedmethod void ListItemActions::snapToPosition(real position)
++ * \qmlattachedmethod void ListItem::snapToPosition(real position)
   * The function can be used to perform custom snapping, or to execute rebounding
   * and also disconnecting from the connected \l ListItem. This can be achieved by
-- * calling the function with 0.0 value.
++ * calling the function with 0.0 value. The slot has effect only when used from
++ * \l ListItemStyle::actionsDelegate component.
   */
--void UCListItemActionsAttached::snapToPosition(qreal position)
++void UCListItemAttached::snapToPosition(qreal position)
+ {
++    UCListItem::PanelStatus itemStatus = panelStatus();
++    Q_D(UCListItemAttached);
      //if it is disconnected, leave (this also includes the case when m_container is null)
--    if (status() == UCListItemActions::Disconnected) {
--        return;
--    }
--    QQuickItem *panelItem = UCListItemActionsPrivate::get(m_container)->panelItem;
--    if (!panelItem) {
--        // we don't have the panel created yet
--        return;
--    }
--    UCListItem *item = static_cast<UCListItem*>(panelItem->parentItem());
--    if (!item) {
--        // no ListItem attached
--        return;
--    }
--    UCListItemPrivate *listItem = UCListItemPrivate::get(item);
--    position *= (status() == UCListItemActions::Leading) ? 1 : -1;
++    if (!d->listItem || !d->panel || itemStatus == UCListItem::None) {
++        return;
++    }
++    UCListItemPrivate *listItem = UCListItemPrivate::get(d->listItem);
++    position *= (itemStatus == UCListItem::Leading) ? 1 : -1;
      if (position == 0.0) {
          listItem->_q_rebound();
      } else {
@@ -243,5 +179,3 @@
+         }
+     }
+ }
--
--
 === modified file 'modules/Ubuntu/Components/plugin/uclistitemstyle.h'
 --- modules/Ubuntu/Components/plugin/uclistitemstyle.h	2014-12-01 11:13:10 +0000
 +++ modules/Ubuntu/Components/plugin/uclistitemstyle.h	2015-01-16 14:53:38 +0000
@@ -46,7 +46,7 @@
      qreal m_swipeOvershoot;
      friend class UCListItemPrivate;
--    friend class UCListItemActionsPrivate;
++    friend class UCActionPanel;
      friend class UCListItemSnapAnimator;
  };
 === renamed file 'modules/Ubuntu/Components/plugin/uclistitemattached.cpp' => 'modules/Ubuntu/Components/plugin/ucviewitemsattached.cpp'
 --- modules/Ubuntu/Components/plugin/uclistitemattached.cpp	2014-11-18 15:27:08 +0000
 +++ modules/Ubuntu/Components/plugin/ucviewitemsattached.cpp	2015-01-16 14:53:38 +0000
@@ -28,34 +28,34 @@
   * in this way the controlling of the interactive flag of the Flickable and all
   * its ascendant Flickables.
   */
--UCListItemAttachedPrivate::UCListItemAttachedPrivate(UCListItemAttached *qq)
++UCViewItemsAttachedPrivate::UCViewItemsAttachedPrivate(UCViewItemsAttached *qq)
      : q_ptr(qq)
      , globalDisabled(false)
+ {
+ }
--UCListItemAttachedPrivate::~UCListItemAttachedPrivate()
++UCViewItemsAttachedPrivate::~UCViewItemsAttachedPrivate()
+ {
      clearChangesList();
      clearFlickablesList();
+ }
  // disconnect all flickables
--void UCListItemAttachedPrivate::clearFlickablesList()
++void UCViewItemsAttachedPrivate::clearFlickablesList()
+ {
--    Q_Q(UCListItemAttached);
++    Q_Q(UCViewItemsAttached);
      Q_FOREACH(const QPointer<QQuickFlickable> &flickable, flickables) {
          if (flickable.data())
          QObject::disconnect(flickable.data(), &QQuickFlickable::movementStarted,
--                            q, &UCListItemAttached::unbindItem);
++                            q, &UCViewItemsAttached::unbindItem);
+     }
      flickables.clear();
+ }
  // connect all flickables
--void UCListItemAttachedPrivate::buildFlickablesList()
++void UCViewItemsAttachedPrivate::buildFlickablesList()
+ {
--    Q_Q(UCListItemAttached);
++    Q_Q(UCViewItemsAttached);
      QQuickItem *item = qobject_cast<QQuickItem*>(q->parent());
      if (!item) {
          return;
@@ -65,17 +65,17 @@
          QQuickFlickable *flickable = qobject_cast<QQuickFlickable*>(item);
          if (flickable) {
              QObject::connect(flickable, &QQuickFlickable::movementStarted,
--                             q, &UCListItemAttached::unbindItem);
++                             q, &UCViewItemsAttached::unbindItem);
              flickables << flickable;
+         }
          item = item->parentItem();
+     }
+ }
--void UCListItemAttachedPrivate::clearChangesList()
++void UCViewItemsAttachedPrivate::clearChangesList()
+ {
      // clear property change objects
--    Q_Q(UCListItemAttached);
++    Q_Q(UCViewItemsAttached);
      Q_FOREACH(PropertyChange *change, changes) {
          // deleting PropertyChange will restore the saved property
          // to its original binding/value
@@ -84,10 +84,10 @@
      changes.clear();
+ }
--void UCListItemAttachedPrivate::buildChangesList(const QVariant &newValue)
++void UCViewItemsAttachedPrivate::buildChangesList(const QVariant &newValue)
+ {
      // collect all ascendant flickables
--    Q_Q(UCListItemAttached);
++    Q_Q(UCViewItemsAttached);
      QQuickItem *item = qobject_cast<QQuickItem*>(q->parent());
      if (!item) {
          return;
@@ -104,22 +104,27 @@
+     }
+ }
--UCListItemAttached::UCListItemAttached(QObject *owner)
++UCViewItemsAttached::UCViewItemsAttached(QObject *owner)
      : QObject(owner)
--    , d_ptr(new UCListItemAttachedPrivate(this))
--{
--}
--
--UCListItemAttached::~UCListItemAttached()
--{
++    , d_ptr(new UCViewItemsAttachedPrivate(this))
++{
++}
++
++UCViewItemsAttached::~UCViewItemsAttached()
++{
++}
++
++UCViewItemsAttached *UCViewItemsAttached::qmlAttachedProperties(QObject *owner)
++{
++    return new UCViewItemsAttached(owner);
+ }
  // register item to be rebound
--bool UCListItemAttached::listenToRebind(UCListItem *item, bool listen)
++bool UCViewItemsAttached::listenToRebind(UCListItem *item, bool listen)
+ {
      // we cannot bind the item until we have an other one bound
      bool result = false;
--    Q_D(UCListItemAttached);
++    Q_D(UCViewItemsAttached);
      if (listen) {
          if (d->boundItem.isNull() || (d->boundItem == item)) {
              d->boundItem = item;
@@ -135,9 +140,9 @@
+ }
  // reports true if any of the ascendant flickables is moving
--bool UCListItemAttached::isMoving()
++bool UCViewItemsAttached::isMoving()
+ {
--    Q_D(UCListItemAttached);
++    Q_D(UCViewItemsAttached);
      Q_FOREACH(const QPointer<QQuickFlickable> &flickable, d->flickables) {
          if (flickable && flickable->isMoving()) {
              return true;
@@ -147,9 +152,9 @@
+ }
  // returns true if the given ListItem is bound to listen on moving changes
--bool UCListItemAttached::isBoundTo(UCListItem *item)
++bool UCViewItemsAttached::isBoundTo(UCListItem *item)
+ {
--    Q_D(UCListItemAttached);
++    Q_D(UCViewItemsAttached);
      return d->boundItem == item;
+ }
@@ -161,9 +166,9 @@
   * When disabled, always the last item disabling will be kept as active disabler,
   * and only the active disabler can enable (restore) the interactive flag state.
   */
--void UCListItemAttached::disableInteractive(UCListItem *item, bool disable)
++void UCViewItemsAttached::disableInteractive(UCListItem *item, bool disable)
+ {
--    Q_D(UCListItemAttached);
++    Q_D(UCViewItemsAttached);
      if (disable) {
          // disabling or re-disabling
          d->disablerItem = item;
@@ -188,9 +193,9 @@
+     }
+ }
--void UCListItemAttached::unbindItem()
++void UCViewItemsAttached::unbindItem()
+ {
--    Q_D(UCListItemAttached);
++    Q_D(UCViewItemsAttached);
      if (d->boundItem) {
          // depending on content item's X coordinate, we either do animated or prompt rebind
          if (d->boundItem->contentItem()->x() != 0.0) {
 === modified file 'tests/resources/listitems/ListItemTest.qml'
 --- tests/resources/listitems/ListItemTest.qml	2014-12-04 13:23:18 +0000
 +++ tests/resources/listitems/ListItemTest.qml	2015-01-16 14:53:38 +0000
@@ -16,6 +16,7 @@
  import QtQuick 2.2
  import Ubuntu.Components 1.2
++import Ubuntu.Components.Styles 1.2
  MainView {
      id: main
@@ -109,7 +110,7 @@
                          width: units.gu(3)
                          height: width
                          name: action.iconName
--                        color: "blue"
++                        color: pressed ? "blue" : "pink"
                          anchors.horizontalCenter: parent.horizontalCenter
+                     }
                      Label {
@@ -131,13 +132,16 @@
          ListItem {
              Label {
++                id: label2
                  anchors.fill: parent
--                text: "Another standalone ListItem"
++                text: "Another standalone ListItem\nStarted with custom style, reset to theme style on first click"
+             }
              leadingActions: testItem.leadingActions
              trailingActions: ListItemActions {
                  actions: leading.actions
+             }
++            style: ListItemStyle {}
++            onClicked: { style = undefined; label2.text = "Another standalone ListItem" }
+         }
          ListView {
@@ -152,6 +156,7 @@
                  id: listItem
                  onClicked: print(" clicked")
                  leadingActions: leading
++                trailingActions: leadingActions
                  Label {
                      text: modelData + " item"
+                 }
@@ -179,7 +184,7 @@
              Column {
                  id: column
--                width: view.width
++                width: flicker.width
                  property alias count: repeater.count
                  Repeater {
                      id: repeater
 === modified file 'tests/unit_x11/tst_components/tst_listitem.qml'
 --- tests/unit_x11/tst_components/tst_listitem.qml	2014-12-19 06:32:11 +0000
 +++ tests/unit_x11/tst_components/tst_listitem.qml	2015-01-16 14:53:38 +0000
@@ -18,11 +18,12 @@
  import QtTest 1.0
  import Ubuntu.Test 1.0
  import Ubuntu.Components 1.2
++import Ubuntu.Components.Styles 1.2
  Item {
      id: main
--    width: units.gu(40)
--    height: units.gu(71)
++    width: units.gu(50)
++    height: units.gu(100)
      Action {
          id: stockAction
@@ -192,8 +193,8 @@
              compare(defaults.highlighted, false, "Not highlighted by default");
              compare(defaults.swipeOvershoot, 0.0, "No overshoot till the style is loaded!");
              compare(defaults.divider.visible, true, "divider is visible by default");
--            compare(defaults.divider.leftMargin, units.dp(2), "divider's left margin is 2GU");
--            compare(defaults.divider.rightMargin, units.dp(2), "divider's right margin is 2GU");
++            compare(defaults.divider.leftMargin, 0, "divider's left margin is 0");
++            compare(defaults.divider.rightMargin, 0, "divider's right margin is 0");
              compare(defaults.divider.colorFrom, "#000000", "colorFrom differs.");
              fuzzyCompare(defaults.divider.colorFrom.a, 0.14, 0.01, "colorFrom alpha differs");
              compare(defaults.divider.colorTo, "#ffffff", "colorTo differs.");
@@ -206,6 +207,14 @@
              compare(actionsDefault.actions.length, 0, "ListItemActions has no actions set.");
+         }
++        Component { id: customStyle; ListItemStyle {} }
++
++        function test_style_reset() {
++            testItem.style = customStyle;
++            testItem.style = undefined;
++            verify(testItem.style != 0 && testItem.style.objectName == "ListItemThemeStyle", "Style set back to theme");
++        }
++
          function test_children_in_content_item() {
              compare(bodyItem.parent, testItem.contentItem, "Content is not in the right holder!");
+         }

Ubuntu UI Toolkit

Merge lp:~zsombi/ubuntu-ui-toolkit/76-refactoring into lp:ubuntu-ui-toolkit/staging

Commit message

Description of the change

Preview Diff

Subscribers