5742b.diff

     ** Module   : LFUAgingCache.java
     ** Abstract : LFU cache implementation which adjusts element importance by age of last access
     **
     ** Copyright (c) 2014-2021, Golden Code Development Corporation.
     ** Copyright (c) 2014-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- --------------------------------------Description----------------------------------------
     ** 001 ECF 20140922 Created initial version.
-...
     ** 004 ECF 20190327 Refactored to include more implementation-specific logic, allowing parent
     **                  class to be more generic.
     ** 005 ECF 20210519 Refactoring to adjust for changes in the class hierarchy.
     **     TJD 20220527 Support for text-metrics cache controlled by server
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
+       }
        /**
         * Retrieve the Most Frequently Used items out of cache
         * Order of result is unimportant
+        *
         * @param   maxEntries - maximum number of entries to reurn
         */
        public Map<K,V> getMFUEntries(int maxEntries)
+       {
           Map<K,V> result=new HashMap<K,V>();
           // reverse order to get MFU elements
           Iterator<Entry<K, V>> mfuElementsIterator = sorted.descendingIterator();
           while(mfuElementsIterator.hasNext())
+          {
              if (--maxEntries < 0)
                 break;
              Entry<K, V> entry=mfuElementsIterator.next();
              result.put(entry.getKey(), entry.getValue());
+          }
           return result;
+       }
        /**
         * Get the number of elements which will be expired from the cache each time it becomes full,
         * and capacity is required for a new element.
+        *

     **     SBI 20211003 Added http configuration settings for the web client.
     **     EVL 20211222 Added implementation to pass options to client driver from server via socket.
     **     EVL 20220105 Improvements for Windows specific options passing via socket for web client.
     **     TJD 20220527 Support for text-metrics cache controlled by server
     */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
           cmd.add("client:web:maxHttpIdleTimeout=" + options.get("maxHttpIdleTimeout"));
           cmd.add("client:web:maxResponseHeaderSize=" + options.get("maxResponseHeaderSize"));
           cmd.add("client:web:maxRequestHeaderSize=" + options.get("maxRequestHeaderSize"));
           cmd.add("client:text-metrics:cache-size="+options.get("clientTextMetricsCacheSize"));
           // Sets the web client embedded mode
           cmd.add("client:web:embedded=" + options.get("embedded"));

     ** Module   : WebClientBuilderOptions.java
     ** Abstract : store web client parameters read from the directory
     **
     ** Copyright (c) 2014-2021, Golden Code Development Corporation.
     ** Copyright (c) 2014-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------Description----------------------------------
     ** 001 CA  20140206 First version, extracted from ClientBuilderOptions.
-...
     **     CA  20210924 Replaced 'sticked' with 'fixed' name, for web client taskbar style.
     **     SBI 20210926 Removed code that updates jvm arguments for new client.
     **     SBI 20211003 Added http configuration settings for the web client.
     **     TJD 20220527 Support for text-metrics cache controlled by server
      */
     /*
     ** This program is free software: you can redistribute it and/or modify
-...
     import com.goldencode.p2j.cfg.*;
     import com.goldencode.p2j.net.*;
     import com.goldencode.p2j.ui.*;
     import com.goldencode.p2j.ui.client.chui.driver.*;
     import com.goldencode.p2j.web.*;
     // must be explicit to avoid abmiguity with Java
-...
           // Read if the drawing batches are cached
           boolean graphicsCached = cbo.getNode(DIRECTORY_NODE_ID, "graphicsCached", false);
           // Get client font metrics cache size from configuration
           int clientTextMetricsCacheSize = cbo.getNode(FontTable.FONT_METRICS_NODE_ID,"client-cache-size",0);
           String taskBarStyle = cbo.getNode(DIRECTORY_NODE_ID, "taskBarStyle", "fixed").trim();
           options.put("taskBarStyle", taskBarStyle);
-...
           options.put("pingPongInterval", String.valueOf(pingPongInterval));
           options.put("maxLostPings", String.valueOf(maxLostPings));
           options.put("delayBetweenPingTries", String.valueOf(delayBetweenPingTries));
           options.put("clientTextMetricsCacheSize", String.valueOf(clientTextMetricsCacheSize));
           // sets true or false if the web client embedded mode is on or off respectively
           options.put("embedded", embedded ? "true" : "false");

     ** 034 EVL 20220110 Adding support for symbolic font flag.
     ** 035 AL2 20220425 Parse and use the web text scale font specification.
     ** 036 AL2 20220430 Changed default value for webScale.
     ** 037 TJD 20220525 Support for text-metrics cache controlled by server
     */
     /*
-...
     import java.io.*;
     import java.net.*;
     import java.util.*;
     import java.util.concurrent.locks.*;
     import java.util.logging.*;
     import javax.xml.parsers.*;
     import org.w3c.dom.*;
-...
        /** The fallback font, in case the default fonts are not specified. */
        private static final String FALLBACK_DEFAULT_FONT = "System, size 10";
        /** The name of the node containing the font metrics management configuration */
        public static final String FONT_METRICS_NODE_ID = "font-metrics";
        /** A map containing the legacy font metrics. */
        private static Map<String, LegacyFontMetrics> legacyFontMetrics = new HashMap<>();
