59bde999461d9393f44748b06650c413ea46fc05
[scilab.git] / scilab / modules / action_binding / src / c / dynamic_menus.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2001-2008 - ENPC  - Jean-Philippe Chancelier <jpc@cermics.enpc.fr>
4  * Copyright (C) 2004-2008 - INRIA - Serge STEER <serge.steer@inria.fr>
5  * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET
6  * Copyright (C) 2008-2009 - DIGITEO - Bruno JOFRET
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
13  *
14  */
15
16 #include <string.h>
17 #include "stack-c.h"
18 #include "MALLOC.h"
19 #include "dynamic_menus.h"
20 #include "sciprint.h"
21 #include "sciprint_full.h"
22 #include "localization.h"
23 #include "Thread_Wrapper.h"
24
25 /*--------------------------------------------------------------------------*/
26 /*
27  *  Command queue functions
28  *  This function is used to store Scilab command in a queue
29  *
30  *  PUBLIC : int StoreCommand( char *command)
31  *           int C2F(ismenu)()
32  *           int C2F(getmen)(char * btn_cmd,int * lb, int * entry)
33  */
34 /*--------------------------------------------------------------------------*/
35
36 #ifdef _MSC_VER
37         #define IMPORT_SIGNAL __declspec(dllimport)
38 #else
39         #define IMPORT_SIGNAL extern
40 #endif
41
42 typedef struct commandRec
43 {
44   char              *command;           /* command info one string two integers */
45   int               flag; /* 1 if the command execution cannot be interrupted */
46   struct commandRec *next;
47 } CommandRec;
48 /*--------------------------------------------------------------------------*/
49
50 /*
51 ** Extern Signal to say we git a StoreCommand.
52 */
53 IMPORT_SIGNAL __threadSignal LaunchScilab;
54
55 /*--------------------------------------------------------------------------*/
56 static CommandRec *commandQueue = NULL;
57 static __threadLock commandQueueSingleAccess = __StaticInitLock;
58 /*--------------------------------------------------------------------------*/
59 int StoreCommand (char *command)
60 {
61   return (StoreCommandWithFlag (command, 0));
62 }
63
64 /*--------------------------------------------------------------------------*/
65 int StorePrioritaryCommand (char *command)
66 {
67   return (StorePrioritaryCommandWithFlag (command, 0));
68 }
69
70 /*--------------------------------------------------------------------------*/
71 /*
72  * try to execute a command or add it to the end of command queue
73  * flag = 0 : the command is not shown in scilab window
74  * flag = 1 : the command is shown in scilab window (if at prompt) and executed sequentially
75  */
76 /*--------------------------------------------------------------------------*/
77 int StoreCommandWithFlag (char *command,int flag)
78 {
79   CommandRec *p, *q, *r;
80
81         p = (CommandRec *) MALLOC (sizeof (CommandRec));
82         if (p == (CommandRec *) 0)
83           {
84             sciprint(_("%s: No more memory.\n"),"send_command");
85             return (1);
86           }
87         p->flag = flag;
88         p->command = (char *) MALLOC ((strlen (command) + 1) * sizeof (char));
89         if (p->command == (char *) 0)
90           {
91             FREE(p);
92             sciprint(_("%s: No more memory.\n"),"send_command");
93             return (1);
94           }
95         strcpy (p->command, command);
96         p->next = NULL;
97         __Lock(&commandQueueSingleAccess);
98         if (commandQueue == NULL)
99         {
100                 commandQueue = p;
101         }
102         else
103         {
104             q = commandQueue;
105             while ((r = q->next) != NULL)
106                         {
107                                 q = r;
108                         }
109             q->next = p;
110         }
111         __UnLock(&commandQueueSingleAccess);
112         //**
113         //** We have something to do, awake Scilab !!!!!!
114         //**
115         __Signal(&LaunchScilab);
116         return (0);
117 }
118
119 /*--------------------------------------------------------------------------*/
120 /*
121  * try to execute a command or add it to the _BEGINNING_ of command queue
122  * flag = 0 : the command is not shown in scilab window
123  * flag = 1 : the command is shown in scilab window (if at prompt) and executed sequentially
124  */
125 /*--------------------------------------------------------------------------*/
126 int StorePrioritaryCommandWithFlag (char *command,int flag)
127 {
128   CommandRec *p = NULL;
129
130         p = (CommandRec *) MALLOC (sizeof (CommandRec));
131         if (p == (CommandRec *) 0)
132           {
133             sciprint(_("%s: No more memory.\n"),"send_command");
134             return (1);
135           }
136         p->flag = flag;
137         p->command = (char *) MALLOC ((strlen (command) + 1) * sizeof (char));
138         if (p->command == (char *) 0)
139           {
140             FREE(p);
141             sciprint(_("%s: No more memory.\n"),"send_command");
142             return (1);
143           }
144         strcpy (p->command, command);
145         p->next = NULL;
146         __Lock(&commandQueueSingleAccess);
147         if (commandQueue == NULL)
148         {
149                 commandQueue = p;
150         }
151         else
152         {
153           p->next = commandQueue;
154             commandQueue = p;
155         }
156         __UnLock(&commandQueueSingleAccess);
157         //**
158         //** We have something to do, awake Scilab !!!!!!
159         //**
160         __Signal(&LaunchScilab);
161         return (0);
162 }
163 /*--------------------------------------------------------------------------*/
164 int isEmptyCommandQueue(void)
165 {
166         int isEmpty = 0;
167         __Lock(&commandQueueSingleAccess);
168         if (commandQueue != NULL)
169         {
170                 isEmpty = 0;
171         }
172         else
173         {
174                 isEmpty = 1;
175         }
176         __UnLock(&commandQueueSingleAccess);
177         return isEmpty;
178 }
179 /*--------------------------------------------------------------------------*/
180 /*
181  * Gets info on the first queue element
182  * and remove it from the queue
183  */
184 /*--------------------------------------------------------------------------*/
185
186 int GetCommand ( char *str)
187 {
188         int flag = 0;
189         __Lock(&commandQueueSingleAccess);
190         if (commandQueue != NULL)
191         {
192
193                 CommandRec *p;
194
195
196                 p = commandQueue;
197                 strcpy (str, p->command);
198                 flag=p->flag;
199
200                 commandQueue = p->next;
201                 FREE (p->command);
202                 FREE (p);
203                 if (C2F(iop).ddt==-1) {
204                         if (flag==0) { sciprint_full(_("Unqueuing %s - No option.\n"),str); }
205                         else         { sciprint_full(_("Unqueuing %s - seq.\n"),str); }
206                 }
207
208         }
209         __UnLock(&commandQueueSingleAccess);
210
211         return flag;
212 }
213
214 int ismenu(void)
215 {
216   /* Do not manage commands while compiling scilab function */
217         BOOL commandQueueEmpty;
218         __Lock(&commandQueueSingleAccess);
219         commandQueueEmpty = (commandQueue == NULL);
220         __UnLock(&commandQueueSingleAccess);
221   if ( commandQueueEmpty || (C2F(com).comp[0] != 0))
222         {
223     return(0) ;
224         }
225   else
226         {
227     return(1);
228         }
229 }
230
231 /*--------------------------------------------------------------------------*/
232 /*
233  * menu/button info for Scilab
234  */
235 /*--------------------------------------------------------------------------*/
236 int C2F(getmen)(char * btn_cmd,int * lb, int * entry)
237 {
238   int flag;
239   if (ismenu()==1)
240     {
241       flag=GetCommand(btn_cmd);
242       *lb=(int) strlen(btn_cmd);
243       *entry=0;  /* This parameter entry seems to be unused. Probably a very old thing... */
244     }
245   else
246     {
247       flag=0;
248       *lb =0;
249       *entry=0;  /* This parameter entry seems to be unused. Probably a very old thing... */
250     }
251   return flag;
252 }
253 /*--------------------------------------------------------------------------*/