4077.patch

              </action>
           </rule>
           <rule>type == prog.kw_not_embeded and
                 parent.type == prog.kw_openmime
              <action>createJavaAst(java.bool_true, "false", closestPeerId)</action>
           </rule>
           <rule>type == prog.kw_del_s_c and
                 parent.type == prog.kw_openmime
              <action>createJavaAst(java.bool_true, "true", closestPeerId, 0)</action>
           </rule>
           <rule>type == prog.create_timer and parent.type == prog.statement
              <action>
                 createPeerAst(java.static_method_call, "PSTimer.create", closestPeerId)

           KW_DEL_NODE;
           KW_DEL_PROC;
           KW_DEL_R_L;
           KW_DEL_S_C; // FWD extension
           KW_DEL_S_R;
           KW_DEL_S_RS;
           KW_DEL_WORD;
-...
           KW_EDIT_TAB;
           KW_EH_FL;    // FWD extension, not real 4GL!
           KW_EH_SR;    // FWD extension, not real 4GL!
           KW_NOT_EMBEDED;  // FWD extension
           KW_EMPTY;
           KW_EMPTY_DS;
           KW_EMPTY_SN;
-...
           attrsAndMethods.put( KW_DEL_LINE, METH_LOGICAL );
           attrsAndMethods.put( KW_DEL_NODE, METH_LOGICAL );
           attrsAndMethods.put( KW_DEL_R_L , METH_LOGICAL );
           attrsAndMethods.put( KW_DEL_S_C , ATTR_LOGICAL ); // FWD extension
           attrsAndMethods.put( KW_DEL_S_R , METH_LOGICAL );
           attrsAndMethods.put( KW_DEL_S_RS, METH_LOGICAL );
           attrsAndMethods.put( KW_DELETE  , METH_LOGICAL );
-...
           attrsAndMethods.put( KW_EDIT_UND, METH_LOGICAL );
           attrsAndMethods.put( KW_EH_FL,    ATTR_LOGICAL ); // FWD extension, not real 4GL
           attrsAndMethods.put( KW_EH_SR,    ATTR_LOGICAL ); // FWD extension, not real 4GL
           attrsAndMethods.put( KW_NOT_EMBEDED, ATTR_LOGICAL ); // FWD extension
           attrsAndMethods.put( KW_EMB_FILE, METH_LOGICAL ); // FWD extension, not real 4GL
           attrsAndMethods.put( KW_EMB_URL,  METH_LOGICAL ); // FWD extension, not real 4GL
           attrsAndMethods.put( KW_EMPTY   , ATTR_LOGICAL );
-...
     /**
      * Matches the FWD-extension language statement <code>OPEN-MIME-RESOURCE</code> and a mandatory
      * pair of resource mime type character and its url character expression.
      * pair of resource mime type character and its url character expression. If an optional
      * <code>DELETE-SOURCE-CONTENT</code> is present, then it forces to delete the original input file
      * when the transfer is complete.
      */
     open_mime_resource_stmt
+       :
           KW_OPENMIME^ expr expr (expr)? stmt_term
           KW_OPENMIME^ expr expr
           ( options { generateAmbigWarnings = false; }
+             :
              KW_NOT_EMBEDED
           )?
+          (
              options { generateAmbigWarnings = false; }
+             :
              KW_DEL_S_C
+          )
           stmt_term
