22 #include <hblistwidget.h> |
22 #include <hblistwidget.h> |
23 #include <hbmenu.h> |
23 #include <hbmenu.h> |
24 #include <hbscrollbar> |
24 #include <hbscrollbar> |
25 #include <QActionGroup> |
25 #include <QActionGroup> |
26 #include <QGraphicsLinearLayout> |
26 #include <QGraphicsLinearLayout> |
|
27 #include <QSettings> |
27 #include "hgwidgettestview.h" |
28 #include "hgwidgettestview.h" |
28 #include "hgtestview.h" |
29 #include "hgtestview.h" |
|
30 #include "hgwidgetoptionsview.h" |
29 #include "hgselectiondialog.h" |
31 #include "hgselectiondialog.h" |
30 #include "hgwidgettestdatamodel.h" |
32 #include "hgwidgettestdatamodel.h" |
31 #include "hgflipwidget.h" |
33 #include "hgflipwidget.h" |
|
34 #include "hgitemsizedialog.h" |
|
35 #include "hgcoverflowwidget.h" |
32 #include "trace.h" |
36 #include "trace.h" |
33 #include <hgwidgets/hggrid.h> |
37 #include <hgwidgets/hggrid.h> |
34 #include <hgwidgets/hgmediawall.h> |
38 #include <hgwidgets/hgmediawall.h> |
35 |
39 |
|
40 |
|
41 static const int GRIDBUFFERSIZE(400); |
|
42 static const int COVERFLOWBUFFERSIZE(130); |
|
43 |
36 HgWidgetTestView::HgWidgetTestView(QGraphicsItem *parent) : |
44 HgWidgetTestView::HgWidgetTestView(QGraphicsItem *parent) : |
37 HbView(parent), |
45 HbView(parent), |
38 mWidget(NULL), |
46 mWidget(0), |
39 mModel(NULL), |
47 mModel(0), |
40 mListWidget(NULL), |
48 mWidgetType(HgWidgetNone), |
|
49 mListWidget(0), |
41 mToggleOrientation(false), |
50 mToggleOrientation(false), |
42 mTBone(false), |
51 mFlipWidget(0), |
43 mFlipWidget(NULL), |
52 mFrontItem(0), |
44 mFrontItem(NULL) |
53 mOptionsView(0), |
|
54 mItemSizeDialog(0), |
|
55 mItemPosDialog(0) |
45 { |
56 { |
46 mModel = new HgWidgetTestDataModel(this); |
57 mModel = new HgWidgetTestDataModel(this); |
47 mModel->setImageDataType(HgWidgetTestDataModel::TypeQImage); |
|
48 mSelectionModel = new QItemSelectionModel(mModel, this); |
58 mSelectionModel = new QItemSelectionModel(mModel, this); |
49 |
59 |
50 createMenu(); |
60 createMenu(); |
51 |
61 |
52 mLayout = new QGraphicsLinearLayout(Qt::Vertical); |
62 mLayout = new QGraphicsLinearLayout(Qt::Vertical); |
53 mLayout->setContentsMargins(0,0,0,0); |
63 mLayout->setContentsMargins(0,0,0,0); |
54 initWidget( HgWidgetGrid ); |
64 setupWidget(); |
55 setLayout( mLayout ); |
65 setLayout(mLayout); |
56 } |
66 } |
57 |
67 |
58 HgWidgetTestView::~HgWidgetTestView() |
68 HgWidgetTestView::~HgWidgetTestView() |
59 { |
69 { |
60 } |
70 } |
61 |
71 |
62 void HgWidgetTestView::createMenu() |
72 void HgWidgetTestView::createMenu() |
63 { |
73 { |
64 FUNC_LOG; |
74 FUNC_LOG; |
65 |
75 |
66 HbMenu* modeMenu = new HbMenu("Change widget type"); |
76 menu()->addAction("Options", this, SLOT(showOptions())); |
67 menu()->addMenu(modeMenu); |
77 menu()->addAction("Reset Options", this, SLOT(resetOptions())); |
68 |
|
69 HbMenu* scrollBarMenu = new HbMenu("ScrollBar settings"); |
|
70 menu()->addMenu( scrollBarMenu ); |
|
71 |
|
72 HbMenu* imageTypeMenu = new HbMenu("Datamodel image type"); |
|
73 menu()->addMenu( imageTypeMenu ); |
|
74 |
|
75 HbAction* gridAction = modeMenu->addAction( "Use grid" ); |
|
76 HbAction* coverFlowAction = modeMenu->addAction( "Use coverFlow" ); |
|
77 HbAction* TBone = modeMenu->addAction( "Use TBone" ); |
|
78 connect( modeMenu, SIGNAL(triggered(HbAction*)), this, SLOT(switchWidget(HbAction*)) ); |
|
79 |
|
80 QActionGroup* ac1 = new QActionGroup( this ); |
|
81 gridAction->setCheckable( true ); |
|
82 coverFlowAction->setCheckable( true ); |
|
83 TBone->setCheckable(true); |
|
84 gridAction->setChecked( true ); |
|
85 ac1->addAction( gridAction ); |
|
86 ac1->addAction( coverFlowAction ); |
|
87 ac1->addAction( TBone ); |
|
88 |
|
89 HbAction* scrollBarAutoHideAction = scrollBarMenu->addAction( "Autohide ScrollBar" ); |
|
90 HbAction* scrollBarAlwaysOnAction = scrollBarMenu->addAction( "ScrollBar always on" ); |
|
91 HbAction* scrollBarAlwaysOffAction = scrollBarMenu->addAction( "ScrollBar always off" ); |
|
92 scrollBarMenu->addSeparator(); |
|
93 HbAction* interactiveScrollBarAction = scrollBarMenu->addAction( "Interactive scrollbar" ); |
|
94 HbAction* uninteractiveScrollBarAction = scrollBarMenu->addAction( "Uninteractive scrollbar" ); |
|
95 connect( scrollBarAutoHideAction, SIGNAL(triggered()), this, SLOT(autoHideScrollBar()) ); |
|
96 connect( scrollBarAlwaysOnAction, SIGNAL(triggered()), this, SLOT(scrollBarAlwaysOn()) ); |
|
97 connect( scrollBarAlwaysOffAction, SIGNAL(triggered()), this, SLOT(scrollBarAlwaysOff()) ); |
|
98 connect( interactiveScrollBarAction, SIGNAL(triggered()), this, SLOT(interactiveScrollBar()) ); |
|
99 connect( uninteractiveScrollBarAction, SIGNAL(triggered()), this, SLOT(unInteractiveScrollBar()) ); |
|
100 |
|
101 QActionGroup* ac2 = new QActionGroup( this ); |
|
102 scrollBarAutoHideAction->setCheckable( true ); |
|
103 scrollBarAlwaysOnAction->setCheckable( true ); |
|
104 scrollBarAlwaysOffAction->setCheckable(true); |
|
105 scrollBarAutoHideAction->setChecked( true ); |
|
106 ac2->addAction( scrollBarAutoHideAction ); |
|
107 ac2->addAction( scrollBarAlwaysOnAction ); |
|
108 ac2->addAction( scrollBarAlwaysOffAction ); |
|
109 |
|
110 QActionGroup* ac3 = new QActionGroup( this ); |
|
111 interactiveScrollBarAction->setCheckable( true ); |
|
112 uninteractiveScrollBarAction->setCheckable( true ); |
|
113 uninteractiveScrollBarAction->setChecked( true ); |
|
114 ac3->addAction( interactiveScrollBarAction ); |
|
115 ac3->addAction( uninteractiveScrollBarAction ); |
|
116 |
|
117 HbAction* qimageAction = imageTypeMenu->addAction( "feed QImages" ); |
|
118 HbAction* hbiconAction = imageTypeMenu->addAction( "feed HbIcons" ); |
|
119 HbAction* qiconAction = imageTypeMenu->addAction( "feed QIcons" ); |
|
120 connect( qimageAction, SIGNAL(triggered()), this, SLOT(feedqimages()) ); |
|
121 connect( hbiconAction, SIGNAL(triggered()), this, SLOT(feedhbicons()) ); |
|
122 connect( qiconAction, SIGNAL(triggered()), this, SLOT(feedqicons()) ); |
|
123 |
|
124 QActionGroup* ac4 = new QActionGroup( this ); |
|
125 qimageAction->setCheckable( true ); |
|
126 hbiconAction->setCheckable( true ); |
|
127 qiconAction->setCheckable( true ); |
|
128 qimageAction->setChecked( true ); |
|
129 ac4->addAction( qimageAction ); |
|
130 ac4->addAction( hbiconAction ); |
|
131 ac4->addAction( qiconAction ); |
|
132 |
|
133 menu()->addAction("Toggle scrolldirection", this, SLOT(toggleScrollDirection())); |
78 menu()->addAction("Toggle scrolldirection", this, SLOT(toggleScrollDirection())); |
134 menu()->addAction("Simulate orientation switch", this, SLOT(orientationChanged())); |
79 menu()->addAction("Simulate orientation switch", this, SLOT(orientationChanged())); |
135 |
80 menu()->addAction("Edit item size", this, SLOT(startItemSizeChange())); |
136 mUseLowResAction = menu()->addAction( "Use low res images for coverflow" ); |
81 menu()->addAction("Edit item pos", this, SLOT(startItemPosChange())); |
137 mUseLowResAction->setCheckable(true); |
82 |
138 mUseLowResAction->setChecked(false); |
|
139 mUseLowResAction->setEnabled(false); |
|
140 connect( mUseLowResAction, SIGNAL(triggered()), this, SLOT(toggleLowResForCoverflow()) ); |
|
141 |
|
142 HbMenu *modelChangeSubMenu = menu()->addMenu("Change model"); |
83 HbMenu *modelChangeSubMenu = menu()->addMenu("Change model"); |
143 modelChangeSubMenu->addAction("Remove items", this, SLOT(openDeleteItemsDialog())); |
84 modelChangeSubMenu->addAction("Remove items", this, SLOT(openDeleteItemsDialog())); |
144 modelChangeSubMenu->addAction("Move items", this, SLOT(openMoveItemsDialog())); |
85 modelChangeSubMenu->addAction("Move items", this, SLOT(openMoveItemsDialog())); |
145 modelChangeSubMenu->addAction("Add items", this, SLOT(openAddItemsDialog())); |
86 modelChangeSubMenu->addAction("Add items", this, SLOT(openAddItemsDialog())); |
146 |
87 modelChangeSubMenu->addAction("Reset model", this, SLOT(resetModel())); |
147 HbMenu *labelChangeSubMenu = menu()->addMenu("Change labels"); |
|
148 HbMenu *titleSubMenu = labelChangeSubMenu->addMenu("Title"); |
|
149 HbAction *aboveAction1 = titleSubMenu->addAction("Above", this, SLOT(setTitleAboveImage())); |
|
150 HbAction *belowAction1 = titleSubMenu->addAction("Below", this, SLOT(setTitleBelowImage())); |
|
151 HbAction *hiddenAction1 = titleSubMenu->addAction("Hide", this, SLOT(setTitleHidden())); |
|
152 QActionGroup* ac5 = new QActionGroup(this); |
|
153 aboveAction1->setCheckable(true); |
|
154 belowAction1->setCheckable(true); |
|
155 hiddenAction1->setCheckable(true); |
|
156 hiddenAction1->setChecked(true); |
|
157 ac5->addAction(aboveAction1); |
|
158 ac5->addAction(belowAction1); |
|
159 ac5->addAction(hiddenAction1); |
|
160 |
|
161 HbMenu *descriptionSubMenu = labelChangeSubMenu->addMenu("Description"); |
|
162 HbAction *aboveAction2 = descriptionSubMenu->addAction("Above", this, SLOT(setDescriptionAboveImage())); |
|
163 HbAction *belowAction2 = descriptionSubMenu->addAction("Below", this, SLOT(setDescriptionBelowImage())); |
|
164 HbAction *hiddenAction2 = descriptionSubMenu->addAction("Hide", this, SLOT(setDescriptionHidden())); |
|
165 QActionGroup* ac6 = new QActionGroup(this); |
|
166 aboveAction2->setCheckable(true); |
|
167 belowAction2->setCheckable(true); |
|
168 hiddenAction2->setCheckable(true); |
|
169 hiddenAction2->setChecked(true); |
|
170 ac6->addAction(aboveAction2); |
|
171 ac6->addAction(belowAction2); |
|
172 ac6->addAction(hiddenAction2); |
|
173 } |
|
174 |
|
175 void HgWidgetTestView::switchWidget(HbAction* action) |
|
176 { |
|
177 FUNC_LOG; |
|
178 |
|
179 mTBone = false; |
|
180 if( action->text() == "Use grid"){ |
|
181 initWidget( HgWidgetGrid ); |
|
182 } |
|
183 else if( action->text() == "Use coverFlow"){ |
|
184 initWidget( HgWidgetCoverflow ); |
|
185 } |
|
186 else if( action->text() == "Use TBone" ){ |
|
187 mTBone = true; |
|
188 initWidget( HgWidgetCoverflow ); |
|
189 } |
|
190 } |
88 } |
191 |
89 |
192 void HgWidgetTestView::toggleScrollDirection() |
90 void HgWidgetTestView::toggleScrollDirection() |
193 { |
91 { |
194 FUNC_LOG; |
92 FUNC_LOG; |
195 |
93 |
196 mToggleOrientation = !mToggleOrientation; |
94 mToggleOrientation = !mToggleOrientation; |
197 initWidget( mWidgetType ); |
95 initWidget(mWidgetType); |
198 } |
96 } |
199 |
97 |
200 void HgWidgetTestView::initWidget( WidgetType type ) |
98 void HgWidgetTestView::initWidget(HgTestWidgetType type) |
201 { |
99 { |
202 FUNC_LOG; |
100 FUNC_LOG; |
203 |
101 |
204 mWidgetType = type; |
102 if (mWidgetType != type) { |
205 |
103 mWidgetType = type; |
206 // TODO, disconnecting signals required? |
104 |
207 |
105 // TODO, disconnecting signals required? |
208 if( mWidget ) |
106 |
209 mLayout->removeItem(mWidget); |
107 if( mWidget ) |
210 if( mListWidget ) |
108 mLayout->removeItem(mWidget); |
211 mLayout->removeItem(mListWidget); |
109 if( mListWidget ) |
212 |
110 mLayout->removeItem(mListWidget); |
213 delete mWidget; |
111 |
214 mWidget = NULL; |
112 delete mWidget; |
215 |
113 mWidget = NULL; |
216 delete mListWidget; |
114 |
217 mListWidget = NULL; |
115 delete mListWidget; |
218 |
116 mListWidget = NULL; |
219 mWidget = createWidget(type); |
117 |
220 mLayout->addItem(mWidget); |
118 mWidget = createWidget(type); |
221 |
119 mLayout->addItem(mWidget); |
222 switch (type) |
120 |
223 { |
121 switch (type) { |
224 case HgWidgetGrid: |
122 case HgWidgetGrid: |
225 { |
123 setItemVisible(Hb::AllItems, true); |
226 mUseLowResAction->setEnabled(false); |
124 mModel->enableLowResImages(false); |
227 mModel->enableLowResImages(false); |
125 // TODO, init grid different model, |
228 // TODO, init grid different model, |
126 mModel->setThumbnailSize(ThumbnailManager::ThumbnailMedium); |
229 mModel->setThumbnailSize(ThumbnailManager::ThumbnailMedium); |
127 break; |
230 break; |
128 case HgWidgetCoverflow: |
231 } |
129 mModel->setThumbnailSize(ThumbnailManager::ThumbnailLarge); |
232 case HgWidgetCoverflow: |
130 setItemVisible(Hb::AllItems, orientation() != Qt::Horizontal); |
233 { |
131 break; |
234 mUseLowResAction->setEnabled(true); |
132 case HgWidgetTBone: |
235 mModel->enableLowResImages(mUseLowResAction->isChecked()); |
133 setItemVisible(Hb::AllItems, true); |
236 mModel->setThumbnailSize(ThumbnailManager::ThumbnailLarge); |
134 mModel->setThumbnailSize(ThumbnailManager::ThumbnailMedium); |
237 if (mTBone) { |
|
238 mListWidget = new HbListWidget; |
135 mListWidget = new HbListWidget; |
239 mLayout->addItem(mListWidget); |
136 mLayout->addItem(mListWidget); |
240 mListWidget->addItem( "List item 1"); |
137 mListWidget->addItem( "List item 1"); |
241 mListWidget->addItem( "List item 2"); |
138 mListWidget->addItem( "List item 2"); |
242 mListWidget->addItem( "List item 3"); |
139 mListWidget->addItem( "List item 3"); |
243 } |
140 break; |
244 break; |
141 default: |
245 } |
142 break; |
246 default: |
143 } |
247 break; |
144 |
248 } |
145 HANDLE_ERROR_NULL(mWidget); |
249 |
146 mWidget->setModel(mModel); |
250 HANDLE_ERROR_NULL(mWidget); |
|
251 if (mWidget) |
|
252 { |
|
253 mWidget->setModel( mModel ); |
|
254 connect(mWidget, SIGNAL(activated(QModelIndex)), SLOT(openDialog(QModelIndex))); |
147 connect(mWidget, SIGNAL(activated(QModelIndex)), SLOT(openDialog(QModelIndex))); |
255 connect(mWidget, SIGNAL(longPressed(QModelIndex, QPointF)), SLOT(openView(QModelIndex))); |
148 connect(mWidget, SIGNAL(longPressed(QModelIndex, QPointF)), SLOT(openView(QModelIndex))); |
256 QList<HbMainWindow *> mainWindows = hbInstance->allMainWindows(); |
149 QList<HbMainWindow *> mainWindows = hbInstance->allMainWindows(); |
257 if (mainWindows.count() > 0) |
150 if (mainWindows.count() > 0) { |
258 { |
|
259 HbMainWindow *primaryWindow = mainWindows[0]; |
151 HbMainWindow *primaryWindow = mainWindows[0]; |
260 connect(primaryWindow, SIGNAL(orientationChanged(Qt::Orientation)), mWidget, SLOT(orientationChanged(Qt::Orientation))); |
152 connect(primaryWindow, SIGNAL(orientationChanged(Qt::Orientation)), mWidget, SLOT(orientationChanged(Qt::Orientation))); |
261 } |
153 connect(primaryWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation))); |
262 |
154 } |
263 connect(mWidget, SIGNAL(scrollingStarted()), SLOT(onScrollingStarted())); |
155 setupWidgetOptions(); |
264 connect(mWidget, SIGNAL(scrollingEnded()), SLOT(onScrollingEnded())); |
156 setupWidgetSize(); |
265 } |
157 |
|
158 connect(mWidget, SIGNAL(scrollingStarted()), SLOT(onScrollingStarted())); |
|
159 connect(mWidget, SIGNAL(scrollingEnded()), SLOT(onScrollingEnded())); |
|
160 } |
|
161 } |
|
162 |
|
163 void HgWidgetTestView::changeScrollBarVisibility(HgWidget::ScrollBarPolicy policy) |
|
164 { |
|
165 FUNC_LOG; |
|
166 |
|
167 if (mWidget->scrollBarPolicy() != policy) { |
|
168 mWidget->setScrollBarPolicy(policy); |
|
169 } |
|
170 } |
|
171 |
|
172 void HgWidgetTestView::changeScrollBarInteractivity(bool value) |
|
173 { |
|
174 FUNC_LOG; |
|
175 |
|
176 if (mWidget->scrollBar()->isInteractive() != value) { |
|
177 mWidget->scrollBar()->setInteractive(value); |
|
178 |
|
179 if (mWidgetType == HgWidgetCoverflow || mWidgetType == HgWidgetTBone) { |
|
180 mWidget->setIndexFeedbackPolicy(HgWidget::IndexFeedbackSingleCharacter); |
|
181 } |
|
182 } |
|
183 } |
|
184 |
|
185 void HgWidgetTestView::changeModelImageType(HgTestImageType type) |
|
186 { |
|
187 FUNC_LOG; |
|
188 |
|
189 if (mModel->imageDataType() != type) { |
|
190 mModel->setImageDataType(type); |
|
191 } |
|
192 } |
|
193 |
|
194 void HgWidgetTestView::changeLowResImageUse(bool value) |
|
195 { |
|
196 FUNC_LOG; |
|
197 |
|
198 if (mWidgetType == HgWidgetCoverflow || mWidgetType == HgWidgetTBone) { |
|
199 mModel->enableLowResImages(value); |
|
200 initWidget(mWidgetType); |
|
201 } |
|
202 } |
|
203 |
|
204 void HgWidgetTestView::changeTitlePosition(HgMediawall::LabelPosition position) |
|
205 { |
|
206 FUNC_LOG; |
|
207 |
|
208 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
|
209 if (mediawall && mediawall->titlePosition() != position) { |
|
210 mediawall->setTitlePosition(position); |
|
211 } |
|
212 } |
|
213 |
|
214 void HgWidgetTestView::changeTitleFont(const HbFontSpec &fontSpec) |
|
215 { |
|
216 FUNC_LOG; |
|
217 |
|
218 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
|
219 if (mediawall && mediawall->titleFontSpec() != fontSpec) { |
|
220 mediawall->setTitleFontSpec(fontSpec); |
|
221 } |
|
222 } |
|
223 |
|
224 void HgWidgetTestView::changeDescriptionPosition(HgMediawall::LabelPosition position) |
|
225 { |
|
226 FUNC_LOG; |
|
227 |
|
228 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
|
229 if (mediawall && mediawall->descriptionPosition() != position) { |
|
230 mediawall->setDescriptionPosition(position); |
|
231 } |
|
232 } |
|
233 |
|
234 void HgWidgetTestView::changeDescriptionFont(const HbFontSpec &fontSpec) |
|
235 { |
|
236 FUNC_LOG; |
|
237 |
|
238 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
|
239 if (mediawall && mediawall->descriptionFontSpec() != fontSpec) { |
|
240 mediawall->setDescriptionFontSpec(fontSpec); |
|
241 } |
|
242 } |
|
243 |
|
244 void HgWidgetTestView::changeWidgetHeight(int value) |
|
245 { |
|
246 FUNC_LOG; |
|
247 |
|
248 int height(rect().height()); |
|
249 if (value < height) { |
|
250 qreal left(0), top(0), right(0), bottom(0); |
|
251 mLayout->getContentsMargins(&left, &top, &right, &bottom); |
|
252 |
|
253 if (mWidgetType == HgWidgetTBone) { |
|
254 mListWidget->setPreferredSize(mListWidget->preferredSize().width(), height-value); |
|
255 mLayout->setContentsMargins(left, 0, right, 0); |
|
256 } |
|
257 else { |
|
258 int margin(0); |
|
259 margin = (height-value)/2; |
|
260 mLayout->setContentsMargins(left, margin, right, margin); |
|
261 } |
|
262 } |
|
263 } |
|
264 |
|
265 void HgWidgetTestView::changeWidgetWidth(int value) |
|
266 { |
|
267 FUNC_LOG; |
|
268 |
|
269 int width(rect().width()); |
|
270 int margin(0); |
|
271 if (value < width) { |
|
272 margin = (width-value)/2; |
|
273 } |
|
274 |
|
275 qreal left(0), top(0), right(0), bottom(0); |
|
276 mLayout->getContentsMargins(&left, &top, &right, &bottom); |
|
277 mLayout->setContentsMargins(margin, top, margin, bottom); |
266 } |
278 } |
267 |
279 |
268 void HgWidgetTestView::openDialog(const QModelIndex& index) |
280 void HgWidgetTestView::openDialog(const QModelIndex& index) |
269 { |
281 { |
270 FUNC_LOG; |
282 FUNC_LOG; |
271 |
283 |
272 QVariant image = mModel->data(index, Qt::DecorationRole); |
284 QVariant image = mModel->data(index, Qt::DecorationRole); |
273 QVariant texts = mModel->data(index, Qt::DisplayRole); |
285 QVariant texts = mModel->data(index, Qt::DisplayRole); |
274 |
286 |
275 if (mWidgetType == HgWidgetCoverflow) |
287 if (mWidgetType == HgWidgetCoverflow || mWidgetType == HgWidgetTBone) |
276 { |
288 { |
277 if (image.canConvert<QPixmap>() && texts.canConvert<QStringList>()) |
289 if (image.canConvert<QPixmap>() && texts.canConvert<QStringList>()) |
278 { |
290 { |
279 QStringList strList = texts.toStringList(); |
291 QStringList strList = texts.toStringList(); |
280 if (strList.count() > 1) |
292 if (strList.count() > 1) |
281 { |
293 { |
282 if (mFrontItem) |
294 if (mFrontItem) |
283 mFrontItem->setVisible(false); |
295 mFrontItem->setVisible(false); |
284 |
296 |
285 if (mFlipWidget) |
297 if (mFlipWidget) |
286 delete mFlipWidget; |
298 delete mFlipWidget; |
287 |
299 |
288 QPolygonF poly; |
300 QPolygonF poly; |
289 if (!mWidget->getItemOutline(index, poly)) |
301 if (!mWidget->getItemOutline(index, poly)) |
290 return; |
302 return; |
291 |
303 |
292 QRectF itemRect = poly.boundingRect(); |
304 QRectF itemRect = poly.boundingRect(); |
|
305 itemRect.moveTo(itemRect.topLeft() + mWidget->geometry().topLeft()); |
293 |
306 |
294 mFlipWidget = |
307 mFlipWidget = |
295 new HgFlipWidget( |
308 new HgFlipWidget( |
296 strList.at(0), |
309 strList.at(0), |
297 strList.at(1), |
310 strList.at(1), |
456 } |
482 } |
457 |
483 |
458 mWidget->show(); |
484 mWidget->show(); |
459 } |
485 } |
460 |
486 |
461 void HgWidgetTestView::autoHideScrollBar() |
487 void HgWidgetTestView::showOptions() |
462 { |
488 { |
463 setScrollBarPolicy(HgWidget::ScrollBarAutoHide); |
489 FUNC_LOG; |
464 } |
490 |
465 |
491 QList<HbMainWindow *> mainWindows = hbInstance->allMainWindows(); |
466 void HgWidgetTestView::scrollBarAlwaysOn() |
492 if (mainWindows.count() > 0) { |
467 { |
493 HbMainWindow *primaryWindow = mainWindows[0]; |
468 setScrollBarPolicy(HgWidget::ScrollBarAlwaysOn); |
494 if (!mOptionsView) { |
469 } |
495 HgWidgetOptionsView* view = new HgWidgetOptionsView; |
470 |
496 connect(view, SIGNAL(optionsClosed()), SLOT(hideOptions())); |
471 void HgWidgetTestView::scrollBarAlwaysOff() |
497 connect(view, SIGNAL(widgetTypeChanged(HgTestWidgetType)), |
472 { |
498 SLOT(initWidget(HgTestWidgetType))); |
473 setScrollBarPolicy(HgWidget::ScrollBarAlwaysOff); |
499 connect(view, SIGNAL(scrollBarVisibilityChanged(HgWidget::ScrollBarPolicy)), |
474 } |
500 SLOT(changeScrollBarVisibility(HgWidget::ScrollBarPolicy))); |
475 |
501 connect(view, SIGNAL(scrollBarInteractivityChanged(bool)), |
476 void HgWidgetTestView::setScrollBarPolicy( HgWidget::ScrollBarPolicy policy ) |
502 SLOT(changeScrollBarInteractivity(bool))); |
477 { |
503 connect(view, SIGNAL(imageTypeChanged(HgTestImageType)), |
478 mWidget->setScrollBarPolicy( policy ); |
504 SLOT(changeModelImageType(HgTestImageType))); |
479 } |
505 connect(view, SIGNAL(lowResImageUseChanged(bool)), SLOT(changeLowResImageUse(bool))); |
480 |
506 connect(view, SIGNAL(widgetHeightChanged(int)), SLOT(changeWidgetHeight(int))); |
481 void HgWidgetTestView::setScrollBarInteractive( bool value ) |
507 connect(view, SIGNAL(widgetWidthChanged(int)), SLOT(changeWidgetWidth(int))); |
482 { |
508 connect(view, SIGNAL(titlePositionChanged(HgMediawall::LabelPosition)), |
483 if( value ) |
509 SLOT(changeTitlePosition(HgMediawall::LabelPosition))); |
484 setScrollBarPolicy(HgWidget::ScrollBarAlwaysOn); |
510 connect(view, SIGNAL(titleFontChanged(HbFontSpec)), |
485 |
511 SLOT(changeTitleFont(HbFontSpec))); |
486 mWidget->scrollBar()->setInteractive(value); |
512 connect(view, SIGNAL(descriptionPositionChanged(HgMediawall::LabelPosition)), |
487 |
513 SLOT(changeDescriptionPosition(HgMediawall::LabelPosition))); |
488 if (mWidgetType == HgWidgetCoverflow) { |
514 connect(view, SIGNAL(descriptionFontChanged(HbFontSpec)), |
489 mWidget->setIndexFeedbackPolicy(HgWidget::IndexFeedbackSingleCharacter); |
515 SLOT(changeDescriptionFont(HbFontSpec))); |
490 } |
516 connect(view, SIGNAL(reflectionsEnabledChanged(bool)), |
491 |
517 SLOT(changeReflectionsEnabled(bool))); |
492 } |
518 |
493 |
519 mOptionsView = view; |
494 void HgWidgetTestView::interactiveScrollBar() |
520 primaryWindow->addView(mOptionsView); |
495 { |
521 } |
496 setScrollBarInteractive(true); |
522 primaryWindow->setCurrentView(mOptionsView); |
497 } |
523 } |
498 |
524 } |
499 void HgWidgetTestView::unInteractiveScrollBar() |
525 |
500 { |
526 void HgWidgetTestView::hideOptions() |
501 setScrollBarInteractive(false); |
527 { |
502 } |
528 FUNC_LOG; |
503 |
529 |
504 HgWidget *HgWidgetTestView::createWidget(WidgetType type) const |
530 QList<HbMainWindow *> mainWindows = hbInstance->allMainWindows(); |
|
531 if (mainWindows.count() > 0) { |
|
532 HbMainWindow *primaryWindow = mainWindows[0]; |
|
533 primaryWindow->setCurrentView(this); |
|
534 } |
|
535 } |
|
536 |
|
537 void HgWidgetTestView::setupWidget() |
|
538 { |
|
539 FUNC_LOG; |
|
540 |
|
541 QSettings settings(SETT_ORGANIZATION, SETT_APPLICATION); |
|
542 |
|
543 QVariant value = settings.value(SETT_WIDGET_TYPE); |
|
544 if (value.isValid()) { |
|
545 initWidget(static_cast<HgTestWidgetType>(value.toInt())); |
|
546 } |
|
547 else { |
|
548 initWidget(HgWidgetGrid); |
|
549 } |
|
550 |
|
551 value = settings.value(SETT_LOW_RES_IMAGES); |
|
552 if (value.isValid()) { |
|
553 changeLowResImageUse(value.toBool()); |
|
554 } |
|
555 } |
|
556 |
|
557 void HgWidgetTestView::setupWidgetOptions() |
|
558 { |
|
559 FUNC_LOG; |
|
560 |
|
561 QSettings settings(SETT_ORGANIZATION, SETT_APPLICATION); |
|
562 |
|
563 QVariant value = settings.value(SETT_SCROLLBAR_VISIBILITY); |
|
564 if (value.isValid()) { |
|
565 changeScrollBarVisibility(static_cast<HgWidget::ScrollBarPolicy>(value.toInt())); |
|
566 } |
|
567 |
|
568 value = settings.value(SETT_SCROLLBAR_INTERACTIVITY); |
|
569 if (value.isValid()) { |
|
570 changeScrollBarInteractivity(value.toBool()); |
|
571 } |
|
572 |
|
573 value = settings.value(SETT_MODEL_IMAGE_TYPE); |
|
574 if (value.isValid()) { |
|
575 changeModelImageType(static_cast<HgTestImageType>(value.toInt())); |
|
576 } |
|
577 else { |
|
578 changeModelImageType(ImageTypeQImage); |
|
579 } |
|
580 |
|
581 value = settings.value(SETT_TITLE_POSITION); |
|
582 if (value.isValid()) { |
|
583 changeTitlePosition(static_cast<HgMediawall::LabelPosition>(value.toInt())); |
|
584 } |
|
585 |
|
586 value = settings.value(SETT_TITLE_FONT); |
|
587 if (value.isValid()) { |
|
588 changeTitleFont(HbFontSpec(static_cast<HbFontSpec::Role>(value.toInt()))); |
|
589 } |
|
590 |
|
591 value = settings.value(SETT_DESCRIPTION_POSITION); |
|
592 if (value.isValid()) { |
|
593 changeDescriptionPosition(static_cast<HgMediawall::LabelPosition>(value.toInt())); |
|
594 } |
|
595 |
|
596 value = settings.value(SETT_DESCRIPTION_FONT); |
|
597 if (value.isValid()) { |
|
598 changeDescriptionFont(HbFontSpec(static_cast<HbFontSpec::Role>(value.toInt()))); |
|
599 } |
|
600 |
|
601 value = settings.value(SETT_REFLECTIONS_ENABLED); |
|
602 if (value.isValid()) { |
|
603 changeReflectionsEnabled(value.toBool()); |
|
604 } |
|
605 |
|
606 } |
|
607 |
|
608 void HgWidgetTestView::setupWidgetSize() |
|
609 { |
|
610 QSettings settings(SETT_ORGANIZATION, SETT_APPLICATION); |
|
611 |
|
612 QVariant value = settings.value(SETT_WIDGET_HEIGHT); |
|
613 if (value.isValid()) { |
|
614 changeWidgetHeight(value.toInt()); |
|
615 } |
|
616 |
|
617 value = settings.value(SETT_WIDGET_WIDTH); |
|
618 if (value.isValid()) { |
|
619 changeWidgetWidth(value.toInt()); |
|
620 } |
|
621 } |
|
622 |
|
623 HgWidget *HgWidgetTestView::createWidget(HgTestWidgetType type) const |
505 { |
624 { |
506 FUNC_LOG; |
625 FUNC_LOG; |
507 HANDLE_ERROR_NULL(mModel); |
626 HANDLE_ERROR_NULL(mModel); |
508 HANDLE_ERROR_NULL(mSelectionModel); |
627 HANDLE_ERROR_NULL(mSelectionModel); |
509 |
628 |
510 Qt::Orientation scrollDirection = !mToggleOrientation ? Qt::Vertical : Qt::Horizontal ; |
629 Qt::Orientation scrollDirection = Qt::Vertical; |
|
630 QList<HbMainWindow *> mainWindows = hbInstance->allMainWindows(); |
|
631 if (mainWindows.count() > 0) |
|
632 { |
|
633 HbMainWindow *primaryWindow = mainWindows[0]; |
|
634 if (primaryWindow->orientation() == Qt::Horizontal) { |
|
635 scrollDirection = Qt::Horizontal; |
|
636 } |
|
637 } |
511 |
638 |
512 HgWidget* widget = 0; |
639 HgWidget* widget = 0; |
513 |
640 HgCoverflowWidget* temp = 0; |
|
641 |
514 switch (type) { |
642 switch (type) { |
515 case HgWidgetGrid: |
643 case HgWidgetGrid: |
|
644 mModel->setThumbnailSize(ThumbnailManager::ThumbnailMedium); |
|
645 mModel->setBuffer(GRIDBUFFERSIZE, GRIDBUFFERSIZE/3); |
516 widget = new HgGrid(scrollDirection); |
646 widget = new HgGrid(scrollDirection); |
517 break; |
647 break; |
518 case HgWidgetCoverflow: |
648 case HgWidgetCoverflow: |
519 widget = new HgMediawall(); |
649 mModel->setThumbnailSize(ThumbnailManager::ThumbnailLarge); |
|
650 mModel->setBuffer(COVERFLOWBUFFERSIZE, COVERFLOWBUFFERSIZE/3); |
|
651 widget = new HgCoverflowWidget(); |
|
652 temp = (HgCoverflowWidget*)widget; |
|
653 temp->setTitlePosition(HgMediawall::PositionNone); |
|
654 break; |
|
655 case HgWidgetTBone: |
|
656 mModel->setThumbnailSize(ThumbnailManager::ThumbnailLarge); |
|
657 mModel->setBuffer(COVERFLOWBUFFERSIZE, COVERFLOWBUFFERSIZE/3); |
|
658 widget = new HgCoverflowWidget(); |
|
659 temp = (HgCoverflowWidget*)widget; |
|
660 temp->setTitlePosition(HgMediawall::PositionNone); |
520 break; |
661 break; |
521 default: |
662 default: |
522 break; |
663 break; |
523 } |
664 } |
524 |
665 |
597 void HgWidgetTestView::onScrollingEnded() |
719 void HgWidgetTestView::onScrollingEnded() |
598 { |
720 { |
599 FUNC_LOG; |
721 FUNC_LOG; |
600 |
722 |
601 if (mModel->lowResImagesEnabled()) { |
723 if (mModel->lowResImagesEnabled()) { |
602 |
724 |
603 if (!mWidget) |
725 if (!mWidget) |
604 return; |
726 return; |
605 |
727 |
606 // get index to current item |
728 // get index to current item |
607 QModelIndex index = mWidget->currentIndex(); |
729 QModelIndex index = mWidget->currentIndex(); |
608 if (!index.isValid()) |
730 if (!index.isValid()) |
609 return; |
731 return; |
610 |
732 |
611 // get outlines of the item so we know where to render |
733 // get outlines of the item so we know where to render |
612 QPolygonF poly; |
734 QPolygonF poly; |
613 if (!mWidget->getItemOutline(index, poly)) |
735 if (!mWidget->getItemOutline(index, poly)) |
614 return; |
736 return; |
615 |
737 |
616 // fetch highresolution image from the model |
738 // fetch highresolution image from the model |
617 QVariant imgVariant = mModel->data(index, Qt::UserRole+2); |
739 QVariant imgVariant = mModel->data(index, Qt::UserRole+2); |
618 if (imgVariant.isNull()) |
740 if (imgVariant.isNull()) |
619 return; |
741 return; |
620 |
742 |
621 QRectF itemRect = poly.boundingRect(); |
743 QRectF itemRect = poly.boundingRect(); |
622 |
744 itemRect.moveTo(itemRect.topLeft() + mWidget->geometry().topLeft()); |
|
745 |
623 // show it using HbLabel |
746 // show it using HbLabel |
624 QPixmap pixmap = imgVariant.value<QPixmap>().scaled(itemRect.width(), itemRect.height()); |
747 QPixmap pixmap = imgVariant.value<QPixmap>().scaled(itemRect.width(), itemRect.height()); |
625 |
748 |
626 if (!mFrontItem) { |
749 if (!mFrontItem) { |
627 mFrontItem = new HbLabel(this); |
750 mFrontItem = new HbLabel(this); |
628 } |
751 } |
629 |
752 |
630 |
753 |
631 mFrontItem->setVisible(false); |
754 mFrontItem->setVisible(false); |
632 mFrontItem->setIcon(HbIcon(pixmap)); |
755 mFrontItem->setIcon(HbIcon(pixmap)); |
633 mFrontItem->setAlignment(Qt::AlignHCenter|Qt::AlignVCenter); |
756 mFrontItem->setAlignment(Qt::AlignHCenter|Qt::AlignVCenter); |
634 mFrontItem->setPos(itemRect.center() - QPointF(itemRect.width()/2, itemRect.height()/2)); |
757 mFrontItem->setPos(itemRect.center() - QPointF(itemRect.width()/2, itemRect.height()/2)); |
635 mFrontItem->resize(itemRect.width(), itemRect.height()); |
758 mFrontItem->resize(itemRect.width(), itemRect.height()); |
636 mFrontItem->setVisible(true); |
759 mFrontItem->setVisible(true); |
637 |
760 } |
638 } |
761 } |
639 |
762 |
640 } |
763 void HgWidgetTestView::orientationChanged(Qt::Orientation orientation) |
641 |
764 { |
642 void HgWidgetTestView::toggleLowResForCoverflow() |
765 if (orientation == Qt::Horizontal && mWidgetType == HgWidgetCoverflow ) { |
643 { |
766 setItemVisible(Hb::AllItems, false); |
644 if (mWidgetType == HgWidgetCoverflow) { |
767 } |
645 mModel->enableLowResImages(mUseLowResAction->isChecked()); |
768 else if (orientation == Qt::Horizontal && mWidgetType == HgWidgetTBone) { |
646 initWidget(mWidgetType); |
769 initWidget(HgWidgetCoverflow); |
647 } |
770 // HbEffect::add(mWidget,":/effect1.fxml", "end"); |
648 } |
771 // HbEffect::start(mWidget, "end"); |
649 |
772 setItemVisible(Hb::AllItems, false); |
650 void HgWidgetTestView::setTitleAboveImage() |
773 } |
651 { |
774 else if (orientation == Qt::Vertical && mWidgetType == HgWidgetCoverflow) { |
652 FUNC_LOG; |
775 initWidget(HgWidgetTBone); |
653 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
776 // HbEffect::add(mWidget,":/effect1.fxml", "end"); |
654 if (mediawall) { |
777 // HbEffect::start(mWidget, "end"); |
655 mediawall->setTitlePosition(HgMediawall::PositionAboveImage); |
778 setItemVisible(Hb::AllItems, true); |
656 } |
779 } |
657 } |
780 |
658 |
781 HgCoverflowWidget* wall = qobject_cast<HgCoverflowWidget*>(mWidget); |
659 void HgWidgetTestView::setTitleBelowImage() |
782 if (wall) |
660 { |
783 wall->updateTextPositions(); |
661 FUNC_LOG; |
784 } |
662 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
785 void HgWidgetTestView::resizeEvent(QGraphicsSceneResizeEvent *event) |
663 if (mediawall) { |
786 { |
664 mediawall->setTitlePosition(HgMediawall::PositionBelowImage); |
787 Q_UNUSED(event); |
665 } |
788 FUNC_LOG; |
666 } |
789 |
667 |
790 setupWidgetSize(); |
668 void HgWidgetTestView::setTitleHidden() |
791 |
669 { |
792 /* if (mWidgetType == HgWidgetCoverflow || |
670 FUNC_LOG; |
793 mWidgetType == HgWidgetTBone) |
671 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
794 { |
672 if (mediawall) { |
795 HgMediawall* wall = qobject_cast<HgMediawall*>(mWidget); |
673 mediawall->setTitlePosition(HgMediawall::PositionNone); |
796 wall->setFrontItemPosition(QPointF(mWidget->size().width()/2, |
674 } |
797 mWidget->size().height()/2)); |
675 } |
798 }*/ |
676 |
799 } |
677 void HgWidgetTestView::setDescriptionAboveImage() |
800 |
678 { |
801 Qt::Orientation HgWidgetTestView::orientation() const |
679 FUNC_LOG; |
802 { |
680 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
803 FUNC_LOG; |
681 if (mediawall) { |
804 |
682 mediawall->setDescriptionPosition(HgMediawall::PositionAboveImage); |
805 if (mainWindow()) { |
683 } |
806 return mainWindow()->orientation(); |
684 } |
807 } |
685 |
808 |
686 void HgWidgetTestView::setDescriptionBelowImage() |
809 return Qt::Horizontal; |
687 { |
810 } |
688 FUNC_LOG; |
811 |
689 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
812 void HgWidgetTestView::startItemSizeChange() |
690 if (mediawall) { |
813 { |
691 mediawall->setDescriptionPosition(HgMediawall::PositionBelowImage); |
814 if (mItemSizeDialog) |
692 } |
815 return; |
693 } |
816 |
694 |
817 if (!mWidget) |
695 void HgWidgetTestView::setDescriptionHidden() |
818 return; |
696 { |
819 |
697 FUNC_LOG; |
820 QSizeF itemSize = mWidget->itemSize(); |
698 HgMediawall *mediawall = qobject_cast<HgMediawall *>(mWidget); |
821 QSizeF itemSpacing = mWidget->itemSpacing(); |
699 if (mediawall) { |
822 mItemSizeDialog = new HgItemSizeDialog(itemSize, itemSpacing, this); |
700 mediawall->setDescriptionPosition(HgMediawall::PositionNone); |
823 |
701 } |
824 QObject::connect(mItemSizeDialog, SIGNAL(updateItemSizeAndSpacing()), this, SLOT(updateItemSizeAndSpacing())); |
702 } |
825 QObject::connect(mItemSizeDialog, SIGNAL(closed()), this, SLOT(itemSizeDialogClosed())); |
|
826 } |
|
827 |
|
828 void HgWidgetTestView::startItemPosChange() |
|
829 { |
|
830 if (mItemPosDialog) |
|
831 return; |
|
832 |
|
833 if (!mWidget) |
|
834 return; |
|
835 |
|
836 HgMediawall* wall = qobject_cast<HgMediawall*>(mWidget); |
|
837 if (!wall) |
|
838 return; |
|
839 |
|
840 QPointF itemPos = wall->frontItemPositionDelta(); |
|
841 QSizeF s(itemPos.x(), itemPos.y()); |
|
842 mItemPosDialog = new HgItemSizeDialog(s, s, this); |
|
843 |
|
844 mItemPosDialog->setSliderLimits(-500, 500); |
|
845 |
|
846 QObject::connect(mItemPosDialog, SIGNAL(updateItemSizeAndSpacing()), this, SLOT(updateItemPos())); |
|
847 QObject::connect(mItemPosDialog, SIGNAL(closed()), this, SLOT(itemPosDialogClosed())); |
|
848 } |
|
849 |
|
850 |
|
851 |
|
852 void HgWidgetTestView::updateItemSizeAndSpacing() |
|
853 { |
|
854 if (!mItemSizeDialog) |
|
855 return; |
|
856 |
|
857 mWidget->setItemSize(mItemSizeDialog->itemSize()); |
|
858 mWidget->setItemSpacing(mItemSizeDialog->itemSpacing()); |
|
859 |
|
860 HgCoverflowWidget* wall = qobject_cast<HgCoverflowWidget*>(mWidget); |
|
861 if (wall) |
|
862 { |
|
863 wall->updateTextPositions(); |
|
864 } |
|
865 |
|
866 mWidget->update(); |
|
867 |
|
868 } |
|
869 |
|
870 void HgWidgetTestView::updateItemPos() |
|
871 { |
|
872 if (!mItemPosDialog) |
|
873 return; |
|
874 |
|
875 HgCoverflowWidget* wall = qobject_cast<HgCoverflowWidget*>(mWidget); |
|
876 if (!wall) |
|
877 return; |
|
878 |
|
879 QSizeF s = mItemPosDialog->itemSize(); |
|
880 wall->setFrontItemPositionDelta(QPointF(s.width(), s.height())); |
|
881 wall->updateTextPositions(); |
|
882 mWidget->update(); |
|
883 } |
|
884 |
|
885 void HgWidgetTestView::itemSizeDialogClosed() |
|
886 { |
|
887 // dialog deletes it self at close |
|
888 mItemSizeDialog = NULL; |
|
889 } |
|
890 |
|
891 void HgWidgetTestView::itemPosDialogClosed() |
|
892 { |
|
893 mItemPosDialog = NULL; |
|
894 } |
|
895 |
|
896 void HgWidgetTestView::resetOptions() |
|
897 { |
|
898 QSettings settings(SETT_ORGANIZATION, SETT_APPLICATION); |
|
899 settings.clear(); |
|
900 setupWidget(); |
|
901 } |
|
902 |
|
903 void HgWidgetTestView::changeReflectionsEnabled(bool enabled) |
|
904 { |
|
905 HgMediawall* wall = qobject_cast<HgMediawall*>(mWidget); |
|
906 if (wall) |
|
907 wall->enableReflections(enabled); |
|
908 } |
|
909 |
|
910 void HgWidgetTestView::resetModel() |
|
911 { |
|
912 mModel->reset(); |
|
913 } |