Forum AmigaOne Zone

#include <stdio.h>
#include <dos/dos.h>
#include <clib/dos_protos.h>

int main( void )
{
   BPTR con;

   /* Otwieramy okno z konsolą */
   if( con = Open( "CON:0/0/640/200/Konsola/CLOSE", MODE_NEWFILE ) )
   {
      /* Wyświetlamy testowy napis */
      VFPrintf( con, "Testowy napis.\n", NULL );
      
      /* Czekamy na naciśnięcie klawisza pięć sekund */
      WaitForChar( con, 5*1000000 );

      /* Zamykamy konsolę */
      Close( con );

      /* Kończymy program (powodzenie) */
      return( RETURN_OK );
   }
   else   
      /* Bład otwierania konsoli */
      printf( "Nie mogę otworzyć konsoli.\n" );
   /* Kończymy program (błąd) */
   return( RETURN_FAIL );
}

#include <stdio.h>
#include <string.h>
#include <devices/console.h>
#include <devices/conunit.h>
#include <intuition/intuition.h>
#include <dos/dos.h>
#include <clib/exec_protos.h>
#include <clib/intuition_protos.h>

/* Rozmiar bufora */
#define ROZMIAR_BUFORA 25

/* Deklaracja funkcji */
int test( struct Window *win, struct IOStdReq *io );

/* Program główny */
int main( void )
{
   struct MsgPort *mp;
   struct Window *win;
   struct IOStdReq *io;

   int returnCode = RETURN_FAIL;

   /* Tworzymy port komunikacyjny */
   if( mp = CreateMsgPort() )
   {
      /* Tworzymy strukturę IOStdReq */
      if( io = ( struct IOStdReq * ) CreateIORequest( mp, sizeof( struct IOStdReq ) ) )      
      {
         /* Otwieramy własne okienko */
         if( win = OpenWindowTags( NULL,
            WA_Left,   0,
            WA_Top,      0,
            WA_Width,   640,
            WA_Height,   200,
            WA_Title,   "Okno konsoli",
            WA_CloseGadget,   TRUE,
            WA_DepthGadget,   TRUE,
            WA_DragBar,   TRUE,
            WA_SimpleRefresh,   TRUE,
            WA_Activate,   TRUE,
            WA_IDCMP,   IDCMP_CLOSEWINDOW,
            TAG_DONE ) )
         {
            /* Wstawiamy adres struktury okienka do struktury IOStdReq */
            io->io_Data = ( APTR ) win;
            io->io_Length = sizeof( struct Window );

            /* Otwieramy console.device (z mapą znaków i usługą Cut-and-Paste) */
            if( OpenDevice( "console.device", CONU_SNIPMAP, ( struct IORequest * ) io, CONFLAG_DEFAULT ) == 0 )
            {
               /* Wywołujemy funkcję testującą */         
               returnCode = test( win, io );

               /* Zamykamy console.device */
               if( CheckIO( ( struct IORequest * ) io ) == NULL )
                  AbortIO( ( struct IORequest * ) io );
               WaitIO( ( struct IORequest * ) io );
               CloseDevice( ( struct IORequest * ) io );               
            }
            /* Zamykamy okienko */
            CloseWindow( win );            
         }
         /* Zwalniamy strukturę IOStdReq */
         DeleteIORequest( ( struct IORequest * ) io );   
      }
      /* Zwalniamy port */
      DeleteMsgPort( mp );
   }
   /* Zwracamy wynik */
   return( returnCode );
}

/* Nasza funkcja testująca konsolę */
int test( struct Window *win, struct IOStdReq *io )
{
   UBYTE *napis = "Testowy napis.\n";
   UBYTE bufor[ ROZMIAR_BUFORA ];
   ULONG con_sig, win_sig, signal;

   /* Wypisujemy w konsoli napis */
   io->io_Data = napis;
   io->io_Length = strlen( napis );
   io->io_Command = CMD_WRITE;
   DoIO( ( struct IORequest * ) io );

   /* Wysyłamy polecenie czytania z konsoli */
   io->io_Data = ( APTR ) bufor;
   io->io_Length = ROZMIAR_BUFORA;
   io->io_Command = CMD_READ;
   SendIO( ( struct IORequest * ) io );

   /* Maska sygnałowa console.device */
   con_sig = 1L << io->io_Message.mn_ReplyPort->mp_SigBit;

   /* Maska sygnałowa portu okienka */
   win_sig = 1L << win->UserPort->mp_SigBit;

   /* Czekamy na naciśnięcie klawisza lub zamknięcie okienka */
   signal = Wait( con_sig | win_sig );

   /* W przypadku sygnału zamknięcia okienka */
   if( signal & win_sig )
   {   
      /* Czyścimy bufor wiadomości z okienka */
      struct Message *msg;
      while( msg = GetMsg( win->UserPort ) )
         ReplyMsg( msg );
   }      

   /* Wracamy z funkcji */
   return( RETURN_OK );
}