-...
        /** A map containing legacy text/font keys and legacy font width and height dimensions */
        private static Map<String, int[]> sharedLegacyTextDimensions = new HashMap<>();
        /** Runtime cache for legacy text/font keys and legacy font width and height dimensions
         * Cache entries are metrics of legacy font stored as int[2]
         * Invalid entries are stored as int[0], so client dont need to query server for these
         */
        private static LFUAgingCache<String, int[]> sharedLegacyTextMetricsCache = new LFUAgingCache<>(10);
        /** Size of a runtime cache for legacy text/font keys and legacy font width and height dimensions */
        private static int sharedLegacyTextMetricsCacheSize=0;
        private static Lock sharedLegacyTextMetricsLock = new ReentrantLock();
        /** A set containing the name of the fixed fonts. */
        private static Set<String> fixedFonts = new TreeSet<>();
-...
         */
        static int[] getLegacyTextMetrics(String text, String key)
+       {
           LegacyTextMetrics ltm = legacyTextMetrics.get(text);
           if (ltm == null)
+          {
              if (LOG.isLoggable(Level.FINE))
+             {
                 LOG.fine("Text [" + text+ "] has no legacy metrics with font [" + key + "].");
+             }
              return null;
+          }
           LegacyFontMetrics lfm = ltm.legacyMetrics.get(key);
           if (lfm == null)
+          {
              if (LOG.isLoggable(Level.FINE))
+             {
                 LOG.fine("Text [" + text+ "] has no legacy metrics with font [" + key + "].");
+             }
              return null;
+          }
           return new int[] { lfm.width, lfm.height };
           String cacheKey = buildTextMetricsKey(key,text);
           int [] textMetrics = null;
           // map based operations are fast, so lock is only at beginning
           sharedLegacyTextMetricsLock.lock();
           try
+          {
              textMetrics=sharedLegacyTextMetricsCache.get(cacheKey);
              if (textMetrics!=null)
+             {
                 return textMetrics;
+             }
              LegacyTextMetrics ltm = legacyTextMetrics.get(text);
              if (ltm == null)
+             {
                 if (LOG.isLoggable(Level.FINE))
+                {
                    LOG.fine("Text [" + text+ "] has no legacy metrics with font [" + key + "].");
+                }
                 // Store invalid metrics value, so client knows it should not query server for this
                 sharedLegacyTextMetricsCache.putIfAbsent(cacheKey, new int[0]);
                 return null;
+             }
              LegacyFontMetrics lfm = ltm.legacyMetrics.get(key);
              if (lfm == null)
+             {
                 if (LOG.isLoggable(Level.FINE))
+                {
                    LOG.fine("Text [" + text+ "] has no legacy metrics with font [" + key + "].");
+                }
                 // Store invalid metrics value, so client knows it should not query server for this
                 sharedLegacyTextMetricsCache.putIfAbsent(cacheKey, new int[0]);
                 return null;
+             }
              textMetrics = new int[] { lfm.width, lfm.height };
              sharedLegacyTextMetricsCache.putIfAbsent(cacheKey, textMetrics);
+          }
           finally
+          {
              sharedLegacyTextMetricsLock.unlock();
+          }
           return textMetrics;
+       }
        /**
         * buildTextMetricsKey - a helper method to unify TextMetrics keys creation
         * @param key - font key
         * @param text - text
         * @return textMetrics key
         */
        private static String buildTextMetricsKey(String key, String text)
