← Back to branch summary

~lbrulet-8/compiz-plugins-main/fix-876591

« back to all changes in this revision

Viewing changes to snap/src/snap.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2011-10-12 10:49:59 UTC
  • Revision ID: james.westby@ubuntu.com-20111012104959-sqqdj62grtdhz4ca
Tags: 1:0.9.6-0ubuntu4
https://launchpad.net/bugs/872161
* debian/patches/fix-872161.patch:
  - When grabbing a window to demaximize it after dragging it up,
    sometimes the position will not be where you expect it to be
    (LP: #872161)

Show diffs side-by-side

added added

removed removed

Lines of Context:
snap/src/snap.cpp
46
46
 * Wrapper functions to avoid infinite notify loops
47
47
 */
48
48
void
49
 
SnapWindow::move (int dx, int dy)
 
49
SnapWindow::move (int dx, int dy, bool sync)
50
50
{
51
51
    skipNotify = true;
52
52
    window->move (dx, dy, true);
53
 
    screen->warpPointer (dx, dy);
 
53
    /* warp the pointer in the case of
 
54
     * snap release */
 
55
    if (sync)
 
56
        window->syncPosition ();
54
57
    skipNotify = false;
55
58
}
56
59
 
406
409
            switch (type)
407
410
            {
408
411
            case LeftEdge:
409
 
                move (min, 0);
 
412
                move (min, 0, false);
410
413
                break;
411
414
            case RightEdge:
412
 
                move (-min, 0);
 
415
                move (-min, 0, false);
413
416
                break;
414
417
            case TopEdge:
415
 
                move (0, min);
 
418
                move (0, min, false);
416
419
                break;
417
420
            case BottomEdge:
418
 
                move (0, -min);
 
421
                move (0, -min, false);
419
422
                break;
420
423
            default:
421
424
                break;
428
431
 * Call the previous function for each of the 4 sides of the window
429
432
 */
430
433
void
431
 
SnapWindow::moveCheckEdges ()
 
434
SnapWindow::moveCheckEdges (int snapDirection)
432
435
{
433
436
    CompRect input (window->borderRect ());
434
437
    moveCheckNearestEdge (input.left (), input.top (), input.bottom (),
435
 
                          true, RightEdge, HorizontalSnap);
 
438
                          true, RightEdge, HorizontalSnap & snapDirection);
436
439
    moveCheckNearestEdge (input.right (), input.top (), input.bottom (),
437
 
                          false, LeftEdge, HorizontalSnap);
 
440
                          false, LeftEdge, HorizontalSnap & snapDirection);
438
441
    moveCheckNearestEdge (input.top (), input.left (), input.right (),
439
 
                          true, BottomEdge, VerticalSnap);
 
442
                          true, BottomEdge, VerticalSnap & snapDirection);
440
443
    moveCheckNearestEdge (input.bottom (), input.left (), input.right (),
441
 
                          false, TopEdge, VerticalSnap);
 
444
                          false, TopEdge, VerticalSnap & snapDirection);
442
445
}
443
446
 
444
447
// Edges checking functions (resize) -------------------------------------------
670
673
}
671
674
 
672
675
void
 
676
SnapWindow::stateChangeNotify (unsigned int lastState)
 
677
{
 
678
    if (window->state () & CompWindowStateMaximizedHorzMask)
 
679
    {
 
680
        snapGeometry.setWidth (0);
 
681
        snapGeometry.setX (0);
 
682
        snapDirection &= VerticalSnap;
 
683
    }
 
684
 
 
685
    if (window->state () & CompWindowStateMaximizedVertMask)
 
686
    {
 
687
        snapGeometry.setHeight (0);
 
688
        snapGeometry.setY (0);
 
689
        snapDirection &= HorizontalSnap;
 
690
    }
 
691
 
 
692
    window->stateChangeNotify (lastState);
 
693
}
 
694
 
 
695
void
673
696
SnapWindow::moveNotify (int dx, int dy, bool immediate)
674
697
{
 
698
    unsigned int allowedSnapDirection = VerticalSnap | HorizontalSnap;
675
699
    SNAP_SCREEN (screen);
676
700
 
677
701
    window->moveNotify (dx, dy, immediate);
683
707
    // we have to avoid snapping but there's still some buffered moving
684
708
    if (!ss->snapping && (m_dx || m_dy))
685
709
    {
686
 
        move (m_dx, m_dy);
 
710
        move (m_dx, m_dy, false);
687
711
        m_dx = m_dy = 0;
688
712
        return;
689
713
    }
690
714
 
691
715
    // don't snap maximized windows
692
716
    if (window->state () & CompWindowStateMaximizedHorzMask)
 
717
    {
 
718
        allowedSnapDirection &= ~(VerticalSnap);
693
719
        dx = 0;
 
720
    }
694
721
 
695
722
    if (window->state () & CompWindowStateMaximizedVertMask)
 
723
    {
 
724
        allowedSnapDirection &= ~(HorizontalSnap);
696
725
        dy = 0;
 
726
    }
697
727
 
698
728
    // avoiding snap, nothing buffered
699
729
    if (!ss->snapping)
700
730
        return;
701
731
 
 
732
    dx = snapGeometry.x () - window->geometry ().x ();
 
733
    dy = snapGeometry.y () - window->geometry ().y ();
 
734
 
702
735
    // apply edge resistance
703
736
    if (ss->optionGetSnapTypeMask () & SnapTypeEdgeResistanceMask)
704
737
    {
707
740
        // by buffered dx - dx
708
741
        if (!snapGeometry.isEmpty () && snapDirection & HorizontalSnap)
709
742
        {
710
 
            m_dx += dx;
 
743
            m_dx += -dx;
711
744
            if (m_dx < ss->optionGetResistanceDistance ()
712
745
                && m_dx > -ss->optionGetResistanceDistance ())
713
746
            {
714
 
                dx = snapGeometry.x () - window->geometry ().x ();
715
 
                move (dx, 0);
 
747
                move (dx, 0, false);
716
748
            }
717
749
            else
718
750
            {
719
 
                move (m_dx - dx, 0);
 
751
                move (m_dx - dx, 0, true);
720
752
                m_dx = 0;
721
753
                snapDirection &= VerticalSnap;
722
754
            }
724
756
        // Same for vertical snapping and dy
725
757
        if (!snapGeometry.isEmpty () && snapDirection & VerticalSnap)
726
758
        {
727
 
            m_dy += dy;
 
759
            m_dy += -dy;
728
760
            if (m_dy < ss->optionGetResistanceDistance ()
729
761
                && m_dy > -ss->optionGetResistanceDistance ())
730
762
            {
731
 
                dy = snapGeometry.y () - window->geometry ().y ();
732
 
                move (0, dy);
 
763
                move (0, dy, false);
733
764
            }
734
765
            else
735
766
            {
736
 
                move (0, m_dy - dy);
 
767
                move (0, m_dy - dy, true);
737
768
                m_dy = 0;
738
769
                snapDirection &= HorizontalSnap;
739
770
            }
745
776
    // If we don't already snap vertically and horizontally,
746
777
    // check edges status
747
778
    if (snapDirection != (VerticalSnap | HorizontalSnap))
748
 
        moveCheckEdges ();
 
779
        moveCheckEdges (allowedSnapDirection);
749
780
}
750
781
 
751
782
/*