/*
** Example number 1
**
** Original author: 'Corto'
**
** Converted to OS4-style by Tjitte 'OldFart' de Wolff
**
** June 2011
**
*/
 
/*
 * Exemple d'utilisation des datatypes avec l'affichage d'une image dans
 * une fenêtre du Workbench. On ne traite pas le cas où l'on souhaite
 * afficher l'image dans un écran privé.
 * Une fonction a été créée uniquement dans le but d'afficher un fichier
 * image dans une fenêtre correctement ouverte. Ainsi, cette fonction
 * devrait être réutilisable dans d'autres programmes.
 *
 * L'appel à la méthode FRAMEBOX ... je ne sais toujours pas à quoi ça sert !
 *
 * Un autre programme d'exemple sera nécessaire (si demandé) pour montrer
 * comment afficher un image sur un écran privé, en affectant la palette
 * de l'image à l'écran.
 */
 
#include <exec/exec.h>
#include <dos/dos.h>
#include <graphics/gfx.h>
#include <intuition/intuition.h>
#include <graphics/display.h>
 
#include <datatypes/datatypesclass.h>
#include <datatypes/pictureclass.h>
 
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/dos.h>
#include <proto/graphics.h>
#include <proto/datatypes.h>
 
// Prototypes des fonctions
 
static int loadPictureIntoWindow(char *pictureName, struct Window *pictureWindow);
static void waitInput(struct Window *);
 
/*
 * loadPictureIntoWindow()
 *
 * Charge une image grâce aux datatypes et l'affiche dans une fenêtre
 * préalablement ouverte.
 * Codes d'erreur possibles :
 * 0 : pas d'erreur
 * 2 : échec sur la création de l'objet Datatype
 * 3 : impossible d'accéder aux infos de l'objet
 * 4 : bitmap inaccessible
 * 5 : échec de l'appel à la méthode interne PROC_LAYOUT
 */
static int loadPictureIntoWindow(char *pictureName, struct Window *pictureWindow)
{
  int err = 0;
 
  /* 1. Création du datatype */
  Object *dtype = IDataTypes->NewDTObject(pictureName, PDTA_DestMode,      PMODE_V43,
                                                       PDTA_Screen,        pictureWindow->WScreen,
                                                       PDTA_Remap,         TRUE,
                                                       PDTA_DitherQuality, 1,
                                                       TAG_END);
  if (dtype)
   {
    /* 2. Récupération des infos */
    struct BitMapHeader *bmh;
 
    if (IDataTypes->GetDTAttrs(dtype, PDTA_BitMapHeader, (ULONG)&bmh, TAG_DONE) == 1)
     {
      struct FrameInfo     fri;
      /* 3. Adaptation des dimensions de la fenêtre */
      int windowWidth  = bmh->bmh_Width  + pictureWindow->BorderLeft + pictureWindow->BorderRight;
      int windowHeight = bmh->bmh_Height + pictureWindow->BorderTop  + pictureWindow->BorderBottom;
 
      IIntuition->ChangeWindowBox(pictureWindow, 20, 20, windowWidth, windowHeight);
 
      /* 4. Copie du contexte graphique dans le BitMap de la fenêtre */
      IIntuition->IDoMethod(dtype, DTM_FRAMEBOX, NULL, &fri, &fri, sizeof(struct FrameInfo), 0);
 
      if (fri.fri_Dimensions.Depth > 0)
       {
        if (IIntuition->IDoMethod(dtype, DTM_PROCLAYOUT, NULL, 1))
         {
          struct BitMap       *bitmap;
          struct BitMapHeader *bmhd;
 
          if (IDataTypes->GetDTAttrs(dtype, PDTA_DestBitMap,          &bitmap,
                                            PDTA_BitMapHeader, (ULONG)&bmhd,
                                            TAG_DONE) == 2)
           {
            if (bitmap)
             {
              IGraphics->BltBitMapRastPort(bitmap, 0, 0, pictureWindow->RPort,
                                                         pictureWindow->BorderLeft,
                                                         pictureWindow->BorderTop,
                                                         bmhd->bmh_Width,
                                                         bmhd->bmh_Height,
                                                         0xc0);
             }
            else
             {
              err = 4;
             }
           }
          else
           {
            err = 5;
           }
         }
       }
     }
    else
     {
      err = 3;
     }
 
    IDataTypes->DisposeDTObject(dtype);
   }
  else
   {
    err = 2;
   }
 
  return err;
}
 
 
/*
 * Code du programme principal
 *
 * Il doit :
 * - initialiser un écran (ouverture ou récupération du Workbench)
 * - ouvrir une fenêtre capable de recevoir un bitmap
 * - charger l'image dans la fenêtre
 *
 * Si l'écran support est le Workbench alors il faut adapter les couleurs
 * de l'image à charger à la palette de l'écran Workbench.
 * Si un écran propriétaire est ouvert, on peut récupérer la palette
 * de l'image.
 */
