home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 3 / CDPDIII.bin / pd / commodities / superdark / main / tom_gadget.c < prev    next >
C/C++ Source or Header  |  1993-03-20  |  19KB  |  761 lines
  1. /************************************************************************/
  2. /*                                    */
  3. /*    File tom_gadget.c                        */
  4. /*                                    */
  5. /************************************************************************/
  6. /* I have a special kind of structure, for my own gadget. This structure*/
  7. /* is used to create the configuration window, but also to read the    */
  8. /* confugration (and saved it) wich is in the .info file (but this is    */
  9. /* made in the icon_data.c file)                    */
  10. /*                                    */
  11. /************************************************************************/
  12.  
  13. #include <exec/types.h>
  14. #include <exec/tasks.h>
  15. #include <exec/execbase.h>
  16. #include <dos/dosextens.h>
  17. #include <intuition/intuition.h>
  18. #include <intuition/gadgetclass.h>
  19. #include <libraries/gadtools.h>
  20. #include <libraries/reqtools.h>
  21. #include <graphics/displayinfo.h>
  22. #include <clib/exec_protos.h>
  23. #include <clib/intuition_protos.h>
  24. #include <clib/gadtools_protos.h>
  25. #include <clib/reqtools_protos.h>
  26. #include "/includes/struct.h"
  27. #include "/includes/tom_gadget.h"
  28.  
  29. extern    struct my_data    my_info;
  30. extern    struct    appel_proc    data_proc;
  31. extern    UBYTE    flg_debug;
  32. extern    struct    ExecBase *SysBase;
  33. extern    struct    ReqToolsBase *ReqToolsBase;
  34. int    Gere_gadg();
  35.  
  36. struct    tom_gadget    gadg_ok    ={"_Ok"    ,BUTTON   , 20, 80, 70,12,0,0,0,0,0};
  37. struct    tom_gadget    gadg_test  ={"_Test"  ,BUTTON   ,100, 80, 70,12,0,0,0,0,0};
  38. struct    tom_gadget    gadg_cancel={"_Cancel",BUTTON   ,180, 80, 70,12,0,0,0,0,0};
  39. struct    tom_gadget    gadg_info  ={"_Info"  ,BUTTON   ,260, 80, 70,12,0,0,0,0,0};
  40.  
  41. struct Screen    *Scr;
  42. struct Gadget        *Gadgets_tom[MAX_GADGET+4];
  43.  
  44. /*
  45. struct    Node ModulesNodes_alea[MAX_NOM];
  46. USHORT    flg_sel[MAX_NOM];
  47. char    *p_nom_alea[MAX_NOM];
  48. #define    MAX_LONG    20
  49.  
  50. struct List ModulesListAlea = {
  51.     &ModulesListAlea.lh_Tail, ( struct Node * )0l, &ModulesListAlea.lh_Head,0,0 };
  52. */
  53. struct TextAttr topaz8 = {
  54.     ( STRPTR )"topaz.font", 8, 0x00, 0x01 };
  55.  
  56. SHORT    win_size_x=10;
  57. SHORT    win_size_y=10;
  58. SHORT    delta;
  59.  
  60. struct TagItem    WindowTags_gadg[] = {
  61.     WA_Left,          174,
  62.     WA_Top,           44,
  63.     WA_Width,         347,
  64.     WA_Height,        124,
  65.     WA_IDCMP,         IDCMP_MOUSEBUTTONS|IDCMP_GADGETDOWN|IDCMP_GADGETUP|IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW|IDCMP_VANILLAKEY|IDCMP_MOUSEMOVE,
  66.     WA_Flags,         WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  67.     WA_Gadgets,       0l,
  68.     WA_Title,         (char *)"Work Window",
  69.     WA_MinWidth,      67,
  70.     WA_MinHeight,     21,
  71.     WA_MaxWidth,      640,
  72.     WA_MaxHeight,     256,
  73.     TAG_DONE };
  74.  
  75. /********************************************************* add_one_gadget */
  76.  
  77. struct    Gadget    *add_one_gadget(p_gadg,num,g,Visual)
  78. struct    tom_gadget    *p_gadg;
  79. int    num;
  80. struct    Gadget    *g;
  81. APTR    Visual;
  82. {
  83.     struct NewGadget     ng;
  84.     int    dir,place;
  85.     char    **p_liste;
  86.  
  87.     ng.ng_LeftEdge        =    p_gadg->LeftEdge;
  88.     ng.ng_TopEdge         =    p_gadg->TopEdge+delta;
  89.     ng.ng_Width           =    p_gadg->Width;
  90.     ng.ng_Height          =    p_gadg->Height;
  91.     ng.ng_GadgetText      =    p_gadg->GadgetText;
  92.     ng.ng_TextAttr        =    &topaz8;
  93.     ng.ng_GadgetID        =    num;
  94.     ng.ng_Flags           =    PLACETEXT_LEFT;
  95.     ng.ng_VisualInfo      =    Visual;
  96.  
  97.     switch(p_gadg->type_gadg){
  98.         case BUTTON:
  99.         case SCREEN:
  100.         case FONT:
  101.  
  102.             ng.ng_Flags           =    PLACETEXT_IN;
  103.             g = CreateGadget( BUTTON_KIND, g, &ng,
  104.                     GT_Underscore, '_', TAG_DONE );
  105.             break;
  106.  
  107.         case SLIDER:
  108.             place= PLACETEXT_RIGHT;
  109.             dir=LORIENT_HORIZ;
  110.             if(ng.ng_Width<ng.ng_Height){
  111.                 dir=LORIENT_VERT;
  112.                 place= PLACETEXT_BELOW;
  113.             }
  114.             if(p_gadg->p_data!=NULL){
  115.                 *((int *)(p_gadg->p_data))=p_gadg->value;
  116.             }
  117.  
  118.             g = CreateGadget( SLIDER_KIND, g, &ng,
  119.                         GTSL_Min, p_gadg->d1,
  120.                         GTSL_Max, p_gadg->d2,
  121.                         GTSL_Level,p_gadg->value,
  122.                         GTSL_MaxLevelLen, 3,
  123.                         GTSL_LevelFormat, "%3ld",
  124.                         GTSL_LevelPlace,place,
  125.                         PGA_Freedom, dir,
  126. /*
  127.                         GA_Immediate, TRUE,
  128. */
  129.                         GA_RelVerify, TRUE,
  130.                         GT_Underscore, '_',TAG_DONE );
  131.             break;
  132.  
  133.  
  134.         case CHECKBOX:
  135.             g = CreateGadget( CHECKBOX_KIND, g, &ng,
  136.                     GTCB_Checked,(p_gadg->value==TRUE?SELECTED:0),
  137.                     GT_Underscore, '_', TAG_DONE );
  138.             break;
  139.         case MX:
  140.             /* Calcul le nombre d'elements    */
  141.             p_gadg->d1=0;
  142.             p_gadg->d2=0;
  143.             while(p_gadg->p_data[p_gadg->d2]!=0){
  144.                 p_gadg->d2++;
  145.             }    
  146.             g = CreateGadget( MX_KIND, g, &ng,
  147.                     GTMX_Labels,p_gadg->p_data,
  148.                     GTMX_Active,p_gadg->value,
  149.                     TAG_DONE );
  150.             break;
  151.         case LISTVIEW:
  152.             g = CreateGadget( LISTVIEW_KIND, g, &ng,
  153.                     GTLV_Labels, p_gadg->p_data,
  154.                     GTLV_ShowSelected, 0l,
  155.                     GTLV_Selected,p_gadg->value,
  156.                     GT_Underscore, '_',TAG_DONE );
  157.             break;
  158.         case OWN_GADGET:
  159.             g=(struct Gadget (*)())((APTR (*)())((struct own_init *)p_gadg->p_data)->own_add)(p_gadg,g,&ng);
  160.             break;
  161.         case CYCLE:
  162.             /* Calcul le nombre d'elements    */
  163.             p_gadg->d1=0;
  164.             p_gadg->d2=0;
  165.             p_liste=(char **)p_gadg->p_data;
  166.             while(p_liste[p_gadg->d2]!=0){
  167.                 p_gadg->d2++;
  168.             }
  169.             p_gadg->d2--;
  170.             g = CreateGadget( CYCLE_KIND, g, &ng,
  171.                     GTCY_Labels, p_gadg->p_data,
  172.                     GTCY_Active,p_gadg->value,
  173.                     GT_Underscore, '_',TAG_DONE );
  174.             break;
  175.         case STRING:
  176.             g = CreateGadget(STRING_KIND, g, &ng,
  177.                     GTST_String,p_gadg->p_data,
  178.                     GTST_MaxChars,p_gadg->d1,
  179.                     GT_Underscore, '_',TAG_DONE );
  180.             break;
  181.         case INTEGER:
  182.             g = CreateGadget(INTEGER_KIND, g, &ng,
  183.                     GTIN_Number,p_gadg->value,
  184.                     GTST_MaxChars,p_gadg->d1,
  185.                     GT_Underscore, '_',TAG_DONE );
  186.             break;
  187.         default:
  188.             break;
  189.     }
  190.     p_gadg->p_gadg=g;
  191.     return(g);
  192.  
  193. }
  194.  
  195. /************************************************** reaffiche_images */
  196. void    reaffiche_images(struct contexe *pc)
  197. {
  198.     struct    tom_gadget    *p_liste;
  199.  
  200.     p_liste=pc->t_g;
  201.     while(p_liste->type_gadg!=END_LISTE){
  202.         if(p_liste->type_gadg==IMAGE){
  203.             DrawImage( pc->Wnd->RPort,
  204.                    (struct Image *)p_liste->p_data ,
  205.                    p_liste->LeftEdge, 
  206.                    p_liste->TopEdge+delta );
  207.         }
  208.         p_liste++;
  209.     }
  210. }
  211.  
  212. /************************************************************************/
  213. /* Fonction qui cree la liste des gadgets, dans le tableau Gadgets_gadg */
  214. /************************************************************************/
  215.  
  216. InitStuff_gadg(pc,flg_bas)
  217. struct    contexe    *pc;
  218. int    flg_bas;
  219. {
  220.     struct Gadget       *g;
  221.     struct    tom_gadget    *p_gadg,*pg;
  222.     SHORT    i,max_x,max_y;
  223.  
  224.     p_gadg=pc->t_g;
  225.     if ( NOT( Scr = LockPubScreen( "Workbench" )))
  226.         return( 1l );
  227.  
  228.     if ( NOT( pc->Visual = GetVisualInfo( Scr, TAG_DONE )))
  229.         return( 2l );
  230.  
  231.     if ( NOT( g = CreateContext( &pc->GList )))
  232.         return( 3l );
  233.  
  234.     max_x=win_size_x;
  235.     max_y=win_size_y;
  236.     pg=p_gadg;
  237.     delta=Scr->WBorTop+Scr->Font->ta_YSize-8;
  238.     while(pg->type_gadg!=END_LISTE){
  239.     if(pg->LeftEdge+pg->Width>max_x){
  240.         max_x=pg->LeftEdge+pg->Width;
  241.     }
  242.     if(pg->TopEdge+pg->Height>max_y){
  243.         max_y=pg->TopEdge+pg->Height;
  244.     }
  245. /*
  246.     printf("[%d]: leftedge:%d topedge:%d width:%d height:%d maxx:%d maxy:%d\n",i,
  247.             pg->LeftEdge,
  248.             pg->TopEdge,
  249.             pg->Width,
  250.             pg->Height,
  251.             max_x,max_y);
  252. */
  253.     pg++;
  254.     }
  255.     max_y+=10;
  256.     max_x+=30;
  257.     if(flg_bas==FALSE){
  258.         gadg_ok.TopEdge=max_y;
  259.         gadg_test.TopEdge=max_y;
  260.         gadg_cancel.TopEdge=max_y;
  261.         gadg_info.TopEdge=max_y;
  262.         max_y+=gadg_ok.Height+10;
  263.         if(max_x<gadg_info.Width+gadg_info.LeftEdge){
  264.          max_x=gadg_info.Width+gadg_info.LeftEdge+10;
  265.         }
  266.     }
  267.     max_y+=delta;
  268.  
  269.     if(max_x>Scr->Width)max_x=Scr->Width;
  270.     if(max_x+WindowTags_gadg[0].ti_Data>Scr->Width){
  271.         WindowTags_gadg[0].ti_Data=Scr->Width-max_x;
  272.     }
  273.     if(max_y>Scr->Height)max_y=Scr->Height;
  274.     if(max_y+WindowTags_gadg[1].ti_Data>Scr->Height){
  275.         WindowTags_gadg[1].ti_Data=Scr->Height-max_y;
  276.     }
  277.     WindowTags_gadg[0].ti_Data=(Scr->Width -max_x)/2;
  278.     WindowTags_gadg[1].ti_Data=(Scr->Height-max_y)/2;
  279.     WindowTags_gadg[2].ti_Data=max_x;
  280.     WindowTags_gadg[3].ti_Data=max_y;
  281.  
  282.     if(flg_bas==FALSE){
  283.         g =add_one_gadget(&gadg_ok,GD_ok,g,pc->Visual);
  284.         Gadgets_tom[ GD_ok    ]=g;
  285.         g =add_one_gadget(&gadg_test,GD_test,g,pc->Visual);
  286.         Gadgets_tom[ GD_test  ]=g;
  287.         g =add_one_gadget(&gadg_cancel,GD_cancel,g,pc->Visual);
  288.         Gadgets_tom[ GD_cancel]=g;
  289.         g =add_one_gadget(&gadg_info,GD_info,g,pc->Visual);
  290.         Gadgets_tom[ GD_info  ]=g;
  291.     }
  292.  
  293.     i=0;
  294.     while(p_gadg[i].type_gadg!=END_LISTE){
  295.  
  296.     if(pg->LeftEdge>=0){
  297.         g=add_one_gadget(&p_gadg[i],i+GD_info+1,g,pc->Visual);
  298.         Gadgets_tom[ i+GD_info+1 ] = g;
  299.  
  300.         if ( NOT g ){
  301.             printf("ERREUR creation gadget\n");
  302.                 return( 4l );
  303.         }
  304.         i++;
  305.         if(i==MAX_GADGET){
  306.             printf("Erreur,maximum de gadgets atteint!\n");
  307.         }
  308.     }
  309.     }
  310.  
  311.     WindowTags_gadg[ 6 ].ti_Data = (ULONG)pc->GList;
  312.     WindowTags_gadg[ 7 ].ti_Data = (ULONG)pc->p_name;
  313.     if ( NOT( pc->Wnd = OpenWindowTagList( 0l, WindowTags_gadg )))
  314.         return( 5l );
  315.  
  316.     GT_RefreshWindow( pc->Wnd, 0l );
  317.     reaffiche_images(pc);
  318.     return( 0l );
  319. }
  320.  
  321. /************************************************** cleanstuff */
  322.  
  323. void CleanStuff_gadg(pc)
  324. struct    contexe    *pc;
  325. {
  326.     int    i;
  327.     struct    tom_gadget    *p_gadg;
  328.  
  329.     if ( pc->Wnd        ){
  330.  
  331.         p_gadg=pc->t_g;
  332.         i=0;
  333.         while(p_gadg[i].type_gadg!=END_LISTE){
  334.         if(p_gadg[i].type_gadg==OWN_GADGET){
  335.             (void (*)())((APTR (*)())((struct own_init *)p_gadg[i].p_data)->own_end)();
  336.         }
  337.         i++;
  338.         }
  339.  
  340.  
  341.         CloseWindow( pc->Wnd);
  342.         pc->Wnd=0;
  343.         if ( pc->GList  )
  344.             FreeGadgets( pc->GList );
  345.        if(Scr)UnlockPubScreen(NULL,Scr);
  346.        if ( pc->Visual )
  347.                FreeVisualInfo( pc->Visual );
  348.     }
  349. }
  350.  
  351. /************************************************** affiche_texte */
  352.  
  353. void    affiche_texte(char *p_t,struct contexte *p_c,int flg_auto_remove)
  354. {
  355.     struct    IntuiMessage *msg;
  356.     int    x,y,n,n_max,y_max;
  357.     struct    RastPort    *rp;
  358.     char    buffer[80],*save_pt;
  359.     struct    contexe    my_ctx;
  360.     int    old_send;
  361.     static    struct    tom_gadget    my_gadg[]={
  362.         {"_Ok",        BUTTON    , 30,100, 200,12,0,0,0,0,0},
  363.         {0,        END_LISTE,  0,  0,   0, 0, 0,0,0,0,0}};
  364.  
  365.     old_send=my_info.flg_send;
  366.     my_info.flg_send=0;
  367.     if(p_t!=NULL){
  368.  
  369.         /* Recherche de la taille du texte en x et y, pour pouvoir */
  370.         /* ouvrir une fenetre de la taille desiree           */
  371.  
  372.         save_pt=p_t;
  373.         n_max=0;y_max=0;
  374.         n=0;
  375.         do{
  376.             if((*p_t!='\n')&&(*p_t!=0)){
  377.                 n++;
  378.             }else{
  379.                 if( n_max<n ){
  380.                     n_max=n;
  381.                 }
  382.                 n=0;
  383.                 y_max++;
  384.             }
  385.             p_t++;
  386.         }while(*(p_t-1)!=0);
  387.         my_gadg[0].Width=n_max*8;
  388.         my_gadg[0].TopEdge=30+y_max*8;
  389.  
  390.         if(flg_auto_remove==TRUE){
  391.             my_gadg[0].type_gadg=END_LISTE;
  392.             win_size_x=my_gadg[0].Width;
  393.             win_size_y=my_gadg[0].TopEdge;
  394.         }else{
  395.             my_gadg[0].type_gadg=BUTTON;
  396.         }
  397.  
  398.         my_ctx.t_g=my_gadg;
  399.         my_ctx.GList=0;
  400.         my_ctx.p_name="SuperDark Information...";
  401.  
  402.         /* Open the window and create the gadgets */
  403.         InitStuff_gadg(&my_ctx,TRUE);
  404.  
  405.         /* Display the information text          */
  406.         rp=my_ctx.Wnd->RPort;
  407.         x=20;y=30;
  408.         n=0;
  409.         p_t=save_pt;
  410.         SetAPen(rp,1);
  411.         do{
  412.             if((*p_t!='\n')&&(*p_t!=0)){
  413.                 buffer[n]=*p_t;
  414.                 n++;
  415.             }else{
  416.                 Move(rp,x,y);
  417.                 Text(rp,buffer,n);
  418.                 x=20;y+=8;n=0;
  419.             }
  420.             p_t++;
  421.         }while(*(p_t-1)!=0);
  422.  
  423.         if(flg_auto_remove==FALSE){
  424.             /* Wait for an action. Any action will close the window!    */
  425.             WaitPort(my_ctx.Wnd->UserPort);
  426.                  while((msg=(struct IntuiMessage *)GT_GetIMsg(my_ctx.Wnd->UserPort))!=0){
  427.                 GT_ReplyIMsg(msg);
  428.             }
  429.         }else{
  430.             Delay(100);
  431.         }
  432.         CleanStuff_gadg(&my_ctx);
  433.     }
  434.     win_size_x=10;
  435.     win_size_y=10;
  436.     my_info.flg_send=old_send;
  437. }
  438.  
  439. /************************************************** handle event */
  440.  
  441. void    handle_event_gadg(pg,code,pc)
  442. struct    Gadget    *pg;
  443. int    code;
  444. struct    contexe    *pc;
  445. {
  446.     int    id;
  447.     struct    tom_gadget    *p_t;
  448.     struct    rtScreenModeRequester    *scrmodereq;
  449.     struct    rtFontRequester        *fontreq;
  450.     struct    TextAttr        *p_text_attr;
  451.  
  452.     id=pg->GadgetID;
  453.     if(id<=GD_info){
  454.         switch(id){
  455.             case    GD_info:
  456.                 affiche_texte(data_proc.p_texte,pc,FALSE);
  457.                 break;
  458.             case    GD_ok:
  459.                 pc->flg_save=TRUE;
  460.             case    GD_cancel:
  461.                 pc->flg_end=TRUE;
  462.                 break;
  463.             case    GD_test:
  464.                 Forbid();
  465.                 my_info.flg_send=1;
  466.                 Permit();
  467.                 big_blank();
  468.                 my_info.flg_send=0;
  469.                 break;
  470.             default:
  471.                 break;
  472.         }
  473.     }else{
  474.        p_t=&pc->t_g[id-GD_info-1];
  475.        switch(p_t->type_gadg){
  476.         case    BUTTON:
  477.             if(p_t->p_data!=0){
  478.                 pc->flg_end=(int (*)())((APTR (*)())p_t->p_data)(pg,p_t,pc);
  479.             }
  480.             break;
  481.         case    MX:
  482.         case    LISTVIEW:
  483.         case    CYCLE:
  484.             p_t->value=code;
  485.             break;
  486.         case    STRING:
  487.             if(p_t->p_data!=NULL){
  488.                 strcpy(p_t->p_data,((struct StringInfo *)(pg->SpecialInfo))->Buffer);
  489.             }
  490.             break;
  491.         case    INTEGER:
  492.             p_t->value=(p_t->p_data,((struct StringInfo *)(pg->SpecialInfo))->LongInt);
  493.             printd("Integer:%d\n",p_t->value);
  494.             break;
  495.         case    CHECKBOX:
  496.             if((pg->Flags&SELECTED)==0){
  497.                 p_t->value=FALSE;
  498.             }else{
  499.                 p_t->value=TRUE;
  500.             }
  501.             break;
  502.         case    SLIDER:
  503.             p_t->value=code;
  504.             if(p_t->p_data!=NULL){
  505.                 *((int *)(p_t->p_data))=code;
  506.             }
  507.             break;
  508.         case    OWN_GADGET:
  509.             (void (*)())((APTR (*)())((struct own_init *)p_t->p_data)->own_press)(pg,code,pc->Wnd);
  510.             break;
  511.         case    SCREEN:
  512.             printd("Screen....");
  513.             if((ReqToolsBase!=0)&&(ReqToolsBase->LibNode.lib_Version>=38)){
  514.                 if (scrmodereq = rtAllocRequestA (RT_SCREENMODEREQ, NULL)) {
  515.                     /* On met les parametres deja present */
  516.                     if(p_t->d1!=0){
  517.                        rtChangeReqAttr(scrmodereq,
  518.                         RTSC_DisplayID,(ULONG)p_t->p_data,
  519.                         RTSC_DisplayWidth,(ULONG)p_t->d1,
  520.                         RTSC_DisplayHeight,(ULONG)p_t->d2,
  521.                         RTSC_DisplayDepth,(ULONG)p_t->d3,
  522.                         RTSC_OverscanType,(ULONG)p_t->value,
  523.                         TAG_DONE
  524.                        );
  525.                     }
  526.                     if (rtScreenModeRequest (scrmodereq,
  527.                             "Pick a screen mode:",
  528.                             RTSC_Flags, SCREQF_DEPTHGAD|SCREQF_SIZEGADS|
  529.                             SCREQF_OVERSCANGAD,
  530.                             TAG_END
  531.                              )){
  532.                                                      scrmodereq->DisplayID,
  533.                     p_t->p_data=(char *)scrmodereq->DisplayID;
  534.                     p_t->d1=scrmodereq->DisplayWidth;
  535.                     p_t->d2=scrmodereq->DisplayHeight;
  536.                     p_t->d3=scrmodereq->DisplayDepth;
  537.                     p_t->value=scrmodereq->OverscanType;
  538.                    }
  539.                    rtFreeRequest (scrmodereq);
  540.  
  541.                 }
  542.             }else{
  543.                aff_error("To use this features, you should have\nReqTools  version V38 and WB2.0\n\n");
  544.             }
  545.             break;
  546.         case    FONT:
  547.             printd("Font....");
  548.             if(ReqToolsBase!=0){
  549.                 if (fontreq = rtAllocRequestA (RT_FONTREQ, NULL)) {
  550.                        /* On met les parametres deja present */
  551.                    p_text_attr=(struct TextAttr *)p_t->p_data;
  552.                    rtChangeReqAttr(fontreq,
  553.                     RTFO_FontName,(ULONG)p_text_attr->ta_Name,
  554.                     RTFO_FontHeight,(ULONG)p_text_attr->ta_YSize,
  555.                     RTFO_FontStyle,(ULONG)p_text_attr->ta_Style,
  556.                     RTFO_FontFlags,(ULONG)p_text_attr->ta_Flags
  557.                    );
  558.                    if (rtFontRequest (fontreq,
  559.                             "Pick a font:",
  560.                             RTFO_Flags, FREQF_SCALE,
  561.                             TAG_END
  562.                              )){
  563.  
  564.                     strcpy(p_text_attr->ta_Name,fontreq->Attr.ta_Name);
  565.                     p_text_attr->ta_YSize=fontreq->Attr.ta_YSize;
  566.                     p_text_attr->ta_Flags=fontreq->Attr.ta_Flags;
  567.                     p_text_attr->ta_Style=fontreq->Attr.ta_Style;
  568.                    }
  569.                    rtFreeRequest (fontreq);
  570.  
  571.                 }
  572.             }else{
  573.                aff_error("To use this features, you should have\nReqTools\n\n");
  574.             }
  575.             break;
  576.         }
  577.     }
  578. }
  579.  
  580. /**************************************************/
  581.  
  582. void    test_bornes(struct    tom_gadget    *p_liste)
  583. {
  584.     if(p_liste->value<p_liste->d1){
  585.         p_liste->value=p_liste->d2;
  586.     }
  587.     if(p_liste->value>p_liste->d2){
  588.         p_liste->value=p_liste->d1;
  589.     }
  590. }
  591.  
  592.  
  593. /************************************************** find raccourcis */
  594.  
  595. void    find_raccourcis(code,pc)
  596. int    code;
  597. struct    contexe    *pc;
  598. {
  599.     USHORT    i;
  600.     short    dir,flg_found;
  601.     struct    Gadget    *gadg;
  602.     int    state;
  603.     struct    tom_gadget    *p_liste;
  604.     char    *p_text;
  605.  
  606.     p_liste=pc->t_g;
  607.     i=0;
  608.     dir=1;
  609.     flg_found=FALSE;
  610.     while((p_liste->type_gadg!=END_LISTE)&&(flg_found==FALSE)){
  611.         p_text=p_liste->GadgetText;
  612.         while(*p_text!=0){
  613.             if((*p_text=='_')&&(tolower(*(p_text+1))==tolower(code))){
  614.                 flg_found=TRUE;
  615.                 if(isupper(code)){
  616.                     dir=-1;
  617.                 }
  618.             }
  619.             p_text++;
  620.         }
  621.         if(flg_found==TRUE){
  622.             gadg=Gadgets_tom[i+GD_info+1];
  623.             switch(p_liste->type_gadg){
  624.                 case    OWN_GADGET:
  625.                 case    BUTTON:
  626.                 case    SCREEN:
  627.                 case    FONT:
  628. /*
  629.                     ActivateGadget(gadg,pc->Wnd,NULL);
  630. */
  631.                     handle_event_gadg(gadg,code,pc);
  632.                     break;
  633.                 case    CHECKBOX:
  634.                     state=FALSE;
  635.                     if((gadg->Flags&SELECTED)==0){
  636.                         state=TRUE;
  637.                     }
  638.                     GT_SetGadgetAttrs (gadg,pc->Wnd,
  639.                         NULL,GTCB_Checked,state,TAG_DONE);
  640.                     handle_event_gadg(gadg,code,pc);
  641.                     break;
  642.                 case    SLIDER:
  643.                     p_liste->value+=dir;
  644.                     test_bornes(p_liste);
  645. /*
  646.                     GT_SetGadgetAttrs (gadg,pc->Wnd,
  647.                         NULL,GTSL_Level,p_liste->d1+(p_liste->value-p_liste->d1)%(p_liste->d2-p_liste->d1+1),TAG_DONE);
  648. */
  649.                     GT_SetGadgetAttrs (gadg,pc->Wnd,
  650.                         NULL,GTSL_Level,p_liste->value,TAG_DONE);
  651.                     break;
  652.                 case    MX:
  653. /*
  654.                     p_liste->value+=dir;
  655.                     test_bornes(p_liste);
  656.  
  657.                     GT_SetGadgetAttrs (gadg,pc->Wnd,
  658.                                      NULL,GTMX_Active,(p_liste->value),TAG_DONE);
  659. */
  660.                     break;
  661.                 case    CYCLE:
  662.                     p_liste->value+=dir;
  663.                     test_bornes(p_liste);
  664.  
  665.                     GT_SetGadgetAttrs (gadg,pc->Wnd,
  666.                                      NULL,GTCY_Active,(p_liste->value),TAG_DONE);
  667.                     break;
  668.                 case    STRING:
  669.                 case    INTEGER:
  670.                     ActivateGadget(gadg,pc->Wnd,NULL);
  671.                     break;
  672.                 case    LISTVIEW:
  673.                     p_liste->value+=dir;
  674.                     test_bornes(p_liste);
  675.  
  676.                     GT_SetGadgetAttrs (gadg,pc->Wnd,
  677.                                      NULL,GTLV_Selected,(p_liste->value),GTLV_Top,p_liste->value,TAG_DONE);
  678.                     break;
  679.             }
  680.         }
  681.         p_liste++;
  682.         i++;
  683.     }
  684. }
  685.  
  686. /************************************************************* main_gadg */
  687.  
  688. void main_gadg(pc)
  689. struct    contexe    *pc;
  690. {
  691.     struct    IntuiMessage *msg;
  692.     int    class,code;
  693.     APTR    IAdress;
  694.  
  695.     pc->flg_end=FALSE;
  696.  
  697.     do{
  698.        WaitPort(pc->Wnd->UserPort);
  699.          while((msg=(struct IntuiMessage *)GT_GetIMsg(pc->Wnd->UserPort))!=0){
  700.         class=msg->Class;
  701.         code=msg->Code;
  702.         IAdress=msg->IAddress;
  703.         GT_ReplyIMsg(msg);
  704.         switch(class){
  705.             case    CLOSEWINDOW:
  706.                 pc->flg_end=TRUE;
  707.                 break;
  708.             case    VANILLAKEY:
  709.                 switch(code){
  710.                     case 'o':
  711.                         pc->flg_end=TRUE;
  712.                         pc->flg_save=TRUE;
  713.                         break;
  714.                     case 'c':
  715.                     case 27:        /* escape */
  716.                         pc->flg_end=TRUE;
  717.                         break;
  718.                     case 't':
  719.                         handle_event_gadg(Gadgets_tom[GD_test],code,pc);
  720.                         break;
  721.                     case 'i':
  722.                         handle_event_gadg(Gadgets_tom[GD_info],code,pc);
  723.                         break;
  724.                     default:
  725.                         find_raccourcis(code,pc);
  726.                         break;
  727.                 }
  728.                 break;
  729.  
  730.             case    GADGETDOWN:
  731.             case    GADGETUP:
  732.                 handle_event_gadg(IAdress,code,pc);
  733.                 break;
  734.             case    REFRESHWINDOW:
  735.                 reaffiche_images(pc);
  736.                 GT_RefreshWindow( pc->Wnd, 0l );
  737.                 break;
  738.  
  739.             default:
  740.                 break;
  741.         }
  742.          }
  743.     }while(pc->flg_end==FALSE);
  744. }
  745.  
  746.  
  747. int Gere_gadg(struct tom_gadget *p_gadg,char    *p_name)
  748. {
  749.     struct    contexe    ctx;
  750.     
  751.     ctx.t_g=p_gadg;
  752.     ctx.GList=0;
  753.     ctx.p_name=p_name;
  754.     ctx.flg_save=FALSE;
  755.  
  756.     InitStuff_gadg(&ctx,FALSE);
  757.     main_gadg(&ctx,FALSE);    
  758.     CleanStuff_gadg(&ctx);
  759.     return(ctx.flg_save);
  760. }
  761.