Kirill Grouchnikov's Blog

November 2005 Archives

Proposal for uniform support of third-party components in custom look-and-feels

• the XML descriptor name
• the main tag name (may be it's not needed really, but serves as a fault-protection mechanism)
• the name of the tag that contains the fully-qualified class name of the plugin class.

• initialize and reset - should be called by the main LookAndFeel class on initialization and theme switch.
• getUiDelegates - returns a collection of all UI delegates for custom components. Can also return UI delegate for core Swing component, effectively overriding the UI delegate of the LAF
• getFonts - returns font settings for custom components. The same as above - can override core settings for core Swing components
• getDefaults - returns other settings for custom components. Same as above.

1. XML descriptor.
2. Class that implements LafPlugin interface.
3. UI delegate for each custom component.

<target name="jar-bin" description="create runtime jar">
  <delete file="${substance.drop.dir}/substance.jar" />
  <unjar src="${substance.drop.dir}/laf-plugin.jar" dest="${substance.output.dir}/"/>
  <jar compress="true" destfile="${substance.drop.dir}/substance.jar" 
        manifest="${substance.src.dir}/META-INF/MANIFEST.MF">
    <fileset dir="${substance.output.dir}/" excludes="test/**" />
    <fileset dir="${module.substance.basedir}/" includes="resources/**" />
  </jar>
</target>

Crash course in writing code

public class Developer {
   public void writeCode(AssignmentDetails details) {
      Document designDocument = details.getDesignDocument();

      // see if it was done already somewhere in the project
      if (details.isEnhancement()) {
         int myExperience = this.getExperience(Calendar.YEAR);
         if (myExperience <= 2) {
            // Can safely ignore the design requirements. If they are
            // so clever, why don't they write code anymore?
            designDocument.ignore();
            // Time to reinvent the wheel. Surely the guys before me
            // didn't know what they were doing (those "gurus"). It
            // will take me half the time with zero bugs
            details.setClosingDate(Calendar.getCurrent().add(Calendar.DAY, 2));
            // Like i need to see what's out there
            Internet.getDefaultBrowser().close();
            while (true) {
               try {
                  System.hang();
               }
               catch (InterruptedException exc) {
                  System.out.println("Will be ready in a few days");
               }
            }
         }
         else {
            if (myExperience <= 5) {
               // Time to copy-paste. If I change the existing function or
               // refactor it, I'll have to run tons of backwards-compatibility
               // tests. 
               Set<Method> methodsToCopy = details.getBase().getImplementation();
               Package newPackage = this.getProject().createNewPackage(
                   details.getBase().getPackage().getName() + ".issue" + details.getID());
               newPackage.create();
               for (Method method : methodsToCopy) {
                  method.update(details);
                  newPackage.getClass(method.getClass()).add(method);
               }
               // test
               for (TestCase case : designDocument.getTestCases()) {
                  boolean success = case.run();
                  if (!success) {
                     // damn!!
                     if (!designDocument.isReadOnly()) {
                        designDocument.getTestCases().remove(case);
                     }
                     else {
                        // damn!!!
                        designDocument.descope(case.getFunctionality());
                     }
                  }
               }
               // All tests passed successfully (woot)!
               return;
            }
            else {
               // I'm a guru. WTF? Don't they know that gurus' time is more important?
               List<Developer> devs = this.getProject().getDevelopers();
               Collections.sort(devs, new Comparator<Developer>() {
                  public int compare(Developer d1, Developer d2) {
                     return d1.getExperience(Calendar.YEAR) - d2.getExperience(Calendar.YEAR);
                  }
               });
               Developer junior = devs.get(0);
               // 0wned!!!
               return junior.writeCode(details);
            }
         }
      }
      
      // A new feature. Let's try the Internet first.
      Browser browser = Internet.getDefaultBrowser().open();
      browser.go("http://slashdot.org");
      browser.hangAround(Date.HOUR, 1);
      browser.go("http://javablogs.com");
      browser.hangAround(Date.MINUTE, 20);
      browser.search("BileBlog");
      browser.hangAround(Date.SECOND, 5);
      
      browser.go("http://www.google.com");
      browser.type(details.getShortDescription);
      browser.click(Key.ENTER);
      // No need to check that the code actually does what it's supposed
      // to. Google knows what it's doing.
      String contents = browser.getFirstLink().copy();
      
      Package package = this.getProject().getRootPackage();
      package.getClass(details.getShortDescription().trim()).write(contents);
      
      for (TestCase case : designDocument.getTestCases()) {
         boolean success = case.run();
            if (!success) {
               // Ignore - if the testers are smart enough to catch them,
               // hopefully this will be after I move to another project.
            }
         }
      }    
      
   }
}

Crash course in bug handling