#include <intuition/intuition.h>

#include <proto/dos.h>
#include <proto/intuition.h>
#include <proto/exec.h>
#include <proto/gadtools.h>
#include <proto/asl.h>

#include <stdio.h>

static int init(void);
static void loop(void);
static void close(void);

static void ShowAbout(void);
static void FileRead(void);

struct IntuitionBase *IntuitionBase;
struct Library *GadToolsBase;
struct Library *AslBase;
struct Window *window;
struct IntuiMessage *msg;
struct Menu *menu;
struct Screen *pubscr;
void *vi;

char koniec;

struct TagItem taglist[]=
{
   WA_Left,    0,
   WA_Top,      0,
   WA_Width,   250,
   WA_Height,   180,
   WA_MaxWidth,   -1,
   WA_MaxHeight,   -1,
   WA_Title,   (ULONG)"Testowe okno",
   WA_DragBar,   TRUE,
   WA_CloseGadget,   TRUE,
   WA_Activate,   TRUE,
   WA_DepthGadget,   TRUE,
   WA_SizeGadget,   TRUE,
   WA_NewLookMenus,TRUE,
   WA_IDCMP,   IDCMP_CLOSEWINDOW | IDCMP_MENUPICK,
   TAG_END
};

struct TagItem frtag[]=
{
   ASL_Hail,   (ULONG)"Wybierz plik",
   ASL_LeftEdge,   0,
   ASL_TopEdge,   0,
   ASL_Width,   100,
   ASL_Height,   150,
   ASL_OKText,   (ULONG)"Wczytaj",
   ASL_CancelText,   (ULONG)"Poniechaj",
   ASL_File,   (ULONG)"costam.bin",
   ASL_Dir,   (ULONG)"libs:",
   TAG_DONE
};

struct EasyStruct AboutWindow =
{
   sizeof(struct EasyStruct),
   0,
   "About .....",
   "Takie tam pierwsze wypociny.\n",
   "OK",
};

//Menu programu.

struct NewMenu tabnm[]=
{
   {NM_TITLE,   "File"},
   {NM_ITEM,   "Open", "O"},
   {NM_ITEM,   NM_BARLABEL},
   {NM_ITEM,   "Save", "S"},
   {NM_ITEM,   "Save as", "Z"},
   {NM_ITEM,   NM_BARLABEL},
   {NM_ITEM,   "Exit", "Q"},
   {NM_TITLE,   "Menu1"},
   {NM_ITEM,   "Podmenu0"},
   {NM_ITEM,   "Podmenu1..."},
   {NM_ITEM,   NM_BARLABEL},
   {NM_ITEM,   "Podmenu2"},
   {NM_ITEM,   "Podmenu3"},
   {NM_TITLE,   "Menu2"},
   {NM_ITEM,   "Podmenu0"},
   {NM_ITEM,   "Podmenu1"},
   {NM_ITEM,   "Podmenu2"},
   {NM_TITLE,   "Menu3"},
   {NM_ITEM,   "Podmenu1", 0, CHECKIT | MENUTOGGLE},
   {NM_ITEM,   "Podmenu2", 0, CHECKIT | MENUTOGGLE},
   {NM_ITEM,   "Podmenu3", 0, CHECKIT | CHECKED | MENUTOGGLE},
   {NM_ITEM,   "Podmenu4", 0, CHECKIT},
   {NM_SUB,   "Podpodmenu1", 0, CHECKIT, 2|4},
   {NM_SUB,   "Podpodmenu2", 0, CHECKIT | CHECKED, 1|4},
   {NM_SUB,   "Podpodmenu3", 0, CHECKIT, 1|2},
   {NM_TITLE,   "Help"},
   {NM_ITEM,   "About...", "?"},
   {NM_ITEM,   "Podmenu1..."},
   NM_END   
};