+       ;
     /**
-...
              new Keyword("delete-result-list-entry"       ,  0, KW_DEL_R_L , false),
              new Keyword("delete-selected-row"            ,  0, KW_DEL_S_R , false),
              new Keyword("delete-selected-rows"           ,  0, KW_DEL_S_RS, false),
              new Keyword("delete-source-content"          ,  0, KW_DEL_S_C , false),  // FWD extension
              new Keyword("delete-word"                    ,  0, KW_DEL_WORD, false),  // missing in keyword index, found in prog handbook as a key function
              new Keyword("descending"                     ,  4, KW_DESCEND , true ),  // handles "separate keyword" desc too
              new Keyword("description"                    ,  0, KW_DESCR   , false),  // missing in keyword index, found in customer code
-...
              new Keyword("else"                           ,  0, KW_ELSE    , true ),
              new Keyword("embed-image-by-file"            ,  0, KW_EMB_FILE, false),  // FWD extension, not a real 4GL keyword
              new Keyword("embed-image-by-url"             ,  0, KW_EMB_URL , false),  // FWD extension, not a real 4GL keyword
              new Keyword("not-embeded-content"            ,  0, KW_NOT_EMBEDED, false),  // FWD extension
              new Keyword("empty"                          ,  0, KW_EMPTY   , false),
              new Keyword("empty-dataset"                  ,  0, KW_EMPTY_DS, false),  // missing from keyword index and UNTESTED at this time
              new Keyword("empty-selection"                ,  0, KW_EMPTY_SN, false),  // missing in keyword index, found elsewhere in lang ref

        /**
         * Opens the specified resource in a browser's window.
+        *
         * @param    deleteContent
         *           Indicates if the source content will be deleted after the document is loaded by
         *           the client.
         * @param    mimeType
         *           The resource mime type.
         * @param    path
-...
         * @param    embedded
         *           The document is embedded in the template document.
         */
        public void openMimeResource(String mimeType, String path, boolean embedded);
        public void openMimeResource(boolean deletedContent,
                                     String  mimeType,
                                     String  path,
                                     boolean embedded);
        /**
         * Opens the specified file resource in a browser's window.
+        *
         * @param    deleteContent
         *           Indicates if the source content will be deleted after the document is loaded by
         *           the client.
         * @param    filePath
         *           The file system path on the legacy system or the host system. If the legacy system
         *           path is given, then it is resolved to the host system path.
-...
         * @param    preferredMimeTypes
         *           The preferred resource mime types.
         */
        public void openMimeResource(String filePath, boolean embedded, List<String> preferredMimeTypes);
        public void openMimeResource(boolean      deletedContent,
                                     String       filePath,
                                     boolean      embedded,
                                     List<String> preferredMimeTypes);
        /**
         * Set an attribute for a widget implemented at the driver level.  These are custom attributes

src/com/goldencode/p2j/ui/chui/ThinClient.java 2019-11-01 08:29:28 +0000
23021	23021	/**
23022	23022	* Opens the specified resource in a browser's window.
23023	23023	*
	23024	* @param deleteContent
	23025	* Indicates if the source content will be deleted after the document is loaded by
	23026	* the client.
23024	23027	* @param mimeType
23025	23028	* The resource mime type.
23026	23029	* @param urlString
...	...
23029	23032	* The document is embedded in the template document.
23030	23033	*/
23031	23034	@Override
23032		public void openMimeResource(String mimeType, String urlString, boolean embedded)
	23035	public void openMimeResource(boolean deleteContent,
	23036	String mimeType,
	23037	String urlString,
	23038	boolean embedded)
23033	23039	{
23034	23040	urlString = UiUtils.resolveResourceUrl(urlString);
23035	23041	try
23036	23042	{
23037		tk.getInstanceDriver().openMimeResource(mimeType, urlString, embedded);
	23043	tk.getInstanceDriver().openMimeResource(deleteContent, mimeType, urlString, embedded);
23038	23044	}
23039	23045	catch (MalformedURLException e)
23040	23046	{
...	...
23045	23051	/**
23046	23052	* Opens the specified file resource in a browser's window.
23047	23053	*
	23054	* @param deleteContent
	23055	* Indicates if the source content will be deleted after the document is loaded by
	23056	* the client.
23048	23057	* @param filePath
23049	23058	* The file system path on the legacy system or the host system. If the legacy system
23050	23059	* path is given, then it is resolved to the host system path.
...	...
23053	23062	* @param preferredMimeTypes
23054	23063	* The preferred resource mime types.
23055	23064	*/
23056		public void openMimeResource(String filePath, boolean embedded, List<String> preferredMimeTypes)
	23065	public void openMimeResource(boolean deleteContent,
	23066	String filePath,
	23067	boolean embedded,
	23068	List<String> preferredMimeTypes)
23057	23069	{
23058	23070	// getting FSD instance
23059	23071	FileSystemDaemon fsd = getFileSystemDaemon();
...	...
23070	23082
23071	23083	if (mimeType != null && preferredMimeTypes.contains(mimeType))
23072	23084	{
23073		openMimeResource(mimeType, "file:///" + fName, embedded);
	23085	openMimeResource(deleteContent, mimeType, "file:///" + fName, embedded);
23074	23086	}
23075	23087	else
23076	23088	{
23077	23089	mimeType = preferredMimeTypes.get(0); // takes the default mime type
23078	23090
23079		openMimeResource(mimeType, "file:///" + fName, embedded);
	23091	openMimeResource(deleteContent, mimeType, "file:///" + fName, embedded);
23080	23092	}
23081	23093	}
23082	23094	}

        /**
         * Opens the specified resource in a browser's window.
+        *
         * @param    deleteContent
         *           Indicates if the source content will be deleted after the document is loaded by
         *           the client.
         * @param    mimeType
         *           The resource mime type.
         * @param    urlString
-...
         * @throws   MalformedURLException
         *           If the string presentation of the target resource url is malformed.
         */
        public default void openMimeResource(String mimeType, String urlString, boolean embedded)
        public default void openMimeResource(boolean deleteContent,
                                             String  mimeType,
                                             String  urlString,
                                             boolean embedded)
        throws MalformedURLException
+       {
        // do nothing

                 consumer.accept(os);
+             }
              openMimeResource(format.getMimeType(), outFile.toURI().normalize().toASCIIString(), true);
              openMimeResource(false,
                               format.getMimeType(),
                               outFile.toURI().normalize().toASCIIString(),
                               true);
+          }
           catch (IOException e)
