Take the 2-minute tour ×
Ask Patents is a question and answer site for people interested in improving and participating in the patent system. It's 100% free, no registration required.

Microsoft filed US20120227028 Graphical programming object population user interface autogeneration, which describes the automatic generation of GUIs to instantiate objects. I vaguely recall seeing a implementation of this concept in Java somewhere. Are there any other examples of prior art, or is my memory just bad? Here is the claim 1:

A computer-readable non-transitory storage medium configured with data and with instructions that when executed by at least one processor causes the processor(s) to perform a process for utilizing an instance of an object type in a graphical programming environment, the instance having at least one field defined by the object type, each field of the instance having a name and capable of being assigned a value, the process comprising the steps of:

  • receiving a selection that identifies the instance of the object type;
  • automatically determining what fields are defined for the object type instance;
  • automatically generating an instance data population user interface in the graphical programming environment;
  • and displaying at least the following in the user interface:
    • the name of each field that is defined for the object type instance,
    • and a currently assigned value for each field that currently has an assigned value.
share|improve this question
add comment

10 Answers 10

up vote 7 down vote accepted

Sounds like Naked Objects. Apache Isis is mentioned in the Wikipedia article. I remember running something similar for C++ in the late 90's.

share|improve this answer
add comment

Well, a good place to look would be the NetBeans release notes:

http://netbeans.org/community/releases/old.html

NetBeans is a Java IDE that's rougly the Java equivalent a Visual Studio. Seeing that Microsoft's patent was issued in 2012 and NetBeans has been around for a while, you might find something there.

share|improve this answer
    
Ah. Thanks. I couldn't find it there, but I remember that this was part of the JavaBeans spec –  Johm Don Sep 20 '12 at 18:35
    
Patent issue date doesn't matter as much as "priority date", which is usually based on the filing date, unless proof of prior "invention" can be provided. This is changing in 2013, to a "first-to-file" system. –  John Sep 20 '12 at 20:08
    
The relevant date isn't the issue date but the priority date, which here (as in most cases) is the filing date: March 3, 2011. Did NetBeans have a similar feature before that date? (It's enough if the code is publicly downloadable from a version control system, it doesn't have to be a formal release.) –  Gilles Sep 22 '12 at 23:58
    
See separate post below re: Netbeans Profiler Heapwalk, with FieldsBrowserControllerUI.class and InstancesControllerUI.class. –  Andrew Schulman Mar 6 at 19:49
add comment

Would something like Glade count?

What is Glade?

Glade is a RAD tool to enable quick & easy development of user interfaces for the GTK+
toolkit and the GNOME desktop environment.

The user interfaces designed in Glade are saved as XML, and by using the GtkBuilder GTK+
object these can be loaded by applications dynamically as needed. 
share|improve this answer
2  
I would say no, because it specifies the GUIs are created automatically –  Johm Don Sep 20 '12 at 19:29
add comment

Interface Builder from NeXTStep through to versions shipped with Xcode 4.x carries out the process of interface design and the resultant files are instantiated into GUI objects as described in the patent application. See the discussion at http://en.wikipedia.org/wiki/Interface_Builder this shows that Interface Builder dates from 1988 according to the wikipedia article. Interface builder has been available under OSX since first release and does indeed provide user interface object instantiation at run time from text file definitions. Glade provides similar mechanisms for constructing interfaces using a GUI. The files are instantiated into GUI objects see http://en.wikipedia.org/wiki/Glade_Interface_Designer this dates from 1998.

share|improve this answer
add comment

