home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / ftp.vapor.com / microdot-1 / md1_src_02.lzx / brettsel.c < prev    next >
C/C++ Source or Header  |  2014-05-19  |  7KB  |  355 lines
  1. #include "microdot.h"
  2.  
  3. #include "ogre.h"
  4. #include "ogre_protos.h"
  5.  
  6. static int Done,usermode;
  7. extern struct List brettlist;
  8. static char *returnbrettname;
  9.  
  10. ALLOCSTATIC( returnbrettname, 160, MEMF_CLEAR )
  11.  
  12. static ULONG tics,secs;
  13.  
  14. #define GID_ULV 1
  15. #define GID_UOK 2
  16. #define GID_UCANCEL 3
  17.  
  18. static int multi;
  19. static APTR resultpool;
  20. static char **results;
  21.  
  22. static void selectentry( struct ogwin *ogw, char ch, int back )
  23. {
  24.     int offs = 0;
  25.     int c, d;
  26.     struct ogrevn *vn;
  27.  
  28.     vn = ogreLVGetEntry( ogw, GID_ULV, 0 );
  29.     if( !vn )
  30.         return;
  31.  
  32.     if( vn->txt[0] == '/' )
  33.         offs = 1;
  34.  
  35.     d = ogreLVGetActive( ogw, GID_ULV ) + ( ( back ) ? - 1 : 1 );
  36.  
  37.     for( c = d; vn = ogreLVGetEntry( ogw, GID_ULV, c ); ( back ) ? c-- : c++ )
  38.     {
  39.         if( tolower( vn->txt[ offs ] ) == ch )
  40.             goto found;
  41.     }
  42.     for( c = ( back ) ? ogreLVGetNumEntries( ogw, GID_ULV ) - 1 : 0; vn = ogreLVGetEntry( ogw, GID_ULV, c ); ( back ) ? c-- : c++ )
  43.     {
  44.         if( tolower( vn->txt[ offs ] ) == ch )
  45.             goto found;
  46.     }
  47.     ogreLVSetActive( ogw, GID_ULV, -1 );
  48.     return;
  49.  
  50. found:
  51.     ogreLVSetActive( ogw, GID_ULV, c );
  52. }
  53.  
  54. static struct user tempu;
  55.  
  56. char *douserreq( void )
  57. {
  58.     struct ogwin *ogw;
  59.     struct Window *iw;
  60.     struct IntuiMessage *im;
  61.     char *p;
  62.     int Done = FALSE;
  63.     struct ogrevn *vn;
  64.     ULONG lastsecs = 0, lastmics = 0, oldval = 0, val;
  65.  
  66.     returnbrettname[0] = 0;
  67.  
  68.     ogw = ogreInitWindow( scr, WFLG_RMBTRAP, 0, "Bitte UserIn auswΣhlen:" );
  69.     ogreAddGroup( ogw, 0, OGFRAME_NONE, NULL );
  70.     ogreAddList( ogw, 0, 0xff, NULL, GID_ULV, 60, 16, multi, NULL );
  71.     ogreLVInit( ogw, GID_ULV );
  72.  
  73.     loaduserlist();
  74.     ul2ogl( ogw, GID_ULV );
  75.  
  76.     ogreAddButton( ogw, 1 | OGB_ONENTER, '@', "OK", GID_UOK );
  77.     ogreAddButton( ogw, 1 | OGB_ONESC, '\x1b', "Abbruch", GID_UCANCEL );
  78.  
  79.     iw = ogreOpenWindow( ogw );
  80.     if( !iw )
  81.     {
  82.         freeuserlist( FALSE );
  83.         return( NULL );
  84.     }
  85.  
  86.     while( !Done )
  87.     {
  88.  
  89.         im = ogreWaitIM( ogw );
  90.         if( im->Class == IDCMP_GADGETUP )
  91.         {
  92.             switch( im->Code )
  93.             {
  94.                 case GID_ULV:
  95.                     if( im->Qualifier == 1 )
  96.                         Done = 2;
  97.                     val = ogreLVGetLastActive( ogw, GID_ULV );
  98.                     if( DoubleClick( lastsecs, lastmics, im->Seconds, im->Micros ) && ( val == oldval ) && ( im->Qualifier == 2 ) )
  99.                         Done = 2;
  100.                     oldval = val;
  101.                     lastsecs = im->Seconds;
  102.                     lastmics = im->Micros;
  103.                     break;
  104.  
  105.                 case GID_UOK:
  106.                     Done = 2;
  107.                     break;
  108.  
  109.                 case GID_UCANCEL:
  110.                     Done = 1;
  111.                     break;
  112.             }
  113.         }
  114.         else if( im->Class == IDCMP_RAWKEY && ! ( im->Code & 0x80 ) )
  115.         {
  116.             p = rawkeyconvert( im );
  117.  
  118.             *p = tolower( *p );
  119.  
  120.             if( *p >= 'a' && *p <=á'z' )
  121.                 selectentry( ogw, *p, im->Qualifier & QSHIFT );
  122.         }
  123.         ogreIMReply( ogw, im );
  124.     }
  125.  
  126.     p = NULL;
  127.  
  128.     if( Done == 2 )
  129.     {
  130.         if( multi )
  131.         {
  132.             char **resultadder;
  133.  
  134.             resultpool = LibCreatePool( MEMF_CLEAR, 2048, 1024 );
  135.             resultadder = results = LibAllocPooled( resultpool, ogreLVGetNumEntries( ogw, GID_ULV ) * 4 + 4 );
  136.  
  137.             vn = ogreLVGetEntry( ogw, GID_ULV, 0 );
  138.  
  139.             while( vn && vn->n.mln_Succ )
  140.             {
  141.                 if( vn->sel )
  142.                 {
  143.                     struct muser *u = ( struct muser * ) vn->userdata;
  144.  
  145.                     *resultadder = LibAllocPooled( resultpool, strlen( u->u.net ) + strlen( u->u.realname ) + 5 );
  146.                     if( u->u.realname[á0 ]á)
  147.                         sprintf( *resultadder++, "%s (%s)", u->u.net, u->u.realname );
  148.                     else
  149.                         strcpy( *resultadder++, u->u.net );
  150.                 }
  151.                 vn = ( struct ogrevn * ) vn->n.mln_Succ;
  152.             }
  153.  
  154.         }
  155.         else
  156.         {
  157.             vn = ogreLVGetEntry( ogw, GID_ULV, ogreValue( ogw, GID_ULV ) );
  158.             if( vn )
  159.             {
  160.                 struct muser *mu = vn->userdata;
  161.  
  162.                 tempu = mu->u;
  163.                 if( mu->u.realname[0] )
  164.                     sprintf( returnbrettname, "%s (%s)", mu->u.net, mu->u.realname );
  165.                 else
  166.                     strcpy( returnbrettname, mu->u.net );
  167.     
  168.                 p = returnbrettname;
  169.             }
  170.         }
  171.     }
  172.  
  173.     freeuserlist( FALSE );
  174.  
  175.     ogreExitWindow( ogw );
  176.     return( p );
  177. }
  178.  
  179. int douserrequser( struct user *u )
  180. {
  181.     if( douserreq() )
  182.     {
  183.         *u = tempu;
  184.         return( 1 );
  185.     }
  186.     return( 0 );
  187. }
  188.  
  189. int brettreqshowpmboards;
  190. char *dobrettreqtitle( char *windowtitle )
  191. {
  192.     struct ogwin *ogw;
  193.     struct Window *iw;
  194.     struct IntuiMessage *im;
  195.     char *p;
  196.     int Done = FALSE;
  197.     struct ogrevn *vn;
  198.     ULONG lastsecs = 0, lastmics = 0, oldval = 0, val;
  199.     struct mbrett *mb;
  200.  
  201.     returnbrettname[0] = 0;
  202.  
  203.     ogw = ogreInitWindow( scr, 0, 0, windowtitle );
  204.     ogreAddGroup( ogw, 0, OGFRAME_NONE, NULL );
  205.     ogreAddList( ogw, 0, 0xff, NULL, GID_ULV, 60, 16, multi, NULL );
  206.     ogreLVInit( ogw, GID_ULV );
  207.  
  208.     mb = (struct mbrett *) brettlist.lh_Head;
  209.     while( mb->n.ln_Succ )
  210.     {
  211.         p = mb->b.name;
  212.         if( p[0] == '/' && p[1] != '╗' || ( brettreqshowpmboards && p[á0 ]á!= '/'á) )
  213.             ogreLVAddEntry( ogw, GID_ULV, p, FALSE, mb );
  214.         mb = (struct mbrett *) mb->n.ln_Succ;
  215.     }
  216.  
  217.     ogreAddButton( ogw, 1 | OGB_ONENTER, '@', "OK", GID_UOK );
  218.     ogreAddButton( ogw, 1 | OGB_ONESC, '\x1b', "Abbruch", GID_UCANCEL );
  219.  
  220.     iw = ogreOpenWindow( ogw );
  221.     if( !iw )
  222.     {
  223.         return( NULL );
  224.     }
  225.  
  226.     while( !Done )
  227.     {
  228.         im = ogreWaitIM( ogw );
  229.         if( im->Class == IDCMP_GADGETUP )
  230.         {
  231.             switch( im->Code )
  232.             {
  233.                 case GID_ULV:
  234.                     if( im->Qualifier == 1 )
  235.                         Done = 2;
  236.                     val = ogreLVGetLastActive( ogw, GID_ULV );
  237.                     if( DoubleClick( lastsecs, lastmics, im->Seconds, im->Micros ) && ( val == oldval ) && ( im->Qualifier == 2 ) )
  238.                         Done = 2;
  239.                     oldval = val;
  240.                     lastsecs = im->Seconds;
  241.                     lastmics = im->Micros;
  242.                     break;
  243.  
  244.                 case GID_UOK:
  245.                     Done = 2;
  246.                     break;
  247.  
  248.                 case GID_UCANCEL:
  249.                     Done = 1;
  250.                     break;
  251.             }
  252.         }
  253.         else if( im->Class == IDCMP_RAWKEY && ! ( im->Code & 0x80 ) )
  254.         {
  255.             p = rawkeyconvert( im );
  256.  
  257.             *p = tolower( *p );
  258.  
  259.             if( *p >= 'a' && *p <=á'z' )
  260.                 selectentry( ogw, *p, im->Qualifier & QSHIFT );
  261.         }
  262.         ogreIMReply( ogw, im );
  263.     }
  264.  
  265.     p = NULL;
  266.  
  267.     if( Done == 2 )
  268.     {
  269.         if( multi )
  270.         {
  271.             char **resultadder;
  272.  
  273.             resultpool = LibCreatePool( MEMF_CLEAR, 2048, 1024 );
  274.             resultadder = results = LibAllocPooled( resultpool, ogreLVGetNumEntries( ogw, GID_ULV ) * 4 + 4 );
  275.  
  276.             vn = ogreLVGetEntry( ogw, GID_ULV, 0 );
  277.  
  278.             while( vn && vn->n.mln_Succ )
  279.             {
  280.                 if( vn->sel )
  281.                 {
  282.                     *resultadder = LibAllocPooled( resultpool, strlen( ( ( struct mbrett * ) vn->userdata ) -> b.name ) + 1 );
  283.                     strcpy( *resultadder++, ( ( struct mbrett * ) vn->userdata ) -> b.name );
  284.                 }
  285.                 vn = ( struct ogrevn * ) vn->n.mln_Succ;
  286.             }
  287.  
  288.         }
  289.         else
  290.         {
  291.             vn = ogreLVGetEntry( ogw, GID_ULV, ogreValue( ogw, GID_ULV ) );
  292.             if( vn )
  293.             {
  294.                 struct mbrett *mb = vn->userdata;
  295.                 strcpy( returnbrettname, mb->b.name );
  296.                 p = returnbrettname;
  297.             }
  298.         }
  299.     }
  300.  
  301.     ogreExitWindow( ogw );
  302.     return( p );
  303. }
  304.  
  305. char *dobrettreq( void )
  306. {
  307.     return( dobrettreqtitle( "Bitte Brett auswΣhlen..." ) );
  308. }
  309.  
  310. char *dobrettreqmulti( void )
  311. {
  312.     if( results )
  313.     {
  314.         if( *results )
  315.             return( *results++ );
  316.         else
  317.         {
  318.             results = NULL;
  319.             LibDeletePool( resultpool );
  320.             return( NULL );
  321.         }
  322.     }
  323.  
  324.     multi = TRUE;
  325.     dobrettreq();
  326.     multi = FALSE;
  327.  
  328.     if( results )
  329.         return( dobrettreqmulti() );
  330.     return( NULL );
  331. }
  332.  
  333. char *douserreqmulti( void )
  334. {
  335.     if( results )
  336.     {
  337.         if( *results )
  338.             return( *results++ );
  339.         else
  340.         {
  341.             results = NULL;
  342.             LibDeletePool( resultpool );
  343.             return( NULL );
  344.         }
  345.     }
  346.  
  347.     multi = TRUE;
  348.     douserreq();
  349.     multi = FALSE;
  350.  
  351.     if( results )
  352.         return( douserreqmulti() );
  353.     return( NULL );
  354. }
  355.