int main(void)
{
    if(0 == init())
    {
   loop();
    }
    close();
    return 0;
}

static int init(void)
{
    IntuitionBase=(struct IntuitionBase*) OpenLibrary("intuition.library", 40L);
    if (!IntuitionBase)
    {
   return -1;
    }
    GadToolsBase=OpenLibrary("gadtools.library", 40L);
    if (!GadToolsBase)
    {
   return -1;
    }
    AslBase=OpenLibrary("asl.library", 40L);
    if (!AslBase)
    {
   return -1;
    }
    menu=CreateMenusA(tabnm, 0);
    if (!menu)
    {
   return -1;
    }
    pubscr=LockPubScreen(0);
    if (!pubscr)
    {
   return -1;
    }
    vi=GetVisualInfoA(pubscr, 0);
    if (!vi)
    {
   return -1;
    }
    LayoutMenus(menu, vi, GTMN_NewLookMenus, TRUE, TAG_DONE);
    window=OpenWindowTagList(0, taglist);
    if (!window)
    {
   return -1;
    }
    SetMenuStrip(window, menu);
    return 0;
}

static void loop(void)
    {   
   for (koniec=0; !koniec;)
   {
       WaitPort(window->UserPort);
       if (msg=(struct IntuiMessage*) GetMsg(window->UserPort))
       {
      ULONG Clas=msg->Class;
      UWORD Code=msg->Code;
      ReplyMsg((struct Message*)msg);
      switch (Clas)
      {
          case IDCMP_CLOSEWINDOW:
         koniec = 1;
         break;

          case IDCMP_MENUPICK:
         while (Code!=MENUNULL)
         {
             struct MenuItem *item=ItemAddress(menu, Code);
             if (Code==FULLMENUNUM(0, 0, NOSUB))
            FileRead();
             if (Code==FULLMENUNUM(0, 5, NOSUB))
            koniec = 1;
             if (Code==FULLMENUNUM(4, 0, NOSUB))
            ShowAbout();
             Code=item->NextSelect;
         }
      }
       }
   }
    }

static void close(void)
{
    if (window)
    {
   ClearMenuStrip(window);
   CloseWindow(window);
    }
    if (vi)
    {
   FreeVisualInfo(vi);
    }
    if (pubscr)
    {
   UnlockPubScreen(0, pubscr);
    }
    if (menu)
    {
   FreeMenus(menu);
    }
    if (AslBase)
    {
   CloseLibrary(AslBase);
    }
    if (GadToolsBase)
    {
   CloseLibrary(GadToolsBase);
    }
    if (IntuitionBase)
    {
   CloseLibrary((struct Library*)IntuitionBase);
    }
}

static void ShowAbout(void)
{
    EasyRequest(window, &AboutWindow, NULL, NULL);
}

static void FileRead(void)
{
    struct FileRequester *fr;

    if (fr = (struct FileRequester *) AllocAslRequest(ASL_FileRequest, frtag));
    {
   if (AslRequest(fr, NULL))
   {
       printf("OK.\n");
   }
    }
    FreeAslRequest(fr);
}

....
struct Screen *pubscr;
void *vi;

char koniec;
int WindowWidth, WindowHeight; //Dopisane

struct TagItem taglist[]=
{
   WA_Left,    0,
   WA_Top,      0,
   WA_Width,   WindowWidth,    //Edytowane
   WA_Height,   WindowHeight,  //Edytowane
   WA_MaxWidth,   -1,
   WA_MaxHeight,   -1,
....

....
    pubscr=LockPubScreen(0);
    if (!pubscr)
    {
   return -1;
    }
   WindowWidth=pubscr->Width-200;      //Dopisane
   WindowHeight=pubscr->Height-100;    //Dopisane
   vi=GetVisualInfoA(pubscr, 0);
    if (!vi)
....

   WA_Width,   WindowWidth,    //Edytowane
   WA_Height,   WindowHeight,  //Edytowane

/* Ustalenie wartości zmiennych */
   WindowWidth=pubscr->Width-200;      //Dopisane
   WindowHeight=pubscr->Height-100;    //Dopisane

/* Wpisanie tych wartości do odpowiednich pól w liście tagów */
struct TagItem *tag;
if (tag = FindTagItem(WA_Width, taglist)) tag->ti_Data = WindowWidth;
if (tag = FindTagItem(WA_Height, taglist)) tag->ti_Data = WindowHeight;