Add interactive zoom_rect.
[scilab.git] / scilab / modules / graphics / src / c / getHandleProperty / getPropertyAssignedValue.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
4  * 
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at    
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 /*------------------------------------------------------------------------*/
14 /* file: getPropertyAssignedValue.c                                       */
15 /* desc : a set of functions used to get the values which will be         */
16 /*        assigned to handles properties from the stack                   */
17 /*------------------------------------------------------------------------*/
18
19
20 #include "getPropertyAssignedValue.h"
21 #include "stack-c.h"
22 #include "sciprint.h"
23 #include "localization.h"
24 #include "MALLOC.h"
25 #include "BasicAlgos.h"
26
27 /*--------------------------------------------------------------------------*/
28 BOOL isParameterHandle( int type )
29 {
30   return ( type == sci_handles ) ;
31 }
32 /*--------------------------------------------------------------------------*/
33 BOOL isParameterDoubleMatrix( int type )
34 {
35   return ( type == sci_matrix ) ;
36 }
37 /*--------------------------------------------------------------------------*/
38 BOOL isParameterTlist( int type )
39 {
40   return ( type == sci_tlist ) ;
41 }
42 /*--------------------------------------------------------------------------*/
43 BOOL isParameterStringMatrix( int type )
44 {
45   return ( type == sci_strings ) ;
46 }
47 /*--------------------------------------------------------------------------*/
48 double getDoubleFromStack( int stackPointer )
49 {
50   return *(stk( stackPointer ));
51 }
52 /*--------------------------------------------------------------------------*/
53 double * getDoubleMatrixFromStack( int stackPointer )
54 {
55   return stk( stackPointer ) ;
56 }
57 /*--------------------------------------------------------------------------*/
58 void copyDoubleVectorFromStack( int stackPointer, double dest[], int nbElement )
59
60   doubleArrayCopy( dest, getDoubleMatrixFromStack( stackPointer ), nbElement ) ;
61 }
62 /*--------------------------------------------------------------------------*/
63 void copyDoubleVectorToIntFromStack( int stackPointer, int dest[], int nbElement )
64
65   int i ;
66   double * values = getDoubleMatrixFromStack( stackPointer ) ;
67   for ( i = 0 ; i < nbElement ; i++ )
68   {
69     dest[i] = (int) values[i] ;
70   }
71 }
72 /*--------------------------------------------------------------------------*/
73 double * createCopyDoubleVectorFromStack( int stackPointer, int nbElement )
74 {
75   double * res = MALLOC( nbElement * sizeof(double) ) ;
76   if ( res == NULL )
77   {
78     return NULL ;
79   }
80   copyDoubleVectorFromStack( stackPointer, res, nbElement ) ;
81   return res ;
82 }
83 /*--------------------------------------------------------------------------*/
84 char * getStringFromStack( int stackPointer )
85 {
86   return cstk( stackPointer ) ;
87 }
88 /*--------------------------------------------------------------------------*/
89 char ** getStringMatrixFromStack( int stackPointer )
90 {
91   /* strange but it was taken from sci_set */
92   return (char **) stackPointer ;
93 }
94 /*--------------------------------------------------------------------------*/
95 char ** createCopyStringMatrixFromStack( int stackPointer, int nbElement )
96 {
97   int i ;
98   char ** res    = MALLOC( nbElement * sizeof(char *) ) ;
99   char ** values = getStringMatrixFromStack( stackPointer ) ;
100   
101   if ( res == NULL )
102   {
103     return NULL ;
104   }
105
106   for ( i = 0 ; i < nbElement ; i++ )
107   {
108     int size =  (int)strlen( values[i] ) + 1 ;
109     res[i] = MALLOC( size * sizeof(char) ) ;
110
111     if ( res[i] == NULL )
112     {
113       /* deallocate what have been allocated */
114       int j ;
115       for ( j = 0 ; j < i ; j++ )
116       {
117         FREE( res[j] ) ;
118       }
119       FREE( res ) ;
120       return NULL ;
121     }
122
123     strcpy( res[i], values[i] ) ;
124   }
125
126   return res ;
127
128 }
129 /*--------------------------------------------------------------------------*/
130 unsigned long getHandleFromStack( int stackPointer )
131 {
132   return (unsigned long) *(hstk( stackPointer )) ;
133 }
134 /*--------------------------------------------------------------------------*/
135 unsigned long * getHandleVectorFromStack(int stackPointer)
136 {
137   return (unsigned long *) hstk(stackPointer);
138 }
139 /*--------------------------------------------------------------------------*/
140 BOOL isStringParamEqual( int stackPointer, const char * str )
141 {
142   if ( strcmp( getStringFromStack( stackPointer ), str ) == 0 )
143   {
144     return TRUE ;
145   }
146   else
147   {
148     return FALSE ;
149   }
150 }
151 /*--------------------------------------------------------------------------*/
152 /*--------------------------------------------------------------------------*/
153 int getStackListNbElement( int paramNum )
154 {
155   int nbRow        = 0 ;
156   int nbCol        = 0 ;
157   int stackPointer = 0 ;
158
159   GetRhsVar( paramNum,TYPED_LIST_DATATYPE, &nbRow, &nbCol, &stackPointer );
160
161   return nbRow - 1 ;
162
163  }
164 /*--------------------------------------------------------------------------*/
165 AssignedList * createAssignedList( int paramNum, int nbElement )
166 {
167   AssignedList * newList = NULL ;
168   int nbRow = 0 ;
169   int nbCol = 0 ;
170
171   newList = MALLOC( sizeof(AssignedList) ) ;
172
173   if ( newList == NULL )
174   {
175     return NULL ;
176   }
177
178   newList->nbElement   = nbElement + 1 ;
179   newList->curElement  = 2 ; /* begin with 1 and 1 are the names */
180   newList->paramNumber = paramNum ;
181
182   /* get the stack pointer */
183   GetRhsVar( paramNum,TYPED_LIST_DATATYPE, &nbRow, &nbCol, &(newList->stackPointer) );
184
185   /* check the size */
186   if ( nbRow != newList->nbElement || nbCol != 1 )
187   {
188     sciprint("Wrong size for tlist.\n") ;
189     return NULL ;
190   }
191   return newList ;
192 }
193 /*--------------------------------------------------------------------------*/
194 void destroyAssignedList( AssignedList * list )
195 {
196   FREE( list ) ;
197 }
198 /*--------------------------------------------------------------------------*/
199 int getAssignedListNbElement( AssignedList * list )
200 {
201   return list->nbElement - 1 ;
202 }
203 /*--------------------------------------------------------------------------*/
204 void rewindAssignedList( AssignedList * list )
205 {
206   list->curElement = 2 ;
207 }
208 /*--------------------------------------------------------------------------*/
209 BOOL isListCurrentElementDoubleMatrix( AssignedList * list )
210 {
211   return ( ElementType( list->paramNumber, list->curElement ) == 1 ) ;
212 }
213 /*--------------------------------------------------------------------------*/
214 BOOL isListCurrentElementStringMatrix( AssignedList * list )
215 {
216   return ( ElementType( list->paramNumber, list->curElement ) == 10 ) ;
217 }
218 /*--------------------------------------------------------------------------*/
219 BOOL isListCurrentElementEmptyMatrix( AssignedList * list )
220 {
221   int nbRow = 0 ;
222   int nbCol = 0 ;
223
224   if ( !isListCurrentElementDoubleMatrix( list ) )
225   {
226     /* empty matrix is a double matrix */
227     return FALSE ;
228   }
229
230   getDoubleMatrixFromList( list, list->curElement, &nbRow, &nbCol ) ;
231
232   if ( nbRow * nbCol == 0 )
233   {
234     return TRUE ;
235   }
236
237   return FALSE ;
238
239 }
240 /*--------------------------------------------------------------------------*/
241 double * getDoubleMatrixFromList( AssignedList * list, int rank, int * nbRow, int * nbCol )
242 {
243   int valueStackPointer = 0 ;
244   GetListRhsVar( list->paramNumber, rank,MATRIX_OF_DOUBLE_DATATYPE, nbRow, nbCol, &valueStackPointer );
245   
246   return getDoubleMatrixFromStack( valueStackPointer ) ;
247 }
248 /*--------------------------------------------------------------------------*/
249 char ** getStringMatrixFromList( AssignedList * list, int rank, int * nbRow, int * nbCol )
250 {
251   int valueStackPointer = 0 ;
252   GetListRhsVar( list->paramNumber, rank,MATRIX_OF_STRING_DATATYPE, nbRow, nbCol, &valueStackPointer );
253
254   return getStringMatrixFromStack( valueStackPointer ) ;
255 }
256 /*--------------------------------------------------------------------------*/
257 double * getCurrentDoubleMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
258 {
259   double * res = NULL ;
260   if ( list->curElement > list->nbElement )
261   {
262     *nbRow = 0 ;
263     *nbCol = 0 ;
264     return NULL ;
265   }
266
267   res = getDoubleMatrixFromList( list, list->curElement, nbRow, nbCol ) ;
268   list->curElement++ ;
269   return res ;
270 }
271 /*--------------------------------------------------------------------------*/
272 char ** getCurrentStringMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
273 {
274   char ** res = NULL ;
275   if ( list->curElement > list->nbElement )
276   {
277     *nbRow = 0 ;
278     *nbCol = 0 ;
279     return NULL ;
280   }
281
282   res = getStringMatrixFromList( list, list->curElement, nbRow, nbCol ) ;
283   list->curElement++ ;
284   return res ;
285
286 }
287 /*--------------------------------------------------------------------------*/
288 double * createCopyDoubleMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
289 {
290   /* get the matrix */
291   double * stackValues = getCurrentDoubleMatrixFromList( list, nbRow, nbCol ) ;
292   int nbElement = (*nbRow) * (*nbCol) ;
293
294   double * copyMatrix = NULL ;
295
296   if ( nbElement == 0 )
297   {
298     return NULL ;
299   }
300
301   /* copy */
302
303   copyMatrix = MALLOC( (*nbRow) * (*nbCol) * sizeof( double ) ) ;
304
305   if ( copyMatrix == NULL )
306   { 
307     *nbRow = -1 ;
308     *nbCol = -1 ;
309     return NULL ;
310   }
311
312   doubleArrayCopy( copyMatrix, stackValues, nbElement ) ;
313
314   return copyMatrix ;
315
316 }
317 /*--------------------------------------------------------------------------*/
318 char ** createCopyStringMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
319 {
320   /* get the matrix */
321   char ** stackValues = getCurrentStringMatrixFromList( list, nbRow, nbCol ) ;
322   int nbElement = (*nbRow) * (*nbCol) ;
323
324   if ( nbElement == 0 )
325   {
326     return NULL ;
327   }
328
329   return createStringArrayCopy( stackValues, nbElement ) ;
330 }
331 /*--------------------------------------------------------------------------*/