KR>
  > My questions are: Is there anything like MFC for OS/2?
KR>

  There's Borland OWL and IBM OpenClass, both of which are shipped with
  the OS/2 C++ compilers from the respective companies.  There are other,
  non-bundled C++ class libraries, but I'm applying a rather strict
  interpretation to your "like".

  Although there are some minor differences, you should be able port OWL
  code from Windows to Presentation Manager reasonably easily.  There are
  also third-party tools such as Professor OWL (which is available on the
  Hobbes CD-ROM) which make creating OWL applications easy.

  IBM OpenClass is a _serious_ contender when it comes to C++ class
  libraries.  In my opinion, it beats the socks off both OWL and MFC,
  partly because of the comprehensive coverage (an OpenClass application
  never has to even think about  -- the class library wraps almost
  all of the system API), and partly because of the simple elegance of the
  design.

  In support of the latter point, one has only to compare MFC's "message
  maps" and OWL's "event response tables" with OpenClass' "event
  handlers".  OpenClass wins hands down.

  Not only can event handlers be modified at runtime, allowing the
  behaviour of a control to be changed dynamically as required (message
  maps are fixed at compile time); and not only can new event handlers be
  easily added to existing controls (try writing "mixin" classes with
  message maps and see how many years it takes you); but event handlers
  are conceptually far easier to understand for someone coming from a
  non-GUI background, since they are much more "C++ like".

  The only downside to OpenClass is that it was designed with the
  "construction is creation" metaphor (MFC and OWL both use the
  "load/unload" metaphor, for comparison), which can prove extremely
  bothersome in some situations.  That's the main reason that I don't use
  it (I have my own DirectToSOM C++ class library that combines event
  handlers with "load/unload", thus getting the best of both worlds).

  Although the Visual Builder supplied with IBM's C++ compiler is supposed
  to be an OpenClass application generator, it's extremely cumbersome and
  overweight, to the point that almost no-one in the real world can use
  it.  However, third party tools exist.  Prominaire Designer (a demo
  version of which is available on both the DevCon and the Hobbes CD-ROMs)
  can be used to generate OpenClass applications, and is well worth a
  look.

KR>
  > Will anything I'm learning now be transferable to OS/2
  > programming?
KR>

  With MFC very little, if anything, will be transferrable to PM.  The
  problem is MFC itself.  It is far too "thin" as a class library, and so
  makes far too much of the underlying API visible to the programmer.  You
  end up, essentially, learning Windows API programming.

  Whilst there are some similarities between the PM API and the Windows
  API, MFC doesn't make life one whit easier.

  And as Mike said, MFC is prone to Microsoft's goalpost moving, largely
  incompatible with itself (mainly due to its thinness), incomplete, and
  poorly suited for re-use.

  Your best bet is to forget MFC right now, and learn IBM OpenClass.  It
  is available for Windows.

  You'll also probably find it much easier to learn than MFC.  One
  colleague of mine, recently introduced to OpenClass, commented today
  that _OS/2_C++_Class_Library__Power_GUI_Programming_with_C_Set++_, *the*
  book on OpenClass (see the FIDONET OS2PROG booklist posted in this echo
  for publisher and ISBN), puts all of the tutorial texts for MFC that he
  has encountered to shame.

  > JdeBP <
___
 X MegaMail 2.10 #0:
--- Maximus/2 3.01