← Back to branch summary

~ubuntu-branches/ubuntu/vivid/kdesdk/vivid

« back to all changes in this revision

Viewing changes to umbrello/umbrello/widgets/widgetlist_utils.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2012-06-06 11:49:54 UTC
  • mfrom: (0.4.21)
  • Revision ID: package-import@ubuntu.com-20120606114954-rdls73fzlpzxglbx
Tags: 4:4.8.80-0ubuntu1
* New uptream beta release
* Update dont_export_private_classes.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
umbrello/umbrello/widgets/widgetlist_utils.cpp
 
1
/***************************************************************************
 
2
 *   This program is free software; you can redistribute it and/or modify  *
 
3
 *   it under the terms of the GNU General Public License as published by  *
 
4
 *   the Free Software Foundation; either version 2 of the License, or     *
 
5
 *   (at your option) any later version.                                   *
 
6
 *                                                                         *
 
7
 *   copyright (C) 2009-2011                                               *
 
8
 *   Umbrello UML Modeller Authors <uml-devel@uml.sf.net>                  *
 
9
 ***************************************************************************/
 
10
 
 
11
// own header
 
12
#include "widgetlist_utils.h"
 
13
 
 
14
// app includes
 
15
#include "debug_utils.h"
 
16
#include "umlwidget.h"
 
17
 
 
18
// qt/kde includes
 
19
#include <QtCore/QVector>
 
20
 
 
21
namespace WidgetList_Utils
 
22
{
 
23
 
 
24
/**
 
25
 * Looks for the smallest x-value of the given UMLWidgets.
 
26
 * @param widgetList A list with UMLWidgets.
 
27
 */
 
28
qreal getSmallestX(const UMLWidgetList &widgetList)
 
29
{
 
30
    qreal smallestX = 0;
 
31
 
 
32
    int i = 1;
 
33
    foreach(UMLWidget *widget,  widgetList) {
 
34
        if (i == 1) {
 
35
            smallestX = widget->x();
 
36
        } else {
 
37
            if (smallestX > widget->x())
 
38
                smallestX = widget->x();
 
39
        }
 
40
        i++;
 
41
    }
 
42
 
 
43
    return smallestX;
 
44
}
 
45
 
 
46
/**
 
47
 * Looks for the smallest y-value of the given UMLWidgets.
 
48
 * @param widgetList A list with UMLWidgets.
 
49
 */
 
50
qreal getSmallestY(const UMLWidgetList &widgetList)
 
51
{
 
52
    if (widgetList.isEmpty())
 
53
        return -1;
 
54
 
 
55
    qreal smallestY = 0;
 
56
 
 
57
    int i = 1;
 
58
    foreach(UMLWidget *widget,  widgetList) {
 
59
        if (i == 1) {
 
60
            smallestY = widget->y();
 
61
        } else {
 
62
            if (smallestY > widget->y())
 
63
                smallestY = widget->y();
 
64
        }
 
65
        i++;
 
66
    }
 
67
 
 
68
    return smallestY;
 
69
}
 
70
 
 
71
/**
 
72
 * Looks for the biggest x-value of the given UMLWidgets.
 
73
 * @param widgetList A list with UMLWidgets.
 
74
 */
 
75
qreal getBiggestX(const UMLWidgetList &widgetList)
 
76
{
 
77
    if (widgetList.isEmpty())
 
78
        return -1;
 
79
 
 
80
    qreal biggestX = 0;
 
81
 
 
82
    int i = 1;
 
83
    foreach(UMLWidget *widget, widgetList) {
 
84
        if (i == 1) {
 
85
            biggestX = widget->x();
 
86
            biggestX += widget->width();
 
87
        } else {
 
88
            if (biggestX < widget->x() + widget->width())
 
89
                biggestX = widget->x() + widget->width();
 
90
        }
 
91
        i++;
 
92
    }
 
93
 
 
94
    return biggestX;
 
95
}
 
96
 
 
97
/**
 
98
 * Looks for the biggest y-value of the given UMLWidgets.
 
99
 * @param widgetList A list with UMLWidgets.
 
100
 */
 
101
qreal getBiggestY(const UMLWidgetList &widgetList)
 
102
{
 
103
    if (widgetList.isEmpty())
 
104
        return -1;
 
105
 
 
106
    qreal biggestY = 0;
 
107
 
 
108
    int i = 1;
 
109
    foreach(UMLWidget *widget, widgetList) {
 
110
        if (i == 1) {
 
111
            biggestY = widget->y();
 
112
            biggestY += widget->height();
 
113
        } else {
 
114
            if (biggestY < widget->y() + widget->height())
 
115
                biggestY = widget->y() + widget->height();
 
116
        }
 
117
        i++;
 
118
    }
 
119
 
 
120
    return biggestY;
 
121
}
 
122
 
 
123
/**
 
124
 * Returns the sum of the heights of the given UMLWidgets
 
125
 * @param widgetList A list with UMLWidgets.
 
126
 */
 
127
qreal getHeightsSum(const UMLWidgetList &widgetList)
 
128
{
 
129
    qreal heightsSum = 0;
 
130
 
 
131
    foreach(UMLWidget *widget, widgetList) {
 
132
        heightsSum += widget->height();
 
133
    }
 
134
 
 
135
    return heightsSum;
 
136
}
 
137
 
 
138
/**
 
139
 * Returns the sum of the widths of the given UMLWidgets.
 
140
 * @param widgetList A list with UMLWidgets.
 
141
 */
 
142
qreal getWidthsSum(const UMLWidgetList &widgetList)
 
143
{
 
144
    qreal widthsSum = 0;
 
145
 
 
146
    foreach(UMLWidget *widget, widgetList) {
 
147
        widthsSum += widget->width();
 
148
    }
 
149
 
 
150
    return widthsSum;
 
151
}
 
152
 
 
153
}  // namespace WidgetList_Utils