public class Developer {
   public void fixBugs(Set<Bug> bugs) {
      if ((bugs == null) || (bugs.size() == 0)) {
         // does this ever happen?
         throw new UnsupportedException();
      }
      if (bugs.size() > 10) {
         // unsupported
         throw new UnsupportedException("Too many bugs");
         // most probably was ignored, give another chance
         throw new IllegalArgumentException("Too many bugs");
         // most probably was ignored, nuke the bastards
         Thread.currentThread().destroy();
      }
      
      // start handling
      for (Bug bug : bugs) {
         // wait for a while, hoping it will fix itself
         Thread.sleep(10000);
         if (!bug.isActive()) {
            // that was nice
            continue;
         }
         // let's hope somebody else will take it
         Thread.yield();
         if (!bug.isActive()) {
            // what a sucker
            continue;
         }
         // come on!!! it's still active??? wtf???
         String filename = bug.getFilename();
         int tries = 0;
         while (bug.isActive() && (tries <= 10)) {
            RandomAccessFile raf = new RandomAccessFile(filename);
            // pick random file portion and change it
            raf.seek(Math.random()*raf.size());
            raf.write(" // fix for bug " + bug.getID() + " by @author\n");
            String[] keywords = {"for", "while", "do", "continue", "return", "null"};
            for (int i=0; i<100; i++) {
               raf.write(keywords[Math.random()*keywords.length]);
            }
            tries++;
         }
         
         // most probably it's a misinterpreted feature.
         if (Documentation.indexOf(bug.getDescription()) >= 0) {
            // lazy testers... with so much time on their hands why don't 
            // they just read documentation?
            bug.close();
            continue;
         }
         
         // it *should* be a feature
         Designer designer = this.getProject().getLeadDesigner();
         if (designer.acceptsAsFeature(bug.getDescription())) {
            // sucker!!! lol rotfl 0wned!!!
            bug.close();
            continue;
         }
         
         // omg, must be a real bug
         Set<Bug> delegatedBugSet = new HashSet<Bug>();
         delegatedBugSet.add(bug);
         Developer guru = Developer.fetchGuru();
         if (this == guru) {
            // damn!
            throw new UnsupportedException("Will be fixed in service pack");
         }
         guru.fixBugs(delegatedBugSet);
      }
    
      // TODO write tests
      // TODO write documentation
      // TODO update bug tracking system
   
      // seems all is done. 
   }
}

Ribbon and drop-down galleries

• Who, who does not want to wear a ribbon? - introduction and the first implementation
• Ribbon and smart resizing - how ribbon components are laid out during resizing

   public SubstanceThemePopupGallery(final JFrame frame) {
      // set maximum width, maximum height (as-needed vertical scroll
      // bar will be shown) and height of a single icon row
      super(350, 400, 80);

      Map<ThemeKind, IconGroup> groups = new HashMap<ThemeKind, IconGroup>();
      // use createNewGroup function to create icon group at desired visual index
      groups.put(ThemeKind.BRIGHT, this.createNewGroup("Bright themes", 0));
      groups.put(ThemeKind.COLD, this.createNewGroup("Cold themes", 1));
      groups.put(ThemeKind.DARK, this.createNewGroup("Dark themes", 2));

      Map<String, ThemeInfo> themes = SubstanceLookAndFeel.getAllThemes();
      for (Map.Entry<String, ThemeInfo> entry : themes.entrySet()) {
         final String themeClassName = entry.getValue().getThemeClass();
         try {
            Class themeClass = Class.forName(themeClassName);
            SubstanceTheme themeInstance = (SubstanceTheme) themeClass
                  .newInstance();
            // use addIcon to add new icon to some icon group. The icon has:
            // The graphic icon itself
            // Optional title (will be displayed as two-line caption)
            // Action listener (will be activated on mouse click)
            groups.get(entry.getValue().getThemeKind()).addIcon(
                  new ThemeResizableIcon(themeInstance, 60, 40),
                  entry.getKey(), new ActionListener() {
                     public void actionPerformed(ActionEvent e) {
                        SwingUtilities.invokeLater(new Runnable() {
                           public void run() {
                              JPopupGallery.hidePopups(null);
                              SubstanceLookAndFeel
                                    .setCurrentTheme(themeClassName);
                              SwingUtilities
                                    .updateComponentTreeUI(frame
                                          .getRootPane());
                           }
                        });
                     }
                  });
         } catch (Exception e) {
            continue;
         }
      }
   }

Mylar - a very useful Eclipse plugin

"Death to the Browser" - bring on a real application platform

What is needed is the Post Browser, the Next Browser, whatever name you want to give to it. Sure, it can still run HTML (the old stuff), in a container that is essentially the same as today's browser. However it should be capable of complete look-and-feel customization via a standard markup language. It should provide a rich set of custom controls and be able to access the desktop (with appropriate security, of course). It should have a native, secure, bidirectional mechanism, and one that supports multiple connections so that we can access services from multiple sources in a composite application. It should also have extensible controls so that we can extend and improve the behavior of controls and applications as needed. Furthermore those extensions should become part of the next release of the standard, which shouldn't take years to come forward.

This work is licensed under a Creative Commons License.