home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #16 / NN_1992_16.iso / spool / comp / lang / ada / 2182 < prev    next >
Encoding:
Internet Message Format  |  1992-07-23  |  3.3 KB
  1. Path: sparky!uunet!stanford.edu!ames!haven.umd.edu!mimsy!alex
  2. From: alex@cs.umd.edu (Alex Blakemore)
  3. Newsgroups: comp.lang.ada
  4. Subject: Re: GUI Builder for Ada (NeXT)
  5. Message-ID: <59191@mimsy.umd.edu>
  6. Date: 23 Jul 92 15:55:43 GMT
  7. References: <1992Jul21.004533.12229@sei.cmu.edu> <59149@mimsy.umd.edu> <1992Jul23.001918.16925@sei.cmu.edu>
  8. Sender: news@mimsy.umd.edu
  9. Organization: U of Maryland, Dept. of Computer Science, Coll. Pk., MD 20742
  10. Lines: 60
  11.  
  12. In article <1992Jul23.001918.16925@sei.cmu.edu> goodsenj@ajpo.sei.cmu.edu (John Goodsen) writes:
  13. > >NeXT's interface builder lets you ...
  14. > start to develop a class in the interface builder, [modify generated code]
  15. > and parse the evolved file to keep the interface
  16. > >builder up to date with changes you've made to the text.  
  17.  
  18. > Thisn't what was taught in the tutorial at CHI'92.  In particular, I
  19. > explicitly addressed this issue and the answer was, if you change the
  20. > resulting code, it won't parse back in.  
  21.  
  22. This is definitely NOT true.
  23. You can parse the class definition file as many times as you wish.
  24. Every time you change the interface is a good idea. There is no need to parse 
  25. if you change the implementation as that's not important to the Interface Builder.
  26.  
  27. > Looking at my notes from that tutorial, I see a:
  28. >         :-( can't unparse more than once :-(
  29.                     ^^^^^^
  30. > Is this not the case ?
  31.  
  32. You misunderstood (though they dont make it crystal clear)
  33. Unparse means to generate a class interface and noop implementation file
  34. from the info stored in the builder.  You use this when you have defined
  35. a class and its time to add some code to the implementation methods.
  36.  
  37. You CAN unparse multiple times, but you will overwrite any changes
  38. you made since the last timer you unparsed (it prompts) but this
  39. is NOT a problem at all.  You dont need to do this ever.
  40.  
  41. You CAN parse multiple times and this is crucial, you do this alot.
  42.  
  43. Parsing and unparsing are the way you keep the two representations of the
  44. same info (i.e. custom class defs) in synch.  One representation (the code) is
  45. a superset of the other (the IB data structures)
  46.  
  47. In practice, you define a class in IB, 
  48. instantiate objects and connected the instances to other
  49. instances in various ways (all graphically).
  50. You unparse once to get an implementation file, edit it to define
  51. your code, only work in the text file from then on (for that class definition)
  52. and parse when you change the interface to inform the IB.
  53.  
  54. You still use the graphical IB throughout, over and over again to change
  55. attributes, connections, create instances, define other classes, browse
  56. classes, modify the user interface in many ways.
  57. If you make changes to the generated code - no problem, you just
  58. need to hit the parse button to inform IB about them.
  59. I believe even this may go away in 3.0 next month because they support
  60. precompiled interface files (getting more like Ada) though I havent
  61. seen this with my own eyes.
  62.  
  63. > One obvious C++ solution to this functionality is witnessed in the
  64. > Interviews Ibuild concept which forces a layer of inheritance between
  65. > what the Builder spits out and what you modify, allowing you to always
  66. > "re-engineer" the software back into the builder.
  67.  
  68. This layer is not necessary with NeXT IB and objective C.
  69. -- 
  70. -------------------------------
  71. Alex Blakemore alex@cs.umd.edu
  72.