+       {
           return key + "#" + text;
+       }
        /**
-...
         */
        static Map<String, int[]> readLegacyTextMetrics()
+       {
           return sharedLegacyTextDimensions;
           int currentServerCacheSize = Utils.getDirectoryNodeInt(null,
                                                                  FONT_METRICS_NODE_ID +
                                                                     "/" +
                                                                     "server-cache-size",
                                                                  -1,
                                                                  false);
           Map<String, int[]> trimmedTextDimensions = sharedLegacyTextDimensions;
           // return full legacy metrics if server cache size is undefined or set to -1
           if (currentServerCacheSize == -1)
+          {
              return sharedLegacyTextDimensions;
+          }
           else
+          {
              int clientCacheSize = Utils.getDirectoryNodeInt(null,
                                                              FONT_METRICS_NODE_ID +
                                                                 "/" +
                                                                 "client-cache-size",
 ,
                                                              false);
              sharedLegacyTextMetricsLock.lock();
              try
+             {
                 // reinitialize cache only if cache size configuration has changed in runtime
                 if (currentServerCacheSize != sharedLegacyTextMetricsCacheSize ||
                     sharedLegacyTextMetricsCache == null)
+                {
                    sharedLegacyTextMetricsCache = new LFUAgingCache<>(currentServerCacheSize);
                    sharedLegacyTextMetricsCacheSize = currentServerCacheSize;
+                }
                 // send to client the most frequently used elements
                 trimmedTextDimensions = sharedLegacyTextMetricsCache.getMFUEntries(clientCacheSize);
+             }
              finally
+             {
                 sharedLegacyTextMetricsLock.unlock();
+             }
+          }
           // send configured cache size to client
           return trimmedTextDimensions;
+       }
        /**
-...
+             {
                 String fontKey = fontEntry.getKey();
                 LegacyFontMetrics fontMx = fontEntry.getValue();
                 String textKey = fontKey + "#" + text;
                 String textKey = buildTextMetricsKey(fontKey, text);
                 dimensions.put(textKey, new int[] { fontMx.width, fontMx.height });
+             }

     **     EVL 20220516          The call to moveToTop(boolean) should be now called with explicit cast.  This
     **                           is Frame class specific method.
     **     AL2 20220524          Replaced getTempDirectory with readHtmlBrowserWhitelist.
     **     TJD 20220527          Support for text-metrics cache controlled by server
     */
     /*
-...
           // negotiate the UI theme (before requesting fonts and colors from server)
           ThemeManager.init(tc.server, cfg.getString("client", "driver", "theme", null));
           // read cache size from configuration
           // 0 means - use the same size server sends to client
           String textMetricsCacheSize=cfg.getString("client", "text-metrics", "cache-size", "0");
           int requestedTextMetricsCacheSize = 0;
           if (textMetricsCacheSize != null)
+          {
              try
+             {
                 requestedTextMetricsCacheSize = Integer.valueOf(textMetricsCacheSize);
+             }
              catch(NumberFormatException e)
+             {
+             }
+          }
           // initialize the font manager
           FontManager.init(tc.server);
           FontManager.init(tc.server, requestedTextMetricsCacheSize);
           // initialize the client side widget ID worker
           WidgetIdHelper.initWorker(new ClientIdHelper());

     ** Module   : FontManager.java
     ** Abstract : client-side font management class
     **
     ** Copyright (c) 2011-2020, Golden Code Development Corporation.
     ** Copyright (c) 2011-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------Description----------------------------------
     ** 001 SIY 20111115 Created initial version
-...
     ** 035 HC  20200416 Extended direct font control to allow to use system font names.
     ** 036 AL2 20220425 Added web text scale to font key generation.
     **                  Onyl web scaled fonts are checked to be locally installed.
     ** 037 TJD 20220525 Support for text-metrics cache controlled by server
     */
     /*
-...
     import java.util.*;
     import java.util.logging.*;
     import com.goldencode.cache.*;
     import com.goldencode.p2j.security.*;
     import com.goldencode.p2j.ui.*;
     import com.goldencode.p2j.ui.chui.*;
-...
         * @param    server
         *           The server exports.
         */
        public static void init(ServerExports server)
        public static void init(ServerExports server, int textMetricsCacheSize)
