GUI module ported to api_scilab. test_run("gui")
[scilab.git] / scilab / modules / gui / sci_gateway / c / sci_messagebox.c
index 5c902b6..94d8d48 100644 (file)
@@ -11,7 +11,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_messagebox(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrmessageAdr       = NULL;
+    int* piAddrtitleAdr         = NULL;
+    int* piAddriconAdr          = NULL;
+    int* piAddrbuttonsTextAdr   = NULL;
+    int* piAddrmodalOptionAdr   = NULL;
+    double* buttonNumberAdr     = NULL;
+
     int messageBoxID = 0;
 
     /* Used to read input arguments */
@@ -29,23 +38,34 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     int nbRowButtons = 0, nbColButtons = 0;
     int nbRowMessage = 0, nbColMessage = 0;
 
-    char **buttonsTextAdr = 0;
-    char **messageAdr = 0;
-    char **titleAdr = 0;
-    char **modalOptionAdr = 0;
-    char **iconAdr = 0;
+    char **buttonsTextAdr   = 0;
+    char **messageAdr       = 0;
+    char **titleAdr         = 0;
+    char **modalOptionAdr   = 0;
+    char **iconAdr          = 0;
 
     /* Used to write output argument */
-    int buttonNumberAdr = 0;
     int buttonNumber = 0;
 
-    CheckRhs(1, 5);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 5);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* Message to be displayed */
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
     }
     else
     {
@@ -54,12 +74,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Title to be displayed */
-    if (Rhs >= 2)
+    if (nbInputArgument(pvApiCtx) >= 2)
     {
-        if (VarType(2) == sci_strings)
+        if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &titleAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrtitleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrtitleAdr, &nbRow, &nbCol, &titleAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
@@ -79,12 +112,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Icon to be displayed */
-    if (Rhs >= 3)
+    if (nbInputArgument(pvApiCtx) >= 3)
     {
-        if (VarType(3) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &iconAdr);
-            if (nbRow * nbCol == 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddriconAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddriconAdr, &nbRow, &nbCol, &iconAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol == 1)
             {
                 /* The icon argument can be used to give the modal option or the buttons names */
                 if (isModalOption(iconAdr[0]))
@@ -107,7 +153,6 @@ int sci_messagebox(char *fname, unsigned long fname_len)
                 nbColButtons = nbCol;
                 iconAdr = NULL;
             }
-
         }
         else
         {
@@ -117,12 +162,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Buttons names */
-    if (Rhs >= 4)
+    if (nbInputArgument(pvApiCtx) >= 4)
     {
-        if (VarType(4) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 4, sci_strings)))
         {
-            GetRhsVar(4, MATRIX_OF_STRING_DATATYPE, &nbRowButtons, &nbColButtons, &buttonsTextAdr);
-            if (nbRow * nbCol == 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrbuttonsTextAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 4.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonsTextAdr, &nbRowButtons, &nbColButtons, &buttonsTextAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 4);
+                return 1;
+            }
+
+            if (nbRow*nbCol == 1)
             {
                 /* The buttons names argument can be used to give the modal option */
                 if (isModalOption(buttonsTextAdr[0]))
@@ -140,12 +198,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Modal option */
-    if (Rhs == 5)
+    if (nbInputArgument(pvApiCtx) == 5)
     {
-        if (VarType(5) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 5, sci_strings)))
         {
-            GetRhsVar(5, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &modalOptionAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrmodalOptionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 5.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmodalOptionAdr, &nbRow, &nbCol, &modalOptionAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 5);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 5);
                 return FALSE;
@@ -162,11 +233,13 @@ int sci_messagebox(char *fname, unsigned long fname_len)
 
     /* Message */
     setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbColMessage * nbRowMessage);
+    freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
 
     /* Title */
     if (titleAdr != NULL)
     {
         setMessageBoxTitle(messageBoxID, titleAdr[0]);
+        freeAllocatedMatrixOfString(nbRow, nbCol, titleAdr);
     }
     else
     {
@@ -177,18 +250,21 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     if (iconAdr != NULL)
     {
         setMessageBoxIcon(messageBoxID, iconAdr[0]);
+        freeAllocatedMatrixOfString(nbRow, nbCol, iconAdr);
     }
 
     /* Buttons */
     if (buttonsTextAdr != NULL)
     {
         setMessageBoxButtonsLabels(messageBoxID, buttonsTextAdr, nbColButtons * nbRowButtons);
+        freeAllocatedMatrixOfString(nbRowButtons, nbColButtons, buttonsTextAdr);
     }
 
     /* Modal ? */
     if (modalOptionAdr != NULL)
     {
         setMessageBoxModal(messageBoxID, !stricmp(modalOptionAdr[0], "modal"));
+        freeAllocatedMatrixOfString(nbRow, nbCol, modalOptionAdr);
     }
     else
     {
@@ -199,25 +275,32 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     messageBoxDisplayAndWait(messageBoxID);
 
     /* Return the index of the button selected */
-
-    if (Lhs == 1)
+    if (nbOutputArgument(pvApiCtx) == 1)
     {
         /* Read the user answer */
         buttonNumber = getMessageBoxSelectedButton(messageBoxID);
 
         nbRow = 1;
         nbCol = 1;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &buttonNumberAdr);
-        *stk(buttonNumberAdr) = buttonNumber;
 
-        LhsVar(1) = Rhs + 1;
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &buttonNumberAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        buttonNumberAdr[0] = buttonNumber;
+
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     }
     else
     {
-        LhsVar(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
     }
 
-    PutLhsVar();
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/