I think that many of the claims there looked like it was describing original Smalltalk implementation at the Palo Alto Research Center (early '70s), or code that would be trivial to have implemented on that system.

share|improve this answer
    
“Code that would be trivial to have implemented” usually isn't good enough for prior art. Ideally, exhibiting an actual implementation, or a description of one in a paper, would definitely kill that application. –  Gilles Sep 21 '12 at 20:25
add comment

This is a very common pattern and should absolutely not be patentable.

I can refute the root claim from this patent by demonstrating two prior arts: Microsoft's own Visual C++ debugger and the game file editor for my own open-source video game. I present both because they accomplish the claims of this patent in two different ways.

A computer-readable non-transitory storage medium configured with data and with instructions that when executed by at least one processor causes the processor(s) to perform a process for

This is filler text to say that it runs on a computer that saves its data & code on a hard drive.

utilizing an instance of an object type in a graphical programming environment

It should be obvious that the debugger has instances of object types in its GUI. In the game editor screenshot, you see the objects listed on the left in bold, with their properties indented. Properties in both examples can be other objects.

the instance having at least one field defined by the object type, each field of the instance having a name and capable of being assigned a value,

All fields in the debugger are defined by the object type. The "Name" and "Value" columns declare the name and value of a field (row) within an object. In the game editor, the name is to the left on a line with white background, and its value is to the right in gray text.

the process comprising the steps of receiving a selection that identifies the instance of the object type;

Clicking the object accomplishes this in both examples. By expanding an object, you select the instance of the object type whose fields you want to examine or edit.

automatically determining what fields are defined for the object type instance;

The debugger does this using metadata from the compiler ("program database", aka PDB files). Alternatively, the game editor does this using a mechanism in the source code itself. Each object has a standard interface to query for its defined fields. Details of the implementation can be found in the open-source code.

automatically generating an instance data population user interface in the graphical programming environment;

The debugger populates the "Locals" list view with variables automatically when a breakpoint is hit by the executing program. The game editor populates its list on program start. It takes a static root object, queries for its sub-objects, and adds those into the list. It repeats the process for each of the objects it just added until it reaches objects with no sub-objects.

and displaying at least the following in the user interface: the name of each field that is defined for the object type instance, and a currently assigned value for each field that currently has an assigned value.

This is again the "Name" and "Value" columns in the Visual C++ debugger, where each row is a field and an expandable block with a + next to it is an object type instance. In the game editor, the expandable blocks with a + on the left are object type instances, and the fields are either other object type instances or white lines. The white lines are again left-aligned bold text for the name, and right-aligned truncated gray text for the value.

Conclusion

There are, in fact, many more examples of visual debuggers other than Visual C++ that can counter these claims equally, but I chose Visual C++ because it was a Microsoft product, and presumably the Inventors would have been quite aware of it.

I believe all claims could all be easily invalidated by these two examples of prior art.

share|improve this answer
add comment

LabVIEW (National Instruments) has methods to create user interface components directly out of the programming environment. You can right click on any data wire and create a user interface component that correspond to the data object.

share|improve this answer
    
A link or reference to publish date would be meaningful. –  Ron J. Aug 1 '13 at 12:12
    
Here are screenshots from LabVIEW 7.1 (released 2004) showing how to create user interface controls and indicators for various datatypes (Slide 21): dynsys.uml.edu/tutorials/MATLAB_Simulink_LabVIEW/LabVIEW_Doc/… The same was true also for earlier LabVIEW versions dating back to before 1998. –  user5341 Aug 2 '13 at 21:33
add comment

Someone has already mentioned Java NetBeans. I too came across this, using the following search in a software prior-art database (named CodeClaim) that I'm building:

((instance or instantiate) w/100 object w/100 (generate or autogen or builder or ide) w/100 fields w/100 (display or gui or show or ui))

The first hit was in this file:

Java\jdk1.7.0_09\lib\visualvm\profiler\modules\org-netbeans-modules-profiler-heapwalker.jar -> org\netbeans\modules\profiler\heapwalk\ui\FieldsBrowserControllerUI.class

Which also contains InstancesControllerUI. So from this quick check, it sounds like the following would be promising:

Netbeans Profiler Heapwalk

Copyright date in the source code is 1997-2007, and there are 2008 file dates for versions on the web, e.g.:

http://www.java2s.com/Open-Source/Java/IDE-Netbeans/profiler/org/netbeans/modules/profiler/heapwalk/ui/Catalogui.htm

Andrew

share|improve this answer
add comment

My reading of this is that it's not talking about a UI design tool (like Interface Builder or Glade), but rather about a GUI for editing objects: you click on an object, and it displays an editable list of all the properties associated with that object. Which is precisely what every graphical database front end in the world does. Or, if you interpret it more as "automatically generating a GUI for editing data", Ruby on Rails or something similar would be an appropriate precedent.

share|improve this answer
add comment

They just described property pages as in the Windows shell.

share|improve this answer
    
Welcome to Ask Patents. From all the existing answers, it seems that people think it more complex than that. In any case this and all other SE sites prefer longer answers that are more specific and that add to the answers already posted. –  George White Jan 3 at 23:00
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.