+       {
           // do not use locate() here
           WorkArea wa = local.get();
           wa.initialize(server);
           wa.initialize(server, textMetricsCacheSize);
+       }
        /**
-...
+       {
           WorkArea wa = locate();
           String tkey = getTextKey(key, text);
           int[] metrics = wa.textMetrics.get(tkey);
           if (metrics != null)
           int[] metrics = null;
           synchronized (wa.textMetrics)
+          {
              metrics = wa.textMetrics.get(tkey);
+          }
           // invalid metrics.length is 0
           if (metrics != null && metrics.length > 0)
+          {
              // found from cache, fast exit
              return metrics;
+          }
           // check server-side
           metrics = wa.server.getLegacyTextMetrics(text, key);
           // check server-side only if not in cache
           if (metrics == null)
+          {
              metrics = wa.server.getLegacyTextMetrics(text, key);
+          }
           if (metrics == null || metrics.length == 0)
+          {
              // let the driver measure the string
              FontDetails<?> fd = wa.fontCache.get(key);
-...
+          }
           // cache it
           wa.textMetrics.put(tkey, metrics);
           synchronized (wa.textMetrics)
+          {
              wa.textMetrics.put(tkey, metrics);
+          }
           return metrics;
+       }
-...
           /** Access to the client's environment.  May be <code>null</code> if not on a Windows OS. */
           private EnvironmentDaemon ed;
           /** A cache of text metrics.  0-index is the width, 1-index is the height. */
           private final Map<String, int[]> textMetrics = new HashMap<String, int[]>();
           /** A cache of text metrics.  0-index is the width, 1-index is the height.
            *  Default size will help in case server will not send anything at startup
            */
           private LRUCache<String, int[]> textMetrics = new LRUCache<String, int[]>(100);
           /** Flag to track if the work area has been initialized. */
           private boolean initialized = false;
-...
            * Initialize this work area.
+           *
            * @param    server
            * @param    configured TextMetrics cache size
            *           The server exports.
            */
           public void initialize(ServerExports server)
           public void initialize(ServerExports server, int textMetricsCacheSize)
+          {
              initialized = true;
              if (OutputManager.getDriver().isChui())
-...
                 fontCache.clear();
                 windowFontTables.clear();
                 envFontTables.clear();
                 textMetrics.clear();
                 // initialize only in GUI mode
                 this.server = server;
-...
                    this.systemFonts[i] = createFont(sysFonts[i]);
+                }
                 // pre-populate the legacy text metrics for all the fonts in the font-table
                 Map<String, int[]> legacyTextMetrics = server.readLegacyTextMetrics();
                 textMetrics.putAll(legacyTextMetrics);
                 // if client cache size is not defined by configuration option client-cache-size
                 if (textMetricsCacheSize == 0)
+                {
                    // if server sends a very set of items set it to a minimal value
                    if (legacyTextMetrics == null || legacyTextMetrics.size() < 100)
+                   {
                       textMetrics = new LRUCache<String,int[]>(100);
+                   }
                    else
+                   {
                       // if client cache is not defined in config use size of data from server
                       textMetrics = new LRUCache<String,int[]>(legacyTextMetrics.size());
+                   }
+                }
                 else
+                {
                    // if client cache size is defined in config - use it
                    textMetrics = new LRUCache<String,int[]>(textMetricsCacheSize);
+                }
                 // copy text metrics received from server into local cache
                 if (legacyTextMetrics != null)
+                {
                    for (String key:legacyTextMetrics.keySet())
+                   {
                       textMetrics.put(key, legacyTextMetrics.get(key));
+                   }
+                }
                 // the rest of the fonts are installing here
                 driver.releaseWindow();

Project

General

Profile

FWD » Core Development » User Interface