int main(int argc, char *argv[])
{
  int RC = RETURN_FAIL;
 
  // Traitement des arguments
  if (argc == 2)
   {
    char *filename = argv[1];
 
    // Lock de l'écran Workbench pour que la fenêtre s'ouvre sur lui
    struct Screen *screen = IIntuition->LockPubScreen("Workbench");
 
    if (screen)
     {
      // Ouverture d'une fenêtre avec une taille arbitraire
      struct Window *window = IIntuition->OpenWindowTags(NULL, WA_Left,    20,
                                                               WA_Top,     20,
                                                               WA_Width,  200,
                                                               WA_Height, 200,
 
                                                               WA_IDCMP,   0
                                                                          | IDCMP_RAWKEY
                                                                          | IDCMP_MOUSEBUTTONS
                                                                          | IDCMP_ACTIVEWINDOW
                                                                            ,
                                                               WA_Title, (ULONG)"Utilisation des datatypes",
                                                               WA_CustomScreen, (ULONG)screen,
                                                               WA_SizeGadget,    FALSE,
                                                               WA_DragBar,       TRUE,
                                                               WA_DepthGadget,   TRUE,
                                                               WA_CloseGadget,   FALSE,
                                                               WA_Backdrop,      FALSE,
                                                               WA_ReportMouse,   FALSE,
                                                               WA_Borderless,    FALSE,
                                                               WA_Activate,      TRUE,
                                                               WA_RMBTrap,       TRUE,
                                                               WA_SimpleRefresh, FALSE,
                                                               TAG_DONE);
 
      if (window)
       { 
        IIntuition->SetWindowTitles(window, (APTR) -1, "guru-meditation.net aime les datatypes");
 
        // On peut afficher une image dans la fenêtre
        if (loadPictureIntoWindow(filename, window) == 0)
         {
          // Attente d'une touche d'échappement ou d'un clic souris
          waitInput(window);
 
          RC = RETURN_OK;
         }
        else
         {
          IDOS->Printf("Erreur dans le chargement de l'image\n");
         }
 
        IIntuition->CloseWindow(window);
       }
      else
       {
        IDOS->Printf("Impossible d'ouvrir la fenêtre\n");
       }
 
      IIntuition->UnlockPubScreen(NULL, screen);
     }
    else
     {
      IDOS->Printf("Impossible d'accéder à l'écran Workbench\n");
     }
   }
  else
   {
    IDOS->Printf("Usage : dtype nom_image\n");
   }
 
  return RC;
}
 
 
/*
 * waitInput
 * Gère les évènements de la fenêtre.
 */
static void waitInput(struct Window *win)
{
  BOOL Done = FALSE;
  uint32 waitsigs,
         portsig = 1L << win->UserPort->mp_SigBit;
 
  struct IntuiMessage *imsg = NULL;
 
  while (!Done)
   {
    waitsigs = IExec->Wait(portsig);    // Wait ne retourne jamais 0
 
    while (imsg = (struct IntuiMessage *)IExec->GetMsg(win->UserPort))
     {
      // switch puis reply au message
      switch(imsg->Class)
       {
        case IDCMP_RAWKEY:
         {
          switch(imsg->Code)
           {
            case 0x45:   /* = ESC */
            case 0x40:   /* = Space */           
             {
              Done = TRUE;
             }
 
            default:
             {
              break;
             }
           }
         }
 
        case IDCMP_MOUSEBUTTONS:
         {
          switch(imsg->Code)
           {
            case IECODE_LBUTTON:
             {
              Done = TRUE;
             }
 
            default:
             {
              break;
             }
           }
         }
       }
 
      IExec->ReplyMsg((struct Message *)imsg);
     }
   }
}
 
/*
** ================================================================================================
** === End of File ================================================================================
** ================================================================================================
*/