← Back to branch summary

~ubuntu-branches/ubuntu/maverick/ldtp/maverick

« back to all changes in this revision

Viewing changes to src/slider.c

  • Committer: Bazaar Package Importer
  • Author(s): Kartik Mistry
  • Date: 2010-02-04 10:36:08 UTC
  • mfrom: (1.4.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: james.westby@ubuntu.com-20100204103608-dhqdo7jk10ygwt40
Tags: 2.0.2-1
* New upstream release:
  + Packaging is based on Ubuntu packages, Thanks Ubuntu!
  + LDTPv2 is a complete rewrite of LDTPv1 in Python
  + LTFX is completely removed in LDTP v2 in favor of wnck
* debian/control:
  + Updated to Standards-Version 3.8.4 (no changes needed)
  + Fixed typo in description python->Python
  + ldtp is now arch: all package
* debian/rules:
  + Using dh to make it simple
* Removed unused manpages
* Updated package to use new source format 3.0 (quilt)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/slider.c
1
 
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
 
/* 
3
 
 * Linux Desktop Testing Project http://ldtp.freedesktop.org
4
 
 *
5
 
 * Author:
6
 
 *    S. Aishwariya <aishwariyabhavan@yahoo.com >
7
 
 *    K. Sree Kamakshi <poorvakrishna@yahoo.com >
8
 
 *    Nagappan Alagappan <nagappan@gmail.com>
9
 
 *
10
 
 * Copyright 2004 - 2006 Novell, Inc.
11
 
 * Copyright 2007 - 2008 Nagappan Alagappan
12
 
 *
13
 
 * This program is free software; you can redistribute it and/or
14
 
 * modify it under the terms of the GNU Lesser General Public
15
 
 * License as published by the Free Software Foundation; either
16
 
 * version 2 of the License, or (at your option) any later version.
17
 
 *
18
 
 * This program is distributed in the hope that it will be useful,
19
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21
 
 * Lesser General Public License for more details.
22
 
 *
23
 
 * You should have received a copy of the GNU Lesser General Public
24
 
 * License along with this program; if not, write to the
25
 
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26
 
 * Boston, MA 02110, USA.
27
 
 */
28
 
 
29
 
#include "ldtp.h"
30
 
#include "ldtp-gui.h"
31
 
#include "ldtp-utils.h"
32
 
#include "ldtp-error.h"
33
 
#include "ldtp-logger.h"
34
 
#include "ldtp-command.h"
35
 
#include "ldtp-gui-comp.h"
36
 
 
37
 
static gboolean
38
 
is_object_slider (Accessible *object, FILE *log_fp)
39
 
{
40
 
        if (wait_till_object_state_contains (object, SLIDER, log_fp) != 0) {
41
 
                LDTPErrorCode error;
42
 
                error = LDTP_ERROR_INVALID_OBJECT_STATE;
43
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
44
 
                return FALSE;
45
 
        }
46
 
        return TRUE;
47
 
}
48
 
 
49
 
static gboolean
50
 
is_slider_horizontal (Accessible *object)
51
 
{
52
 
        AccessibleStateSet *state;
53
 
        state = Accessible_getStateSet (object);
54
 
        /*
55
 
          Check if the slider is horizontal or vertical
56
 
        */
57
 
        if (AccessibleStateSet_contains (state, SPI_STATE_HORIZONTAL))
58
 
                return TRUE;  //Horizontal State
59
 
        else
60
 
                return FALSE; //Vertical State
61
 
}
62
 
 
63
 
static gboolean
64
 
is_slider_vertical (Accessible *object)
65
 
{
66
 
        AccessibleStateSet *state;
67
 
        state = Accessible_getStateSet (object);
68
 
        /*
69
 
          Check if the slider is horizontal or vertical
70
 
        */
71
 
        if (AccessibleStateSet_contains (state, SPI_STATE_VERTICAL))
72
 
                return TRUE;  //Vertical State
73
 
        else
74
 
                return FALSE; //Not vertical State
75
 
}
76
 
 
77
 
static LDTPErrorCode
78
 
set_value (Accessible *object, long numvalue, FILE *log_fp)
79
 
{
80
 
        LDTPErrorCode error;
81
 
        SPIBoolean flag = FALSE;
82
 
        AccessibleValue *accessible_value;
83
 
 
84
 
        g_print ("Slider value to be set: %ld\n", numvalue);
85
 
        accessible_value = Accessible_getValue (object);
86
 
        if (accessible_value) {
87
 
                flag = AccessibleValue_setCurrentValue (accessible_value, numvalue);
88
 
                Accessible_unref (accessible_value);
89
 
        }
90
 
        if (flag)
91
 
                return LDTP_ERROR_SUCCESS;
92
 
        else {
93
 
                error = LDTP_ERROR_UNABLE_TO_SET_SLIDER_VALUE;
94
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
95
 
                return error;
96
 
        }
97
 
}
98
 
 
99
 
static LDTPErrorCode
100
 
set_max (Accessible *object, FILE *log_fp)
101
 
{ 
102
 
        double val;
103
 
        SPIBoolean flag = FALSE;
104
 
        LDTPErrorCode error;
105
 
        AccessibleValue *value = NULL;
106
 
 
107
 
        if (is_object_slider (object, log_fp) == TRUE) {
108
 
                value = Accessible_getValue (object);
109
 
        } else {
110
 
                error = LDTP_ERROR_SLIDER_SET_MAX_FAILED;
111
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
112
 
                return error;
113
 
        }
114
 
 
115
 
        /*
116
 
          The slider is set to maximum value
117
 
        */
118
 
        if (value) {
119
 
                val = AccessibleValue_getMaximumValue (value); 
120
 
                flag = AccessibleValue_setCurrentValue (value, val);
121
 
                Accessible_unref (value);
122
 
        }
123
 
        if (flag == TRUE)
124
 
                return LDTP_ERROR_SUCCESS;
125
 
        else {
126
 
                error = LDTP_ERROR_SLIDER_SET_MAX_FAILED;
127
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
128
 
                return error;
129
 
        }
130
 
}
131
 
 
132
 
static LDTPErrorCode
133
 
set_min (Accessible *object, FILE *log_fp)
134
 
{ 
135
 
        double val;
136
 
        AccessibleValue *value = NULL;
137
 
        LDTPErrorCode error;
138
 
        SPIBoolean flag;
139
 
 
140
 
        if (is_object_slider (object, log_fp) == FALSE) {
141
 
                error = LDTP_ERROR_SLIDER_SET_MIN_FAILED;
142
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
143
 
                return error;
144
 
        }
145
 
        value = Accessible_getValue(object);    
146
 
        val = AccessibleValue_getMinimumValue (value); 
147
 
 
148
 
        /*
149
 
          The slider is set to minimum value
150
 
        */
151
 
        flag = AccessibleValue_setCurrentValue (value, val);
152
 
        Accessible_unref (value);
153
 
        if (flag == TRUE)
154
 
                return LDTP_ERROR_SUCCESS;
155
 
        else {
156
 
                error = LDTP_ERROR_SLIDER_SET_MIN_FAILED;
157
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
158
 
                return error;
159
 
        }
160
 
}
161
 
 
162
 
static double
163
 
get_slider_value (Accessible *object, FILE *log_fp)
164
 
{
165
 
        double current_val = -1;
166
 
        if (is_object_slider (object, log_fp)) {
167
 
                AccessibleValue *value = NULL;
168
 
                value = Accessible_getValue (object);
169
 
                if (value) {
170
 
                        current_val = AccessibleValue_getCurrentValue (value);
171
 
                        Accessible_unref (value);
172
 
                }
173
 
        }
174
 
        return current_val;
175
 
}
176
 
 
177
 
static double
178
 
get_min_value (Accessible *object)
179
 
{
180
 
        double value = -1;
181
 
        AccessibleValue *accessible;
182
 
        if (!object)
183
 
                return -1;
184
 
        accessible = Accessible_getValue (object);
185
 
        if (accessible) {
186
 
                value = AccessibleValue_getMinimumValue (accessible);
187
 
                Accessible_unref (accessible);
188
 
        }
189
 
        return value;
190
 
}
191
 
 
192
 
static double
193
 
get_min_increment (Accessible *object)
194
 
{
195
 
        double value = -1;
196
 
        AccessibleValue *accessible;
197
 
        if (!object)
198
 
                return -1;
199
 
        accessible = Accessible_getValue (object);
200
 
        if (accessible) {
201
 
                value = AccessibleValue_getMinimumIncrement (accessible);
202
 
                Accessible_unref (accessible);
203
 
        }
204
 
        return value;
205
 
}
206
 
 
207
 
static double
208
 
get_max_value (Accessible *object)
209
 
{
210
 
        double value = -1;
211
 
        AccessibleValue *accessible;
212
 
        if (!object)
213
 
                return -1;
214
 
        accessible = Accessible_getValue (object);
215
 
        if (accessible) {
216
 
                value = AccessibleValue_getMaximumValue (accessible);
217
 
                Accessible_unref (accessible);
218
 
        }
219
 
        return value;
220
 
}
221
 
 
222
 
static LDTPErrorCode
223
 
decrease (Accessible *object, long num, FILE *log_fp)
224
 
{
225
 
        double val;
226
 
        long i = 1;
227
 
        AccessibleValue *value = NULL;
228
 
        SPIBoolean flag = FALSE;
229
 
        if (is_object_slider (object, log_fp)) {
230
 
                value = Accessible_getValue (object);
231
 
                if (!value)
232
 
                        return LDTP_ERROR_UNABLE_TO_DECREASE_SLIDER_VALUE;
233
 
                while (i <= num) {    
234
 
                        val = AccessibleValue_getCurrentValue (value) - 1;
235
 
                        /*
236
 
                          Decrease the value of the slider
237
 
                        */
238
 
 
239
 
                        flag = AccessibleValue_setCurrentValue (value, val);
240
 
                        ldtp_nsleep (0, 15000);
241
 
                        i++;
242
 
                }
243
 
        }
244
 
        Accessible_unref (value);
245
 
        if (flag == TRUE)
246
 
                return LDTP_ERROR_SUCCESS;
247
 
        else {
248
 
                LDTPErrorCode error;
249
 
                error = LDTP_ERROR_UNABLE_TO_DECREASE_SLIDER_VALUE;
250
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
251
 
                return error;
252
 
        }
253
 
}
254
 
 
255
 
static LDTPErrorCode
256
 
increase (Accessible *object, long num, FILE *log_fp)
257
 
{
258
 
        double val;
259
 
        long i = 1;
260
 
        AccessibleValue *value = NULL;
261
 
        SPIBoolean flag = FALSE;
262
 
        if (is_object_slider (object, log_fp)) {
263
 
                value = Accessible_getValue (object);
264
 
                if (!value)
265
 
                        return LDTP_ERROR_UNABLE_TO_DECREASE_SLIDER_VALUE;
266
 
                while (i <= num) {    
267
 
                        val = AccessibleValue_getCurrentValue (value) + 1;
268
 
                        /*
269
 
                          Increase the value of the slider
270
 
                        */
271
 
 
272
 
                        flag = AccessibleValue_setCurrentValue (value, val);
273
 
                        ldtp_nsleep (0, 15000);
274
 
                        i++;
275
 
                }
276
 
        }
277
 
        Accessible_unref (value);
278
 
        if (flag == TRUE)
279
 
                return LDTP_ERROR_SUCCESS;
280
 
        else {
281
 
                LDTPErrorCode error;
282
 
                error = LDTP_ERROR_UNABLE_TO_INCREASE_SLIDER_VALUE;
283
 
                log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), log_fp);
284
 
                return error;
285
 
        }
