4 * Copyright 2013 Samsung Electronics Co., Ltd
6 * Licensed under the Flora License, Version 1.1 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://floralicense.org/license/
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
26 #include <preview_coords.h>
28 #include "smsc_debug.h"
30 #include "smsc_position.h"
33 int init_smsc_position(struct smsc_position *position)
35 SMSC_DEBUG("init_smsc_position() started");
37 memset(position, 0, sizeof(struct smsc_position));
39 /* event of position update */
40 position->position_update_event_type = ecore_event_type_new();
42 SMSC_DEBUG("init_smsc_position() finished");
48 int set_smsc_position_settings(struct smsc_position *position, int pages_count,
49 const struct size_px *available_size_px,
50 const struct size_pts *page_size)
52 /* calculate page size in pixels */
53 struct size_pts min_area_size;
54 struct size_px min_area_size_px;
57 position->is_configured = 1;
58 position->pages_count = pages_count;
59 position->available_size = *available_size_px;
62 min_area_size.x = page_size->x
63 * (1 + PAGE_SIDE_SHOW_COEFF * 2 + MIN_PAGE_SPACE_COEFF * 2);
64 min_area_size.y = page_size->y;
66 if (pts_size2px(&min_area_size, available_size_px,
67 &min_area_size_px) < 0) {
68 //PGEN_DEBUG("ERROR: full_size: pts_size2px()\n");
72 position->page_size_px.x = min_area_size_px.x
73 / (1 + PAGE_SIDE_SHOW_COEFF * 2 + MIN_PAGE_SPACE_COEFF * 2);
74 position->page_size_px.y = min_area_size_px.y;
75 SMSC_DEBUG("init_smsc_position(): page_size_px: (%d, %d)",
76 position->page_size_px.x, position->page_size_px.y);
82 int clear_smsc_position_settings(struct smsc_position *position)
84 position->is_configured = 0;
85 position->pages_count = -1;
90 int get_smsc_position_all_width(const struct smsc_position *position)
92 if (position->is_configured == 0)
94 if (1 == position->pages_count)
96 return position->page_size_px.x * (position->pages_count - 1)
97 * (1 + MIN_PAGE_SPACE_COEFF);
101 int get_smsc_position_cur_page(const struct smsc_position *position)
105 SMSC_RETV_IF(NULL == position, -1, "Argument error");
106 SMSC_RETV_IF(!position->is_configured, -1, "Position not configured");
108 /*SMSC_DEBUG("position->offset = %d", position->offset);
109 SMSC_DEBUG("position->page_size_px.x = %d", position->page_size_px.x);
110 SMSC_DEBUG("MIN_PAGE_SPACE_COEFF = %f", MIN_PAGE_SPACE_COEFF);
111 SMSC_DEBUG("position->pages_count = %d", position->pages_count);*/
112 res = (position->offset + (position->page_size_px.x / 2)
113 * (1 + MIN_PAGE_SPACE_COEFF))
114 / (position->page_size_px.x * (1 + MIN_PAGE_SPACE_COEFF));
115 //SMSC_DEBUG("res = %f", res);
116 if (res >= position->pages_count)
117 return position->pages_count - 1;
124 int get_smsc_position_max_vispages_count(const struct smsc_position *position)
130 if (NULL == position)
133 page_sizex = position->page_size_px.x;
134 all_sizex = position->available_size.x;
135 page_count = ceil(all_sizex * (1 + MIN_PAGE_SPACE_COEFF)
136 / (page_sizex * (1 + MIN_PAGE_SPACE_COEFF)));
137 //SMSC_DEBUG("page_count = %d", page_count);
138 if (page_count > 0) {
139 /* provide odd page_count to have central page */
140 page_count = page_count + 1 - page_count % 2;
141 //SMSC_DEBUG("corrected page_count = %d", page_count);
147 int *get_smsc_position_visible_pages(const struct smsc_position *position)
152 int max_vispage_count;
159 if (position->is_configured == 0)
162 if (1 == position->pages_count) {
163 res = malloc(sizeof(int) * (1 + 1));
169 cur_page_i = get_smsc_position_cur_page(position);
172 cur_page = cur_page_i + 1;
173 max_vispage_count = get_smsc_position_max_vispages_count(position);
174 if (max_vispage_count < 1)
177 middle_page = 1 + max_vispage_count / 2;
178 vispages_left = cur_page - 1;
179 if (vispages_left > middle_page - 1)
180 vispages_left = middle_page - 1;
181 vispages_right = position->pages_count - cur_page;
182 if (vispages_right > middle_page - 1)
183 vispages_right = middle_page - 1;
184 vispages = vispages_right + vispages_left + 1;
186 res = malloc(sizeof(int) * (vispages + 1));
189 /*SMSC_DEBUG("vispages = %d, vispages_left = %d, vispages_right = %d, "
191 vispages, vispages_left, vispages_right, middle_page);*/
193 for (i = 0; i < vispages; ++i)
194 res[i] = cur_page + (i + 1 - (vispages_left + 1)) - 1;
201 int get_smsc_position_page(const struct smsc_position *position,
202 int page, int *is_ok)
206 SMSC_RETV_IF(NULL == position || NULL == is_ok, -1, "Argument error");
209 if (position->is_configured == 0) {
213 if (NULL == position || page < 0 || page >= position->pages_count) {
214 /*SMSC_DEBUG("ERROR in get_smsc_position_page(), page = %d,"
216 page, position->pages_count);*/
220 res = position->available_size.x / 2 - position->offset
221 + page * position->page_size_px.x
222 * (1 + MIN_PAGE_SPACE_COEFF)
223 - position->page_size_px.x / 2;
224 //SMSC_DEBUG("get_smsc_position_page(): page %d: res = %d", page, res);
229 int get_smsc_position_cur_page_center_xdiff(
230 const struct smsc_position *position, int *is_ok)
234 SMSC_RETV_IF(NULL == is_ok, -1, "Argument error");
236 SMSC_RETV_IF(NULL == position, -1, "Argument error");
238 page = get_smsc_position_cur_page(position);
239 SMSC_RETV_IF(page < 0, -1, "Error in current page calculation");
240 res = page * (position->page_size_px.x * (1 + MIN_PAGE_SPACE_COEFF))
246 int move_smsc_position(struct smsc_position *position, int xdiff)
248 struct smsc_position_event *event_data;
251 SMSC_RETV_IF(NULL == position, -1, "Argument error");
252 SMSC_RETV_IF(position->is_configured == 0, -1, "Not configured");
254 all_width = get_smsc_position_all_width(position);
255 SMSC_RETV_IF(all_width < 0, -1, "Width calculation error");
256 //SMSC_DEBUG("move_smsc_position() started");
257 if (xdiff + position->offset >= all_width)
258 position->offset = all_width;
259 else if (xdiff + position->offset <= 0)
260 position->offset = 0;
262 position->offset = position->offset + xdiff;
264 /* emit ecore event */
265 event_data = malloc(sizeof(struct smsc_position_event));
266 memset(event_data, 0, sizeof(struct smsc_position_event));
267 ecore_event_add(position->position_update_event_type,
268 event_data, NULL, NULL);
274 int set_smsc_position(struct smsc_position *position, int offset)
276 struct smsc_position_event *event_data;
279 SMSC_RETV_IF(NULL == position || offset < 0, -1, "Argument error");
281 all_width = get_smsc_position_all_width(position);
282 SMSC_RETV_IF(all_width < 0, -1, "Width calculation error");
284 if (offset >= all_width)
285 position->offset = all_width;
287 position->offset = offset;
289 /* emit ecore event */
290 event_data = malloc(sizeof(struct smsc_position_event));
291 memset(event_data, 0, sizeof(struct smsc_position_event));
292 ecore_event_add(position->position_update_event_type,
293 event_data, NULL, NULL);