GUI module ported to api_scilab. test_run("gui")
[scilab.git] / scilab / modules / gui / sci_gateway / c / sci_helpbrowser.c
index 56c2a51..c1dc76e 100644 (file)
@@ -1,17 +1,17 @@
 /*
-* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-* Copyright (C) 2008 - INRIA - Vincent COUVERT
-*
-* This file must be used under the terms of the CeCILL.
-* This source file is licensed as described in the file COPYING, which
-* you should have received as part of this distribution.  The terms
-* are also available at
-* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-*
-*/
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2008 - INRIA - Vincent COUVERT
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallHelpBrowser.h"
 #include "Scierror.h"
@@ -24,62 +24,93 @@ static BOOL loadedDep = FALSE;
 /*--------------------------------------------------------------------------*/
 int sci_helpbrowser(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0;
-    char **keywordAdr = NULL;
+    SciErr sciErr;
 
-    int nbRowHelp = 0, nbColHelp = 0;
-    char **helpAdr = NULL;
-    char **languageAdr = NULL;
-    int fullTextAdr = 0;
+    int* piAddrhelpAdr      = NULL;
+    int* piAddrkeywordAdr   = NULL;
+    int* piAddrfullTextAdr  = NULL;
+    int* fullTextAdr        = NULL;
 
-    CheckRhs(2, 4);
-    CheckLhs(0, 1);
+    int nbRow = 0;
+    int nbCol = 0;
+    char** keywordAdr = NULL;
+
+    int nbRowHelp       = 0;
+    int nbColHelp       = 0;
+    char** helpAdr      = NULL;
+    char** languageAdr  = NULL;
+
+    CheckInputArgument(pvApiCtx, 2, 4);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* We load SciNotes when calling javahelp because we have no way to know
-    * to load it when using Javahelp because it can call SciNotes directly */
+     * to load it when using Javahelp because it can call SciNotes directly */
     if (!loadedDep)
     {
         loadOnUseClassPath("SciNotes");
         loadedDep = TRUE;
     }
 
-    if (VarType(1) == sci_strings)
+    if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowHelp, &nbColHelp, &helpAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhelpAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrhelpAdr, &nbRowHelp, &nbColHelp, &helpAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
+    }
+    else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
+    {
+        helpAdr = NULL; /* No toolboxes installed */
     }
     else
     {
-        if (VarType(1) == sci_matrix)
+        Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
+        return FALSE;
+    }
+
+    if (nbInputArgument(pvApiCtx) == 2)
+    {
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            if (nbRow * nbCol == 0)
+            int* piAddrlanguageAdr = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlanguageAdr);
+            if (sciErr.iErr)
             {
-                helpAdr = NULL; /* No toolboxes installed */
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                printError(&sciErr, 0);
+                return 1;
             }
-            else
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
             {
-                Scierror(999, _("%s: Wrong size for input argument #%d: Matrix of strings expected.\n"), fname, 1);
-                return FALSE;
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
             }
-        }
-        else
-        {
-            Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
-            return FALSE;
-        }
-    }
 
-    if (Rhs == 2)
-    {
-        if (VarType(2) == sci_strings)
-        {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &languageAdr);
-            if (nbRow * nbCol != 1)
+            if (nbRow*nbCol != 1)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(languageAdr, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
             }
@@ -88,35 +119,55 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
             return FALSE;
         }
 
-        if (helpAdr == NULL) /* No toolboxes loaded */
-        {
-            launchHelpBrowser(NULL, nbRowHelp * nbColHelp, languageAdr[0]);
-        }
-        else
+        launchHelpBrowser(helpAdr, nbRowHelp * nbColHelp, languageAdr[0]);
+
+        if (helpAdr)
         {
-            launchHelpBrowser(helpAdr, nbRowHelp * nbColHelp, languageAdr[0]);
-            freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+            freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
         }
-        freeArrayOfString(languageAdr, nbRow * nbCol);
+        freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
     }
-    else if (Rhs == 4)
+    else if (nbInputArgument(pvApiCtx) == 4)
     {
-        if (VarType(2) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &keywordAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrkeywordAdr);
+            if (sciErr.iErr)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrkeywordAdr, &nbRow, &nbCol, &keywordAdr))
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(keywordAdr, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, keywordAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
             }
@@ -125,23 +176,47 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
             return FALSE;
         }
 
-        if (VarType(3) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &languageAdr);
-            if (nbRow * nbCol != 1)
+            int* piAddrlanguageAdr = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlanguageAdr);
+            if (sciErr.iErr)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(keywordAdr, 1);
-                freeArrayOfString(languageAdr, nbRow * nbCol);
+                freeAllocatedSingleString(*keywordAdr);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
                 return FALSE;
             }
@@ -150,24 +225,51 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
-            freeArrayOfString(keywordAdr, 1);
+            freeAllocatedSingleString(*keywordAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
             return FALSE;
         }
 
-        if (VarType(4) == sci_boolean)
+        if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
         {
-            GetRhsVar(4, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &fullTextAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrfullTextAdr);
+            if (sciErr.iErr)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(keywordAdr, 1);
-                freeArrayOfString(languageAdr, 1);
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedSingleString(*languageAdr);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of boolean at position 4.
+            sciErr = getMatrixOfBoolean(pvApiCtx, piAddrfullTextAdr, &nbRow, &nbCol, &fullTextAdr);
+            if (sciErr.iErr)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedSingleString(*languageAdr);
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 4);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedSingleString(*languageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
                 return FALSE;
             }
@@ -176,28 +278,23 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
-            freeArrayOfString(keywordAdr, 1);
-            freeArrayOfString(languageAdr, 1);
+            freeAllocatedSingleString(*keywordAdr);
+            freeAllocatedSingleString(*languageAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
             return FALSE;
         }
 
-        if (helpAdr == NULL) /* No toolboxes loaded */
-        {
-            searchKeyword(NULL, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *istk(fullTextAdr) == 1);
-        }
-        else
+        searchKeyword(helpAdr, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *fullTextAdr == 1);
+
+        if (helpAdr)
         {
-            searchKeyword(helpAdr, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *istk(fullTextAdr) == 1);
-            if (helpAdr)
-            {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
-            }
+            freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
         }
-        freeArrayOfString(keywordAdr, 1);
-        freeArrayOfString(languageAdr, 1);
+
+        freeAllocatedSingleString(*keywordAdr);
+        freeAllocatedSingleString(*languageAdr);
     }
     else
     {
@@ -205,11 +302,8 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         return FALSE;
     }
 
-    LhsVar(1) = 0;
-
-    PutLhsVar();
-
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return TRUE;
-
 }
 /*--------------------------------------------------------------------------*/