286
 
}
287
 
 
288
 
LDTPErrorCode
289
 
slider_main (LDTPClientContext* cctxt, int command)
290
 
{
291
 
        double value = -1;
292
 
        LDTPErrorCode error;
293
 
        switch (command) {
294
 
        case LDTP_CMD_SETMAX:
295
 
                error = set_max (cctxt->gui_handle->handle, cctxt->log_fp);
296
 
                break;
297
 
        case LDTP_CMD_SETMIN:
298
 
                error = set_min (cctxt->gui_handle->handle, cctxt->log_fp);
299
 
                break;
300
 
        case LDTP_CMD_SETVALUE:
301
 
                if (cctxt->req->arg_list && cctxt->req->arg_list->data)
302
 
                        value = strtod (cctxt->req->arg_list->data, NULL);
303
 
                error = set_value (cctxt->gui_handle->handle, value,
304
 
                                   cctxt->log_fp);
305
 
                break;
306
 
        case LDTP_CMD_GETSLIDERVALUE: {
307
 
                double current_val = -1;
308
 
                current_val = get_slider_value (cctxt->gui_handle->handle, cctxt->log_fp);
309
 
                if (current_val != -1) {
310
 
                        cctxt->resp->data = g_strdup_printf ("%lf", current_val);
311
 
                        cctxt->resp->data_len = g_utf8_strlen (cctxt->resp->data, -1);
312
 
                        error = LDTP_ERROR_SUCCESS;
313
 
                }
314
 
                else {
315
 
                        error = LDTP_ERROR_UNABLE_TO_GET_SLIDER_VALUE;
316
 
                        log_msg (LDTP_LOG_CAUSE, ldtp_error_get_message (error), cctxt->log_fp);
317
 
                }
318
 
                break;
319
 
        }
320
 
        case LDTP_CMD_INCREASE: {
321
 
                long num = 0;
322
 
                if (cctxt->req->arg_list && cctxt->req->arg_list->data)
323
 
                        num = atol (cctxt->req->arg_list->data);
324
 
                error = increase (cctxt->gui_handle->handle, num, cctxt->log_fp);
325
 
                break;
326
 
        }
327
 
        case LDTP_CMD_DECREASE: {
328
 
                long num = 0;
329
 
                if (cctxt->req->arg_list && cctxt->req->arg_list->data)
330
 
                        num = atol (cctxt->req->arg_list->data);
331
 
                error = decrease(cctxt->gui_handle->handle, num, cctxt->log_fp);
332
 
                break;
333
 
        }
334
 
        case LDTP_CMD_GETMINVALUE:
335
 
                value = get_min_value (cctxt->gui_handle->handle);
336
 
                cctxt->resp->data = g_strdup_printf ("%lf", value);
337
 
                if (cctxt->resp->data)
338
 
                        cctxt->resp->data_len = g_utf8_strlen (cctxt->resp->data, -1);
339
 
                if (value != -1)
340
 
                        error = LDTP_ERROR_SUCCESS;
341
 
                else
342
 
                        error = LDTP_ERROR_UNABLE_TO_GET_VALUE;
343
 
                break;
344
 
#ifdef ENABLE_NEWROLES
345
 
        // NOT supported by SLE10
346
 
        case LDTP_CMD_GETMININCREMENT:
347
 
                value = get_min_increment (cctxt->gui_handle->handle);
348
 
                cctxt->resp->data = g_strdup_printf ("%lf", value);
349
 
                if (cctxt->resp->data)
350
 
                        cctxt->resp->data_len = g_utf8_strlen (cctxt->resp->data, -1);
351
 
                if (value != -1)
352
 
                        error = LDTP_ERROR_SUCCESS;
353
 
                else
354
 
                        error = LDTP_ERROR_UNABLE_TO_GET_VALUE;
355
 
                break;
356
 
#endif
357
 
        case LDTP_CMD_GETMAXVALUE:
358
 
                value = get_max_value (cctxt->gui_handle->handle);
359
 
                cctxt->resp->data = g_strdup_printf ("%lf", value);
360
 
                if (cctxt->resp->data)
361
 
                        cctxt->resp->data_len = g_utf8_strlen (cctxt->resp->data, -1);
362
 
                if (value != -1)
363
 
                        error = LDTP_ERROR_SUCCESS;
364
 
                else
365
 
                        error = LDTP_ERROR_UNABLE_TO_GET_VALUE;
366
 
                break;
367
 
        case LDTP_CMD_GETOBJECTSIZE:
368
 
                cctxt->resp->data_len = 0;
369
 
                cctxt->resp->data = get_size (cctxt->gui_handle->handle, &error);
370
 
                if (cctxt->resp->data) {
371
 
                        cctxt->resp->data_len = g_utf8_strlen (cctxt->resp->data, -1);
372
 
                }
373
 
                break;
374
 
        case LDTP_CMD_VERIFYSLIDER:
375
 
                if (is_object_slider (cctxt->gui_handle->handle, cctxt->log_fp))
376
 
                        error = LDTP_ERROR_SUCCESS;
377
 
                else
378
 
                        error = LDTP_ERROR_INVALID_OBJECT_STATE;
379
 
                break;
380
 
        case LDTP_CMD_VERIFYSLIDERVERTICAL:
381
 
                if (is_slider_vertical (cctxt->gui_handle->handle))
382
 
                        error = LDTP_ERROR_SUCCESS;
383
 
                else
384
 
                        error = LDTP_ERROR_NOT_VERTICAL_SLIDER;
385
 
                break;
386
 
        case LDTP_CMD_VERIFYSLIDERHORIZONTAL:
387
 
                if (is_slider_horizontal (cctxt->gui_handle->handle))
388
 
                        error = LDTP_ERROR_SUCCESS;
389
 
                else
390
 
                        error = LDTP_ERROR_NOT_HORIZONTAL_SLIDER;
391
 
                break;
392
 
        default:
393
 
                error = LDTP_ERROR_COMMAND_NOT_IMPLEMENTED;
394
 
        }
395
 
        return error;
396
 
}