+          {
-...
        /**
         * Opens the specified resource in a browser's window.
+        *
         * @param    deleteContent
         *           Indicates if the source content will be deleted after the document is loaded by
         *           the client.
         * @param    mimeType
         *           The resource mime type.
         * @param    urlString
-...
         *           If the string presentation of the target resource url is malformed.
         */
        @Override
        public void openMimeResource(String mimeType, String urlString, boolean embedded)
        public void openMimeResource(boolean deleteContent,
                                     String  mimeType,
                                     String  urlString,
                                     boolean embedded)
        throws MalformedURLException
+       {
           // test that urlString is well-formed.
-...
+          {
              throw new MalformedURLException(ex.getMessage());
+          }
           // set file stamp
           long current = System.currentTimeMillis();
           File sourceContent = Paths.get(uri).toFile();
           if (!sourceContent.setLastModified(current))
+          {
              current = sourceContent.lastModified();
+          }
           if (embedded)
+          {
-...
+          {
              throw new RuntimeException(ex);
+          }
           long elapsed = 0;
           long start = System.currentTimeMillis();
           while(sourceContent.lastModified() == current)
+          {
              try
+             {
                 Thread.currentThread().sleep(1000);
+             }
              catch (InterruptedException e)
+             {
+             }
              elapsed = System.currentTimeMillis() - start;
              if (elapsed > 60 * 1000)
+             {
                 break;
+             }
+          }
           if (deleteContent)
+          {
              sourceContent.delete();
+          }
+       }
        /**

     import java.util.*;
     import com.goldencode.p2j.ui.client.driver.*;
     import org.eclipse.jetty.server.*;
     import org.eclipse.jetty.util.resource.*;
-...
        /**
         * Opens the specified resource in a browser's window.
+        *
         * @param    deleteContent
         *           Indicates if the source content will be deleted after the document is loaded by
         *           the client.
         * @param    mimeType
         *           The resource mime type.
         * @param    urlString
-...
         *           For other IO errors during file operations.
         */
        @Override
        public void openMimeResource(String mimeType, String urlString, boolean embedded)
        public void openMimeResource(boolean deleteContent,
                                     String  mimeType,
                                     String  urlString,
                                     boolean embedded)
        throws MalformedURLException
+       {
           // test that urlString is well-formed.
-...
+             {
                 local = true;
                 id = resolveResourceId(mimeType, url);
                 id = resolveResourceId(deleteContent, mimeType, url);
+             }
+          }
-...
        /**
         * Resolve the document ID used to retrieve the specified resource.
+        *
         * @param    deleteContent
         *           Indicates if the source content will be deleted after the document is loaded by
         *           the client.
         * @param    mimeType
         *           The resource mime type.
         * @param    url
         *           The resource URL - must be a local resource.
+        *
         * @throws   MalformedURLException
         *           If the string presentation of the target resource url is malformed.
         */
        String resolveResourceId(String mimeType, URL url)
        String resolveResourceId(boolean deleteContent, String mimeType, URL url)
        throws MalformedURLException
+       {
           final File temporaryFile;
           try
           final File resourceFile;
           if (deleteContent)
+          {
              temporaryFile = File.createTempFile("openMimeResource",
                                                  null,
                                                  new File(tmpDir));
              try(InputStream input = url.openStream();
                  FileOutputStream output = new FileOutputStream(temporaryFile))
+             {
                 ByteStreams.copy(input, output);
              try
+             {
                 resourceFile = Paths.get(url.toURI()).toFile();
+             }
              catch (URISyntaxException ex)
+             {
                 throw new MalformedURLException(ex.getMessage());
+             }
+          }
           catch (IOException ex)
           else
+          {
              throw new RuntimeException(ex);
              try
+             {
                 resourceFile = File.createTempFile("openMimeResource",
                                                     null,
                                                     new File(tmpDir));
                 try(InputStream input = url.openStream();
                     FileOutputStream output = new FileOutputStream(resourceFile))
+                {
                    ByteStreams.copy(input, output);
+                }
+             }
              catch (IOException ex)
+             {
                 throw new RuntimeException(ex);
+             }
+          }
           Consumer<OutputStream> consumer = output ->
+          {
              try(FileInputStream input = new FileInputStream(temporaryFile))
              try(FileInputStream input = new FileInputStream(resourceFile))
+             {
                 ByteStreams.copy(input, output);
+             }
-...
+             }
           };
           Runnable finalizer = () -> { temporaryFile.delete(); };
           Runnable finalizer = () -> { resourceFile.delete(); };
           UUID uuid = UUID.randomUUID();
           DocumentOutput docOut = new DocumentOutput(consumer,

     import com.goldencode.p2j.ui.chui.ThinClient;
     import com.goldencode.p2j.ui.client.*;
     import com.goldencode.p2j.util.*;
     import org.eclipse.jetty.http.*;
     import org.eclipse.jetty.server.*;
     import org.eclipse.jetty.server.handler.*;
-...
                 local = true;
                 ThinClient tc = ThinClient.getInstance();
                 GuiWebDriver gd = (GuiWebDriver) tc.getOutputManager().getInstanceDriver();
                 id = gd.resolveResourceId(mimeType, url);
                 try
+                {
                    id = gd.resolveResourceId(false, mimeType, url);
+                }
                 catch (MalformedURLException ex)
+                {
                    ex.printStackTrace();
                    return false;
+                }
+             }
+          }

Project

General

Profile

FWD » Core Development » User Interface