Newsgroup: it.comp.os.dibattiti
Titolo: Nanodesktop.h

/*
    ----------------------------------------------------------------------------
    LIBRERIA NANODesktop (versione 1.0)
    Copyright 2006-2011 Battaglia Filippo
    ----------------------------------------------------------------------------
    Versione per PSP/PSPE
    ----------------------------------------------------------------------------
    La libreria Nanodesktop fornisce un completo ambiente grafico a finestre
    per PSP/PSPE.
    Per dettagli sulla licenza d'uso, si veda il file License.txt nella
    directory Nanodesktop/src
    ----------------------------------------------------------------------------
    File Header
    ----------------------------------------------------------------------------
*/
// Le seguenti righe di codice consentono di far sė che il presente file 
header
// sia usato esclusivamente una volta, anche se viene richiamato pių volte.
#ifndef _NANODESKTOP_H
        #define    _NANODESKTOP_H
// La sezione seguente provocherā un errore di compilazione qualora non si
// specifichi la piattaforma per cui deve essere compilato Nanodesktop
#ifndef PSP_PLATFORM
        #define NO_PSP_PLATFORM
#endif
#ifndef PSPE_PLATFORM
        #define NO_PSPE_PLATFORM
#endif
#if defined NO_PSP_PLATFOM && defined NO_PSPE_PLATFORM
     #error  No platform variabile defined. Use -D"PSP_PLATFORM" 
or -D"PSPE_PLATFORM"
#endif
// Fine sezione
#ifdef PSP_PLATFORM
       #include <pspkernel.h>
       #include <pspdebug.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
   -----------------------------------------------------------------------------
   -----------------------------------------------------------------------------
                      NANODESKTOP HAL: Definizione variabili
   -----------------------------------------------------------------------------
   -----------------------------------------------------------------------------
*/
/*  ----------------------------------------------------------------------------
    RIFERIMENTI AD HEADER DELLA LIBC NATIVA DELLA PIATTAFORMA
    ----------------------------------------------------------------------------
*/
#include <nanoc.h>
// Oltre ad includere i vari headers standard della libreria NanoC (stdio.h,
// stdlib.h, errno.h ecc.), contiene il codice necessario per richiamare la
// macro di piattaforma (necessaria sotto PSP, ma non PSPE)
/* -----------------------------------------------------------------------------
   RIFERIMENTI AL FILE HEADER DI DEV-IL
   -----------------------------------------------------------------------------
   Normalmente Nanodesktop supporta il caricamento ed il salvataggio dei 
file
   esclusivamente in formato bitmap.
   Tuttavia, esso puō supportare anche altri formati grafici, per mezzo di 
un'
   interfaccia che gli consente di appoggiare alle routine della libreria 
grafica
   DEV-IL. Per usare questa interfaccia, č necessario che l'utente ricompili
   la libreria Nanodesktop con l'opzione -DI_HAVE_DEV_IL (oppure, che si
   linki l'eseguibile con una versione binaria della libreria che č stata
   compilata con tale opzione, per esempio, Nanodesktop_PSPE_DEVIL per
   piattaforme PSPE).
   -----------------------------------------------------------------------------
*/
#ifdef I_HAVE_DEV_IL
       #include  <il.h>
#endif
/*
    ----------------------------------------------------------------------------
    RIFERIMENTI A ROUTINE DEL KERNEL PSP/PSPE
    ----------------------------------------------------------------------------
*/
 #ifdef PSPE_PLATFORM
        void pspDisplayWaitVblankStart(); 
// Riferimenti alle routine del kernel di sistema
        void pspDisplaySetMode(long,long,long); 
// per l'accesso al sottosistema grafico
        void pspDisplaySetFrameBuf(char *topaddr,long linesize,long 
pixelsize,long);
 #endif
 #ifdef PSP_PLATFORM
        void sceDisplayWaitVblankStart(); 
// Riferimenti alle routine del kernel di sistema
        void sceDisplaySetMode(long,long,long); 
// per l'accesso al sottosistema grafico
        void sceDisplaySetFrameBuf(char *topaddr,long linesize,long 
pixelsize,long);
 #endif
/*
    -------------------------------------------------------------------------------
    HAL: DEFINIZIONE DI COSTANTI PER PORTABILITA' RAPIDA
    -------------------------------------------------------------------------------
    Le librerie NANODesktop sono progettate per potere essere portate con 
rapiditā
    su un architettura differente. In molti casi, č sufficiente modificare 
le
    seguenti costanti, e riscrivere le routine di tipo Low Level
    --------------------------------------------------------------------------------
*/
#define __NRWINDOWSALLOCABLE 12
#define __MAXSCREENX 480
#define __MAXSCREENY 272
#define __VMAXSCREENX 512
#define __VMAXSCREENY 272
#define __MAXCURSX 60
#define __MAXCURSY 33
#define __NRBUTTONSALLOCABLE 64
#define __VKB0_POSX1   90
#define __VKB0_POSY1  110
#define __VKB0_LENX  350
#define __VKB0_LENY  140
#define __NNM_POSX1   20
#define __NNM_POSY1   10
#define __NNM_LENX   390
#define __NNM_LENY    70
#define __LENX_FILEMAN_ERRORBOX_VOID  220
#define __LENY_FILEMAN_ERRORBOX_VOID  50
#define __LENX_FILEMAN_ERRORBOX_MKDIR 260
#define __LENY_FILEMAN_ERRORBOX_MKDIR 90
#define __LENX_FILEMAN_ERRORBOX_CONFIRMDEL 260
#define __LENY_FILEMAN_ERRORBOX_CONFIRMDEL 80
#define __LENX_FILEMAN_ERRORBOX_ERRDEL 260
#define __LENY_FILEMAN_ERRORBOX_ERRDEL 90
#define __LENX_FILEMAN_ERRORBOX_CONFIRMREN 400
#define __LENY_FILEMAN_ERRORBOX_CONFIRMREN 130
#define __LENX_FILEMAN_ERRORBOX_ERRREN 260
#define __LENY_FILEMAN_ERRORBOX_ERRREN 90
#define __MOUSE_DELAY 110000
#define __DELAY_SCALE 100000000
/*
   -------------------------------------------------------------------------
   HAL: VARIABILI PER LE ROUTINE GRAFICHE A LIVELLO LOW-LEVEL
   -------------------------------------------------------------------------
   Lo schermo della PSP č gestito in modo un pō... strano.
   Lo schermo della PSP, dal punto di vista fisico, deve essere visto come 
un
   framebuffer a 16 bit di 512*272 pixel. Questo significa che l'ampiezza in
   byte del framebuffer č di 278.528 byte (in esadecimale 0x44000). 
Tuttavia,
   l'area effettivamente visualizzabile č di soli 480*272 pixel: vuol dire 
che
   32 pixel a destra restano costantemente off-screen.
   Poichč i caratteri hanno una dimensione di 8x8 pixel, vuol dire che sono
   visualizzabili 60x38 caratteri
   Le seguenti costanti simboliche servono alle routine di accesso al
   video che sono hardware specifiche
   -------------------------------------------------------------------------
*/
 extern unsigned int             PageSize;
//   Le seguenti variabili si occupano di gestire il calcolo dell'indirizzo
//   del framebuffer relativo ad ogni pixel.
 extern unsigned short int       ActiveFBPage; 
// La pagina attiva in quel momento. Sono
 
      // previste due pagine (0 e 1).
 extern unsigned int             PSPEBaseRegister, 
// PSPE Base Register: questo indirizzo serve per compatibilitā
 
      // con la vera PSP e con l'emulatore. E' uno scostamento che deve
 
      // essere sommato ad ogni indirizzo
                                 XAddrVideoMemory; 
// Questo č l'indirizzo "virtuale" della memoria video in Ram.
 
      // E' un indirizzo virtuale perchč tutti gli indirizzi devono
 
      // essere traslati di una quantitā pari al PSPEBaseRegister;
 extern unsigned int             AddrVideoMemory; 
// E' destinata ad accogliere il vero indirizzo della memoria video,
 
      // dato dalla somma del PSPEBaseRegister e di XAddrVideoMemory;
 extern unsigned int             LastFBPageWritten, WRCurrentPageAddr, 
// Per non ricalcolarlo ogni volta, l'indirizzo della pagina
                                 LastFBPageRead,    RDCurrentPageAddr; 
// del framebuffer dove č avvenuta l'ultima scrittura viene memorizzato in 
una
 
      // variabile globale. Inoltre, viene memorizzata la pagina dove č
 
      // avvenuta l'ultima scrittura, in modo che sia possibile ricalcolare
 
      // l'indirizzo di pagina solo quando si cerca di scrivere in una 
pagina
 
      // diversa
 extern unsigned int             LastLineRead, LastLineWritten; 
// Poichč nel funzionamento di questa libreria sono
 
      // richieste notevoli quantitā di calcoli per generare
 
      // gli indirizzi dei pixel, viene mantenuta una linea
 
      // corrente, ed insieme un offset di linea. Solo quando
 
      // la richiesta di scrivere un pixel č eseguita su una
 
      // riga differente rispetto a quella corrente, viene
 
      // eseguito il ricalcolo dell'indirizzo offset di linea,
 
      // altrimenti viene usato quello giā calcolato
 extern unsigned int             RDCurrentLineAddr, WRCurrentLineAddr; 
// Indirizzo dei dati della linea corrente
/*
   ---------------------------------------------------------------------------
   HAL: DEFINIZIONE DELLE STRUTTURE DATI PER IL CONTROLLO DEL MOUSE E PER LA
   GESTIONE DEI PULSANTI
   ---------------------------------------------------------------------------
*/
struct PSPDataControllerType
{
   unsigned long Frame;
   unsigned long Buttons;
   unsigned char Analog[4];
   unsigned long unused;
};
#ifdef PSPE_PLATFORM
  void sceCtrlInit(int unknown); 
//   Riferimenti al kernel della PSP
  void sceCtrlSetAnalogMode(int on); 
//   per l'accesso al sistema di controllo
  void sceCtrlRead (struct PSPDataControllerType *DataController, int 
unknown);
#endif
#ifdef PSP_PLATFORM
  void sceCtrlReadBufferPositive (struct PSPDataControllerType 
*DataController, int unknown);
#endif
// Definizione delle costanti per la gestione del controller
#define CTRL_ANALOG_X   0
#define CTRL_ANALOG_Y   1
/* Button bit masks */
#define PSP_CTRL_SQUARE     0x8000
#define PSP_CTRL_TRIANGLE   0x1000
#define PSP_CTRL_CIRCLE     0x2000
#define PSP_CTRL_CROSS      0x4000
#define PSP_CTRL_UP         0x0010
#define PSP_CTRL_DOWN       0x0040
#define PSP_CTRL_LEFT       0x0080
#define PSP_CTRL_RIGHT      0x0020
#define PSP_CTRL_START      0x0008
#define PSP_CTRL_SELECT     0x0001
#define PSP_CTRL_LTRIGGER   0x0100
#define PSP_CTRL_RTRIGGER   0x0200
/*
  --------------------------------------------------------------------------
  HAL: COSTANTI COLORE
  Le routine NANODesktop supportano colori a 16 bit. Tuttavia, per 
facilitare
  il compito al programmatore, sono definite 16 costanti manifeste che
  riportano gli errori pių comuni, ed č presente l'array ndColorVector
  che contiene tali colori
  --------------------------------------------------------------------------
*/
typedef unsigned short int TypeColor;
#define    COLOR_BLACK      0x0000
#define    COLOR_RED        0x1111
#define    COLOR_GREEN      0x2222
#define    COLOR_LGREEN     0x3333
#define    COLOR_BLUE       0x4444
#define    COLOR_PINK       0x5555
#define    COLOR_LBLUE      0x6666
#define    COLOR_LLBLUE     0x7777
#define    COLOR_DRED       0x8888
#define    COLOR_ORANGE     0x9999
#define    COLOR_DGREEN     0xAAAA
#define    COLOR_YELLOW     0xBBBB
#define    COLOR_VIOLET     0xCCCC
#define    COLOR_LPINK      0xDDDD
#define    COLOR_CYAN       0xEEEE
#define    COLOR_WHITE      0xFFFF
#define    COLOR_GRAY       0xC210
 extern unsigned short int PSPWndColorVector[16];
/*
   ----------------------------------------------------------------------------
   ----------------------------------------------------------------------------
                          NANODESKTOP CODE: Definizione variabili
   ----------------------------------------------------------------------------
   ----------------------------------------------------------------------------
*/
/*
   -------------------------------------------------------------------------
    DEFINIZIONE DEI FONT DELLA LIBRERIA
   -------------------------------------------------------------------------
*/
    extern unsigned char font[];
/*
   ----------------------------------------------------------------------------
   STRUTTURE DATI PER LA GESTIONE DEL MOUSE
   ----------------------------------------------------------------------------
*/
extern unsigned short int BackgroundMouse [16][16];
extern unsigned char IsTheFirstTimeForMouse;
extern unsigned short int MousePointer_PosX;
extern unsigned short int MousePointer_PosY;
/* --------------------------------------------------------------------------------
   STRUTTURE PER LA GESTIONE DEI CONTROLLI (Nanodesktop code)
   --------------------------------------------------------------------------------
   Queste strutture consentono alle routine di Nanodesktop di funzionare 
senza
   preoccuparsi di quale sia l'effettivo hardware di controllo sottostante.
   Diverse routine richiamano internamente procedure di HAL per accedere
   all'hardware di controllo, sia esso tastiera, mouse o pad di consolle,
   e poi rilasciano dei codici sotto forma di una struttura del tipo
   ndDataControllerType.
   ----------------------------------------------------------------------------------
*/
// Definizione di costanti
#define ND_BUTTON1         0x8000
#define ND_BUTTON2         0x1000
#define ND_BUTTON3         0x2000
#define ND_BUTTON4         0x4000
#define ND_BUTTON5         0x0001         // Corrisponde al tasto SELECT
#define ND_CTRL_UP         0x0010
#define ND_CTRL_DOWN       0x0040
#define ND_CTRL_LEFT       0x0080
#define ND_CTRL_RIGHT      0x0020
struct ndDataControllerType
{
   unsigned short int Buttons;
};
/*
   --------------------------------------------------------------------------------
   STRUTTURE DATI PER LA GESTIONE DEI PULSANTI
   --------------------------------------------------------------------------------
    Le righe successive definiscono i buffer per la gestione dei pulsanti.
    Nell'ambiente NANODesktop, i pulsanti sono divisi in diverse classi.
    A) Pulsanti di classe 1.
       Sono i bottoni che compaiono nella MinWindowsBar, e che consentono la
       massimizzazione di una finestra minimizzata. I dati relativi a questi
       bottoni sono contenuti in un array apposito di 8 elementi.
       Ogni pulsante č caratterizzato da un ID, che identifica semplicemente
       la finestra a cui fa riferimento il bottone.
    B) Pulsanti di classe 2.
       Sono i bottoni che compaiono nella MinWindowsBar, e che consentono il
       cambiamento delle dimensioni della finestra che si trova in primo
       piano. I dati relativi a questi bottoni sono contenuti in un array
       apposito di 4 elementi.
       Ogni pulsante č caratterizzato da un ID, con un preciso significato:
            0 - Aumenta la dimensione X della finestra in primo piano;
            1 - Diminuisce la dimensione X della finestra in primo piano;
            2 - Aumenta la dimensione Y della finestra in primo piano;
            3 - Diminuisce la dimensione Y della finestra in primo piano;
    C) Pulsanti di classe 3.
       Sono i bottoni che consentono di minimizzare o chiudere una finestra.
       I dati relativi a tali pulsanti sono contenuti in appositi
       campi all'interno dell'array WindowData. Ognuno di questi pulsanti
       č caratterizzato da un ID, con il seguente significato:
           0 - Pseudopulsante per il trascinamento della finestra
           1 - Minimizza la finestra
           2 - Chiude la finestra
           3 - Scrolla in alto la barra di scrolling verticale
           4 - Scrolla in basso la barra di scrolling verticale
           5 - Scrolla a destra la barra di scrolling orizzontale
           6 - Scrolla a sinistra la barra di scrolling orizzontale
    D) Pulsanti di classe 4.
       Sono i bottoni che vengono definiti dall'utente, e giaciono nel
       Window Space della finestra.
       I dati relativi a tali pulsanti sono contenuti in appositi campi
       all'interno dell'array WindowData.
       Ogni utente puō definire fino a 16 pulsanti di classe 4 per
       finestra.
*/
#define NOAUTOCLOSE    0
#define AUTOCLOSE      1
struct ButtonsClass1_DataType
{
       unsigned short int ButtonID;
       unsigned char ButtonIsActivated;
       unsigned short int x1;
       unsigned short int x2;
       unsigned short int y1;
       unsigned short int y2;
};
extern struct ButtonsClass1_DataType ButtonsClass1_Data 
[__NRWINDOWSALLOCABLE];
                                                            // Un array che 
contiene le informazioni relative ai bottoni di
                                                            // classe 1. I 
pulsanti di classe 1 sono quei pulsanti che
                                                            // vengono usati 
per massimizzare le finestre che sono
                                                            // state 
minimizzate
extern unsigned short int MinWindowsBar_x1;
extern unsigned short int MinWindowsBar_y1;
extern unsigned short int MinWindowsBar_x2;
extern unsigned short int MinWindowsBar_y2;
extern unsigned short int MinWindowsBar_LenX, MinWindowsBar_LenY;
extern unsigned char MinWindowsBarIsChanged;
extern unsigned char OtherFBPageIsNotUpgraded;
// Codici di identificazione per i pulsanti di classe 2
#define ENLARGE_X   0
#define SMALLER_X   1
#define ENLARGE_Y   2
#define SMALLER_Y   3
struct ButtonsClass2_DataType
{
       unsigned short int ButtonID;
       unsigned char ButtonIsActivated;
       unsigned short int x1;
       unsigned short int x2;
       unsigned short int y1;
       unsigned short int y2;
};
extern struct ButtonsClass2_DataType ButtonsClass2_Data [4];       // Un 
array che contiene le informazioni relative ai bottoni di
                                                            // classe 2.
// Codici di identificazione per i pulsanti di classe 3
#define   TITLEBAR_BUTTON           0
#define   MINIMIZEWINDOW_BUTTON     1
#define   CLOSEWINDOW_BUTTON        2
#define   SCROLL_UP_BUTTON          3
#define   SCROLL_DOWN_BUTTON        4
#define   SCROLL_LEFT_BUTTON        5
#define   SCROLL_RIGHT_BUTTON       6
struct ButtonsClass3_DataType
{
       unsigned short int ButtonID;
       unsigned char ButtonIsActivated;
       unsigned short int x1;
       unsigned short int x2;
       unsigned short int y1;
       unsigned short int y2;
};
// Codice per i pulsanti di classe 4
struct ButtonsClass4_DataType
{
       unsigned char ButtonIsActivated;
       unsigned short int x1;
       unsigned short int x2;
       unsigned short int y1;
       unsigned short int y2;
};
// Codice per la gestione dei menų
struct ndMenu_Type
{
    int NrItems;
    char *NameItem [60];
};
/*
   ---------------------------------------------------------------------------
   STRUTTURE PER LA GESTIONE DEGLI EVENTI
   ---------------------------------------------------------------------------
   Procedure come MouseControl restituiscono alla routine chiamante una 
struct
   di tipo ndEvent_Type che informa il programma chiamante dell'evento che 
si
   č verificato nel sistema grafico.
   Molti eventi (richiesta di minimizzazione della finestra, richiesta di
   massimizzazione, richiesta di spostamento) vengono gestiti internamente
   da MouseControl, in modo trasparente alla routine chiamante.
   Altri eventi (richiesta di chiusura della finestra, pressione di un 
pulsante,
   devono invece essere gestiti dalla routine chiamante.
   La routine chiamante viene informata attraverso i campi nella struct
   ndEvent_Type.
   Il primo campo della struttura č TypeEvent. Esso puō assumere i seguenti
   valori:
          0       NO_EVENT
                  (L'evento č stato gestito internamente da MouseControl)
          1       LEGACY_EVENT
                  (L'evento č legato ad una funzionalitā standard di 
NANODesktop,
                   come per esempio la minimizzazione di una finestra)
          2       CUSTOM_EVENT
                  (E' stato premuto un bottone definito dall'utente)
   Il secondo campo č Message. Esso informa del tipo di evento.
   In caso di evento di tipo LEGACY puō assumere valore:
           0      A_WINDOW_WANTS_TO_BE_CLOSED
                  (Una finestra richiede di essere chiusa)
   Mentre in caso di evento di tipo CUSTOM esso puō assumere valore
          1000    CUSTOM_BUTTON_PRESSED
                  (E' stato premuto un tasto definito dall'utente).
   Il terzo campo č il campo WindowID. Fornisce l'header della finestra dove
   si č verificato l'evento.
   Il quarto campo, č il campo ButtonID. Fornisce l'header del bottone di 
classe
   4 che č stato premuto. Ha significato solo in caso di evento custom.
   -------------------------------------------------------------------------------
*/
#define NO_EVENT      0
#define LEGACY_EVENT  1
#define CUSTOM_EVENT  2
#define A_WINDOW_WANTS_TO_BE_CLOSED  0
#define CUSTOM_BUTTON_PRESSED        0
struct ndEvent_Type
{
       int TypeEvent;
       int Message;
       int WindowID;
       int ButtonID;
};
/*
   -------------------------------------------------------------------------
   VARIABILI PER LE ROUTINE GRAFICHE A LIVELLO LOW-LEVEL
   -------------------------------------------------------------------------
   Le seguenti costanti simboliche servono a definire le dimensioni dello
   schermo. Si parla di dimensioni virtuali e di dimensioni reali. Le
   dimensioni virtuali si riferiscono all'area complessiva reale del
   framebuffer, mentre le dimensioni virtuali si riferiscono alla sola
   area visualizzabile.
   --------------------------------------------------------------------------
*/
 extern unsigned short int MaxScreenX,
                           MaxScreenY,
                           VMaxScreenX,
                           VMaxScreenY,
                           MaxCursX,
                           MaxCursY,
                           Mouse_MaxScreenX,
                           Mouse_MaxScreenY,
                           Windows_MaxScreenX,
                           Windows_MaxScreenY;
// Le seguenti variabili si occupano di contenere l'immagine di sfondo;
 extern unsigned short int      WallPaper [__MAXSCREENX - 14][__MAXSCREENY - 
14];
 extern char                    WallPaperIsActive;
// La seguente variabile dice al sistema se le trasparenze sono attive o 
meno
 extern char                    TrasparencyEnabled;
// La seguente variabile dice al sistema se le thumbnail per il file manager 
di
// tipo 1 sono attive o meno.
 extern char                    ThumbnailEnabled;
// Le seguenti variabili si occupano di tenere traccia della posizione del 
cursore
// per le routine di scrittura carattere che lavorano a livello LOW.
 extern unsigned short int      LL_PosCursX, LL_PosCursY;
/*
   -----------------------------------------------------------------------------
   VARIABILI PER LE ROUTINE CHE LAVORANO AL LIVELLO LOGICAL PAGE
   -----------------------------------------------------------------------------
   Ogni finestra scrive i pixel su un array logico che viene mantenuto in
   memoria e che prende il nome di logical page.
   Le NANODesktop possono visualizzare al massimo 12 finestre: ci sono 12 
logical
   pages, allocate staticamente.
   Una logical page contiene anche lo spazio per il bordo della finestra,
   per il titolo, per la barra del titolo. La necessitā delle logical pages
   nasce dal fatto che alcune finestre possono essere visualizzate, altre
   possono essere minimizzate, ed alcune finestre sono sovrapposte
   parzialmente ad altre finestre.
   -----------------------------------------------------------------------------
*/
struct WindowDataType
{
       char *WindowTitle; 
// Puntatore al titolo della finestra
       char WindowTitleChar [__MAXCURSX]; 
// Array interno per salvataggio caratteri
       unsigned short int ColorTitle, ColorBGTitle, ColorBorder, ColorBGWS; 
// Memorizzano i colori della finestra
       unsigned short int WndLimitX1, WndLimitY1, WndLimitX2, WndLimitY2; 
// Limiti delle finestre sullo schermo
       unsigned short int WndLength, WndHeight; 
// Lunghezza e larghezza della finestra
       unsigned short int WSWndLength, WSWndHeight; 
// Lunghezza e larghezza del Window Space
       unsigned short int ROI_PosX, ROI_PosY; 
// Posizione della region of interest del WS visualizzata
       unsigned short int ROI_LenX, ROI_LenY; 
// Dimensione della Region of Interest
       unsigned short int AA1_X1, AA1_X2, AA1_Y1, AA1_Y2, AA1_LenX, 
AA1_LenY; // Posizione e dimensioni dell'area attiva livello 1
       unsigned short int AA2_X1, AA2_X2, AA2_Y1, AA2_Y2, AA2_LenX, 
AA2_LenY; // Posizione e dimensioni dell'area attiva livello 2
       unsigned short int AA3_X1, AA3_X2, AA3_Y1, AA3_Y2, AA3_LenX, 
AA3_LenY; // Posizione e dimensioni dell'area attiva livello 3
       unsigned short int p[__VMAXSCREENX][__VMAXSCREENY]; 
// Questo array contiene la pagina logica
       unsigned short int ws[__VMAXSCREENX][__VMAXSCREENY]; 
// Questo array contiene la pagina windows space back screen
       unsigned char CharMap[__MAXCURSX][__MAXCURSY]; 
// Mappa caratteri associata
       unsigned short int CharMapColor[__MAXCURSX][__MAXCURSY];
       unsigned char WindowIsActive; 
// Posta a 1 quando la finestra č attiva
       unsigned char Minimize; 
// Posto a 1 quando la finestra viene minimizzata;
       unsigned short int WS_MaxCursX, WS_MaxCursY; 
// Posizione massima del cursore nella finestra
       unsigned short int WS_PosCursX, WS_PosCursY; 
// Posizione del cursore nella finestra
       unsigned short int MargineCharX, MargineCharY; 
// Margini per la visualizzazione caratteri
       struct ButtonsClass3_DataType ButtonsClass3_Data[7]; 
// Array che contiene le informazioni inerenti ai pulsanti di classe 3
       char NrButtonsAllocated;
       struct ButtonsClass4_DataType 
ButtonsClass4_Data[__NRBUTTONSALLOCABLE]; // Array che contiene le 
informazioni inerenti ai pulsanti di classe 4
};
 extern char OwnerArray [__VMAXSCREENX][__VMAXSCREENY][2];
 extern struct WindowDataType WindowData[__NRWINDOWSALLOCABLE]; 
// Genera un array di 8 strutture di tipo WindowDataType
 extern unsigned char WindowsVector[__NRWINDOWSALLOCABLE]; 
// Questo array č un vettore. Riporta l'ordine delle
 
 // finestre sullo schermo
 extern unsigned char NrWindowsAllocated; 
// Contiene il numero delle finestre giā allocate
/*
  --------------------------------------------------------------------------
  DEFINIZIONE DEI CODICI DI ERRORE
  --------------------------------------------------------------------------
  I codici di errore sono definiti come costanti manifeste
  --------------------------------------------------------------------------
*/
#define    ERR_NO_WINDOW_IS_AVAILABLE  -1
#define    ERR_WINDOW_IS_TOO_SMALL     -2
#define    ERR_WINDOW_IS_NOT_ALLOCATED -3
#define    ERR_PIXEL_IS_OUT_OF_WINDOW  -4
#define    ERR_ELEMENT_NOT_PRESENT     -5
#define    ERR_ELEMENT_ALREADY_PRESENT -6
#define    ERR_PIXEL_NOT_IN_WS         -7
#define    ERR_RECTANGLE_OUT_OF_WS     -8
#define    ERR_WSCURSOR_IS_OUT_OF_WS   -9
#define    ERR_IMAGE_OUT_OF_WS         -10
#define    ERR_WINDOW_WAS_NOT_ACTIVE   -11
#define    ERR_WS_SPACE_REQUEST_IS_TOO_LARGE -12
#define    ERR_WINDOW_WILL_BE_TOO_BIG  -13
#define    ERR_WRONG_ROI_COORD         -14
#define    ERR_WINDOW_OVER_FUNC_AREA   -15
#define    ERR_NO_BUTTON_RECORD_IS_AVAILABLE -16
#define    ERR_BUTTON_OUT_OF_WS        -17
#define    ERR_WRONG_BUTTON_PARAMETERS -18
#define    ERR_MEMORY_ERROR            -19
#define    ERR_MEMORY_OVERFLOW         -20
#define    ERR_LIST_IS_EMPTY           -21
#define    ERR_NR_ELEMENT_IS_INVALID   -22
#define    ERR_SWAP_IS_NOT_ALLOWED     -23
#define    ERR_I_CANNOT_OPEN_DIR       -24
#define    ERR_OPERATION_INTERRUPTED   -25
#define    ERR_ACCESS_SYSTEM_PATH      -26
#define    ERR_WRONG_PARAMETERS        -27
#define    ERR_CANNOT_CREATE_FILE      -28
#define    ERR_FILE_NOT_FOUND          -29
#define    ERR_FORMAT_NOT_SUPPORTED    -30
#define    ERR_IO_IMAGE                -31
#define    ERR_LOGICAL_IN_IMAGE        -32
#define    ERR_WRONG_ICON_FORMAT       -33
#define    ERR_SAME_STRINGID_IS_PRESENT -34
#define    ERR_IMAGE_IS_NOT_ALLOCATED  -35
#define    ERR_STRINGID_SYS_DENIED     -36
#define    ERR_STRINGID_TOO_LONG       -37
#define    ERR_ICON_NOT_FOUND          -38
#define    ERR_SAME_NAMECLASS_IS_PRESENT -39
#define    ERR_NAMECLASS_TOO_LONG      -40
#define    ERR_CLASS_NOT_FOUND         -41
#define    ERR_EXT_NOT_FOUND           -42
#define    ERR_I_CANNOT_CREATE_THUMBS  -43
#define    ERR_MESSAGE_IS_TOO_LONG     -44
#define    ERR_FILELIST_OVERFLOW       -45
#define    ERR_STDOUT_WINDOW_NOT_ACTIVE -46
#define    DIALOG_BOX_EXIT             100
/*
 ------------------------------------------------------------------------
 ALTRI SIMBOLI
 ------------------------------------------------------------------------
*/
#define  RENDER       1
#define  NORENDER     0
/*
   -----------------------------------------------------------------------------------
   STRUTTURE DATI PER IL GESTORE DELLA TASTIERA
   -----------------------------------------------------------------------------------
*/
   extern unsigned short int VKB0_Current_PosX, VKB0_Current_PosY;
/*
   -----------------------------------------------------------------------------------
   STRUTTURE DATI PER IL NEW-NAME MANAGER
   -----------------------------------------------------------------------------------
*/
/*
   I parametri relativi al generatore di nuovi nomi non sono memorizzati in 
variabili
   statiche, ma sono invece memorizzati in una struct di tipo NNData_Type 
che ogni
   istanza di GetNewName salva nel proprio stack.
   Le routine richiamate da GetNewName ricevono poi l'indirizzo di tale 
struct
   come parametro. In tal modo č possibile avere diverse istanze di 
GetNewName.
*/
struct NNMData_Type
{
   unsigned short int A1_X1, A1_Y1, A1_X2, A1_Y2;        // Le coordinate 
della finestra NewName
   unsigned short int A2_X1, A2_Y1, A2_X2, A2_Y2;        // Coordinate della 
gray-bar
   unsigned short int A3_X1, A3_Y1, A3_X2, A3_Y2;        // Coordinate 
dell'area caratteri
   unsigned short int MaxLenChar;
   char WndHeader;
   char FirstCharShown;                                  // Il primo 
carattere che viene mostrato
   char PosCursor;                                       // La posizione del 
cursore
   char PrevArrowLeftStatus;                             // Lo stato 
precedente della freccia a sinistra.
   char Display [255];                                   // Il contenuto 
della GrayBar
   // I dati seguenti sono usati per routine VirtualKeyboard
   unsigned short int VKB_A1_X1, VKB_A1_X2, VKB_A1_Y1, VKB_A1_Y2;
   unsigned short int VKB_LenVirtualKeyboard;
   unsigned short int VKB_LateralMargin;
   char VKB_KeyboardIsActive;
   char VKB_WndHeader;
   char VKB_LenAllKeyString;
   char VKB_PosKeyCursor;
   char VKB_NrKeyRectVisualizable;
   char VKB_CapsLockEnabled;
   char VKB_IdCentralKey;
};
/*
   -------------------------------------------------------------------------
   STRUTTURE PER ROUTINE DI GESTIONE IMMAGINI
   -------------------------------------------------------------------------
*/
#define NDRGB     0
#define NDMGKNB   1
struct ndImage_Type
{
   unsigned short int LenX, LenY;
   char ColorFormat;
   TypeColor *Data;                     // Puntatore ai dati (MagicNumber) 
dell'immagine.
};
/*
   ------------------------------------------------------------------------------------
   STRUTTURE DATI PER IL GESTORE DI ALLOCAZIONE
   ------------------------------------------------------------------------------------
*/
   extern char MemoryInitExecuted;
/*
   --------------------------------------------------------------------------------
   HAL: FUNZIONI LOW-LEVEL PER IL DISCO
   --------------------------------------------------------------------------------
   Poichč ogni LIBC delle varie piattaforme usa delle proprie strutture
   per accedere ai dati, č necessario creare un layer di astrazione.
   Le routine accedono ai dischi usando le routine ndFS. I risultati vengono
   posti nelle strutture seguenti. Sono le routine ndFS che si occupano di
   trasferire i dati verso le strutture previste dalla Libc originale della
   piattaforma in modo trasparente ai layer superiori del software.
   --------------------------------------------------------------------------------
*/
extern char ndFSInitExecuted;
struct ndFS_DateTime_Type
{
  unsigned short  year;
  unsigned short  month;
  unsigned short  day;
  unsigned short  hour;
  unsigned short  min;
  unsigned short  sec;
  unsigned int    msec;
  char            available;
};
struct ndFS_Status_Type
{
  int                        mode;
  unsigned int               attr;
  int                        size;
  struct ndFS_DateTime_Type  ctime;       // Data creazione
  struct ndFS_DateTime_Type  atime;       // Data accesso
  struct ndFS_DateTime_Type  mtime;       // Data modifica
  unsigned int  st_private [6];           // Device specific file
};
struct ndFS_DirEntry_Type
{
  char   d_name [256];                     // Nome del file
  struct ndFS_Status_Type Status;          // Stato del file
  void   *d_private;                       // Puntatore a dati specifici del 
dispositivo.
};
int  ndFS_Open (char *file, int flags, int mode);
void ndFS_Close (int fd);
int  ndFS_Read (int fd, void *data, int size);
int  ndFS_Write (int fd, void *data, int size);
int  ndFS_LSeek (int fd, int offset, int whence);
int  ndFS_LTell (int fd);
int  ndFS_Remove (const char *file);
int  ndFS_Mkdir (const char *dir, int mode);
int  ndFS_Rmdir (const char *dir);
int  ndFS_Rename (const char *oldname, const char *newname);
int  ndFS_FileLen (char *NameFile);
int  ndHAL_Devctl (const char *dev, unsigned int cmd, void *indata, int 
inlen, void *outdata, int outlen);
// Funzioni di supporto al file system
char ndFS_GetLongInt (int FileHandle, int *Value);
char ndFS_GetWord (int FileHandle, unsigned short int *Value);
char ndFS_GetByte (int FileHandle, char *Value);
int  ndFS_WriteChar (int FileHeader, char Carattere);
int  ndFS_WriteWord (int FileHeader, unsigned short int Word);
int  ndFS_WriteDWord (int FileHeader, unsigned int DWord);
unsigned int  ndMEM_ReadDWordFromBuffer (char *Buffer, int Offset);
unsigned int  ndMEM_ReadWordFromBuffer (char *Buffer, int Offset);
unsigned char ndMEM_ReadByteFromBuffer (char *Buffer, int Offset);
// Funzioni non basate sulla libc standard
int ndFS_Dopen (const char *fn);
int ndFS_Dread (SceUID fd, struct ndFS_DirEntry_Type *NdDir);
int ndFS_Dclose (int fd);
/*
   ------------------------------------------------------------------------------------------
   ROUTINE DIPENDENTI DALLA PIATTAFORMA PER GESTIONE COLORI
   ------------------------------------------------------------------------------------------
*/
TypeColor ndHAL_RGBToMagicNumber (unsigned char ChannelR, unsigned char 
ChannelG,
                                  unsigned char ChannelB);
void ndHAL_MagicNumberToRGB (TypeColor MagicNumber, unsigned char *ChannelR, 
unsigned char *ChannelG, unsigned char *ChannelB);
TypeColor ndHAL_ConvertNDFtoMagicNumber (unsigned short int NDFValue);
void ndHAL_ConvertNDFToRGB (TypeColor NDFValue, unsigned char *ChannelR, 
unsigned char *ChannelG, unsigned char *ChannelB);
unsigned short int ndHAL_MathBlend (unsigned short int Color1, unsigned 
short int Color2);
/*
   ---------------------------------------------------------------------------
   FUNZIONI HARDWARE DEPENDENT PER GESTIONE GRAFICA
   ---------------------------------------------------------------------------
*/
void ndHAL_PutPixel (unsigned short int PosPixelX, unsigned short int 
PosPixelY,
                     unsigned short int Color);
unsigned short int ndHAL_GetPixel (unsigned short int PosPixelX, unsigned 
short int PosPixelY);
void ndHAL_ChangeFrameBufferPage();
void ndHAL_PutPixelToPage (unsigned short int PosPixelX, unsigned short int 
PosPixelY,
                           unsigned short int Color, unsigned char Page);
unsigned short int ndHAL_GetPixelFromPage (unsigned short int PosPixelX,
                                           unsigned short int PosPixelY,
                                           unsigned short int Page);
/*
   ---------------------------------------------------------------------------
   ROUTINE PER LA GESTIONE DEL CONTROLLER
   ---------------------------------------------------------------------------
*/
void ndHAL_GetPad (struct ndDataControllerType *ndPadRecord);
void ndHAL_WaitKey ();
/*
   -------------------------------------------------------------------------
   FUNZIONI AUSILIARIE
   -------------------------------------------------------------------------
*/
void StringNumber (long int Numero, char *StrPointer);
void ndDelay (float t);
int  ndRand (void);
/*
   ---------------------------------------------------------------------------
   FUNZIONI DI MANIPOLAZIONE STRINGHE
   ---------------------------------------------------------------------------
*/
// Funzioni ausiliarie per manipolazione stringhe
char Magn (char Carattere);
char DeMagn (char Carattere);
char ndStrCpy (char *StringaDest, char *StringaSrc, unsigned char Limit, 
char MakeMagn);
char ndStrCpyBounded (char *StringaDest, char *StringaSrc, unsigned char 
LimitX1, unsigned char LimitX2, char MakeMagn);
// Funzioni stringhe di supporto al file system
void ndFSTR_AppendExtension (char *NameFile, char *Ext);
void ndFSTR_PutSlashAtEnd (char *NameFile);
void ndFSTR_StringDate (int day, int month, int year, char *Stringa);
void ndFSTR_SplitNameFile (char *NomeCompleto, char *Percorso, char *Nome, 
char *Estensione);
/*
   ---------------------------------------------------------------------------
   ROUTINE GENERALI DEL FILE-SYSTEM
   ---------------------------------------------------------------------------
*/
int ndFS_FileLen (char *NameFile);
char ndFS_GetLongInt (int FileHandle, int *Value);
char ndFS_GetWord (int FileHandle, unsigned short int *Value);
char ndFS_GetByte (int FileHandle, char *Value);
int ndFS_WriteChar (int FileHeader, char Carattere);
int ndFS_WriteWord (int FileHeader, unsigned short int Word);
int ndFS_WriteDWord (int FileHeader, unsigned int DWord);
unsigned int ndMEM_ReadDWordFromBuffer (char *Buffer, int Offset);
unsigned int ndMEM_ReadWordFromBuffer (char *Buffer, int Offset);
unsigned char ndMEM_ReadByteFromBuffer (char *Buffer, int Offset);
/*
   -------------------------------------------------------------------------
   1. ROUTINE CHE LAVORANO A LIVELLO LOW
   -------------------------------------------------------------------------
*/
void ndInitSystem (void);
#define ndLL_PutPixel                         ndHAL_PutPixel
#define ndLL_GetPixel                         ndHAL_GetPixel
#define ndLL_PutPixelToPage                   ndHAL_PutPixelToPage
#define ndLL_GetPixelFromPage                 ndHAL_GetPixelFromPage
#define ndLL_ChangeFrameBufferPage            ndHAL_ChangeFrameBufferPage
void ndLL_WriteChar (short int ChPosX, short int ChPosY,
                     char Carattere, unsigned short int Color);
void ndLL_GoCursor(short int PosX, short int PosY);
void ndLL_CarriageReturn(void);
void ndLL_WriteLetter(char Lettera, unsigned short int Color);
void ndLL_Write (char *str, unsigned short color);
void ndLL_WriteLn (char *str, unsigned short color);
void ndLL_ClrScr (void);
void ndLL_WriteCharSpecial (short int PosPixelCharX, short int 
PosPixelCharY, char Carattere,
                            unsigned short int Color, unsigned short int 
Page);
/*
   ----------------------------------------------------------------------------------
   FUNZIONI LOW-LEVEL PER LA TASTIERA
   ----------------------------------------------------------------------------------
*/
void ndInit_VirtualKeyboards ();
char ndSET_PosVirtualKeyboard0 (unsigned short int NewPosX, unsigned short 
int NewPosY);
char ndGET_PosVirtualKeyboard0 (unsigned short int *PosX, unsigned short int 
*PosY);
unsigned short int ndLL_KeyPressedCode (int MessCode1, int MessCode2);
/*
    ------------------------------------------------------------------------------
    2.1 ROUTINE LP RELATIVE ALLA LOGICA DI GESTIONE DELLE FINESTRE (Windows 
Vector)
    -------------------------------------------------------------------------------
*/
unsigned char ndLP_IsPixelInWindow (unsigned short int PosPixelX, unsigned 
short int PosPixelY,
                                    unsigned char WndHeader);
char ndLP_ShootElementInTheWV (unsigned char Element);
char ndLP_PutElementAtTheTopOfWV (unsigned char Element);
char ndLP_RemoveElementFromWV (unsigned char Element);
void ndLP_FindOwnerOfPixel (unsigned short int PosPixelX, unsigned short int 
PosPixelY, unsigned char *OwnerID);
void ndLP_FindTwoOwnersOfPixel             (unsigned short int PosPixelX, 
unsigned short int PosPixelY,
                                            unsigned char *OwnerID1, 
unsigned char *OwnerID2);
unsigned char ndLP_MyPixelIsInFirstPlane   (unsigned int RPosPixelX, 
unsigned int RPosPixelY,
                                            unsigned char WndHeader);
void ndLP_DrawMinWindowsBar ();
void ndLP_EnableTrasparency (void);
void ndLP_DisableTrasparency (void);
char ndLP_LoadWallPaperFromFile (char *NameFile);
char ndLP_LoadWallPaperFromNDImage (struct ndImage_Type *MyImage);
void ndLP_EnableWallPaper(void);
void ndLP_DisableWallPaper(void);
void WindowsRender ();
/*
  ----------------------------------------------------------------------------
  2.2 ROUTINE LP RELATIVE ALLA SCRITTURA A LIVELLO LOGICAL PAGE
  ----------------------------------------------------------------------------
*/
char ndLP_PutPixel          (unsigned short int RPosPixelX, unsigned short 
int RPosPixelY,
                             unsigned short int Color, unsigned char 
WndHeader,
                             unsigned char RenderNow);
char ndLP_WriteChar         (unsigned short int RPosPixelCharX, unsigned 
short int RPosPixelCharY,
                             char Carattere, unsigned short int Color,
                             unsigned short int BGColor, unsigned char 
WndHeader,
                             unsigned char RenderNow);
char ndLP_Write             (unsigned short int RPosPixelX, unsigned short 
int RPosPixelY,
                             char *str, unsigned short Color, unsigned short 
BGColor,
                             unsigned char WndHeader, unsigned char 
RenderNow);
char ndLP_DrawRectangle     (unsigned short int PosX1, unsigned short int 
PosY1,
                             unsigned short int PosX2, unsigned short int 
PosY2,
                             unsigned short int Color, unsigned short int 
BorderColor,
                             unsigned char WndHeader, unsigned char 
RenderNow);
char ndLP_DrawRectangleVoid (unsigned short int PosX1, unsigned short int 
PosY1,
                             unsigned short int PosX2, unsigned short int 
PosY2,
                             unsigned short int BorderColor, unsigned char 
WndHeader,
                             unsigned short int RenderNow);
// --------------------------------------------------------------------------
// 2.3 ROUTINE LP DI ALLOCAZIONE DELLE FINESTRE
// --------------------------------------------------------------------------
char ndLP_AllocateWindowComplex      (unsigned short int _PosWindowX1,
                                      unsigned short int _PosWindowY1,
                                      unsigned short int _PosWindowX2,
                                      unsigned short int _PosWindowY2,
                                      char *_WindowTitle,
                                      unsigned short int _ColorTitle,
                                      unsigned short int _ColorBGTitle,
                                      unsigned short int _ColorWindow,
                                      unsigned short int _ColorBorderWindow,
                                      unsigned short int _WSLength,
                                      unsigned short int _WSHeight);
char ndLP_AllocateWindow             (unsigned short int _PosWindowX1,
                                      unsigned short int _PosWindowY1,
                                      unsigned short int _PosWindowX2,
                                      unsigned short int _PosWindowY2,
                                      char *_WindowTitle,
                                      unsigned short int _ColorTitle,
                                      unsigned short int _ColorBGTitle,
                                      unsigned short int _ColorWindow,
                                      unsigned short int 
_ColorBorderWindow);
char ndLP_MaximizeWindow (unsigned char WndHeader);
char ndLP_MinimizeWindow (unsigned char WndHeader);
char ndLP_ResizeWindow (unsigned short int NewSizeX, unsigned short int 
NewSizeY,
                        unsigned char WndHeader);
char ndLP_ChangeWindowParameters (unsigned short int _PosWindowX1,
                                  unsigned short int _PosWindowY1,
                                  unsigned short int _PosWindowX2,
                                  unsigned short int _PosWindowY2,
                                  char *_WindowTitle,
                                  unsigned short int _ColorTitle,
                                  unsigned short int _ColorBGTitle,
                                  unsigned short int _ColorWindow,
                                  unsigned short int _ColorBorderWindow,
                                  unsigned short int _WSLength,
                                  unsigned short int _WSHeight,
                                  unsigned char WndHeader,
                                  unsigned short int PutInTheFirstPlane);
char ndLP_MoveWindow (unsigned short int NewPosX, unsigned short int 
NewPosY,
                      unsigned char WndHeader);
char ndLP_PutWindowInFirstPlane (unsigned char WndHeader);
char ndLP_DestroyWindow (unsigned char WndHeader);
char ndLP_ChangeWndTitle (char *NewTitle, unsigned short int NewColorTitle,
                          unsigned short int NewBGColorTitle, unsigned char 
WndHeader);
char ndLP_ChangeWindowROI_Rect (unsigned short int NewROIPosX, unsigned 
short int NewROIPosY,
                                unsigned char WndHeader);
char ndLP_ChangeWindowROI_Rect_Smart (int NewROIPosX, int NewROIPosY, 
unsigned char WndHeader);
char ndLP_ChangeWindowROI (unsigned short int NewROIPosX_Frac, unsigned 
short int NewROIPosY_Frac,
                           unsigned char WndHeader);
/*
   -------------------------------------------------------------------------------------------
   3.1 ROUTINE WS CHE ESPLETANO FUNZIONI DI SERVIZIO
   -------------------------------------------------------------------------------------------
*/
unsigned char ndWS_IsPixelInWS (unsigned short int RRPosPixelX, unsigned 
short int RRPosPixelY, unsigned char WndHeader);
unsigned char ndWS_IsPixelInROI (unsigned short int RRPosPixelX, unsigned 
short int RRPosPixelY, unsigned char WndHeader);
unsigned char ndWS_IsPixelCovered (unsigned short int RRPosPixelX, unsigned 
short int RRPosPixelY,
                                   unsigned char WndHeader, unsigned short 
int *ColoreCoprente);
char XWindowRender (unsigned char WndHeader);
/*
   ------------------------------------------------------------------------------------------------
   3.2 ROUTINE WS CHE SI OCCUPANO DELLA SCRITTURA DEI CARATTERI
   ------------------------------------------------------------------------------------------------
*/
char ndWS_WriteChar (unsigned int PosCursX, unsigned int PosCursY,
                     char Carattere, unsigned int Colore,
                     unsigned char WndHeader, unsigned char RenderNow);
char ndWS_CharScrolling (unsigned char WndHeader);
char ndWS_CarriageReturn (unsigned char WndHeader);
char ndWS_GoCursor (unsigned short int PosCursX, unsigned short int 
PosCursY, unsigned char WndHeader);
char ndWS_ClrScr (unsigned char WndHeader);
char ndWS_WriteLetter (char Carattere, unsigned int Colore, unsigned char 
WndHeader, unsigned char RenderNow);
char ndWS_Write (char *str, unsigned short Colore, unsigned char WndHeader, 
unsigned char RenderNow);
char ndWS_WriteLn (char *str, unsigned short Colore, unsigned char 
WndHeader, unsigned char RenderNow);
/*
  ----------------------------------------------------------------------------------------------
  3.3 ROUTINE WS CHE SI OCCUPANO DELLA CREAZIONE DI ELEMENTI GRAFICI SULLO 
SCHERMO
  ----------------------------------------------------------------------------------------------
*/
unsigned short int ndWS_GetPixel (unsigned short int RRPosPixelX, unsigned 
short int RRPosPixelY,
                         unsigned char WndHeader);
char ndWS_PutPixel      (unsigned short int RRPosPixelX, unsigned short int 
RRPosPixelY,
                         unsigned short int Color, unsigned char WndHeader,
                         unsigned char RenderNow);
char ndWS_DrawRectangle (unsigned short int RRPosX1, unsigned short int 
RRPosY1,
                         unsigned short int RRPosX2, unsigned short int 
RRPosY2,
                         unsigned short int Color, unsigned short int 
BorderColor,
                         unsigned char WndHeader, unsigned char RenderNow);
char ndWS_DrawRectangleVoid (unsigned short int RRPosX1, unsigned short int 
RRPosY1,
                         unsigned short int RRPosX2, unsigned short int 
RRPosY2,
                         unsigned short int BorderColor,
                         unsigned char WndHeader, unsigned char RenderNow);
char ndWS_DrawRectangleRounded (unsigned short int RRPosX1, unsigned short 
int RRPosY1,
                         unsigned short int RRPosX2, unsigned short int 
RRPosY2,
                         unsigned short int Color, unsigned short int 
BorderColor,
                         unsigned char WndHeader, unsigned char RenderNow);
char ndWS_DrawRectangleRoundedVoid (unsigned short int RRPosX1, unsigned 
short int RRPosY1,
                         unsigned short int RRPosX2, unsigned short int 
RRPosY2,
                         unsigned short int BorderColor,
                         unsigned char WndHeader, unsigned char RenderNow);
char ndWS_DrawLine      (unsigned short int RRPosX1, unsigned short int 
RRPosY1,
                         unsigned short int RRPosX2, unsigned short int 
RRPosY2,
                         unsigned short int Color, unsigned char WndHeader,
                         unsigned char RenderNow);
char ndWS_ClrBufferSpace (unsigned char WndHeader);
char ndWS_ClrALL (unsigned char WndHeader);
char ndWS_ChangeWndColor (unsigned short int NewColor, unsigned short int 
WndHeader);
char ndLP_ChangeWndColor (unsigned short int NewColor, unsigned short int 
WndHeader);
char ndWS_WriteCharInWS   (unsigned int RRPosPixelX, unsigned int 
RRPosPixelY, char Carattere,
                           unsigned int Color, unsigned int BGColor, 
unsigned char WndHeader,
                           unsigned char RenderNow);
char ndWS_WriteStringInWS (unsigned short RRPosPixelX, unsigned short int 
RRPosPixelY, char *str,
                           unsigned short Color, unsigned short BGColor, 
unsigned char WndHeader,
                           unsigned char RenderNow);
/*
   ------------------------------------------------------------------------------------------
   ROUTINE PER LA GESTIONE DELLE IMMAGINI
   ------------------------------------------------------------------------------------------
*/
char ndIMG_GetPixelFromImage     (struct ndImage_Type *MyImage, unsigned 
short int PosX,
                                  unsigned short int PosY, TypeColor 
*MagicNumber);
char ndIMG_GetPixelFromImage_RGB (struct ndImage_Type *MyImage, unsigned 
short int PosX, unsigned short int PosY,
                                  unsigned char *ChannelR, unsigned char 
*ChannelG, unsigned char *ChannelB);
char ndIMG_PutPixelToImage       (struct ndImage_Type *MyImage, unsigned 
short int PosX, unsigned short int PosY,
                                  TypeColor MagicNumber);
char ndIMG_PutPixelToImage_RGB   (struct ndImage_Type *MyImage, unsigned 
short int PosX, unsigned short int PosY,
                                  unsigned char ChannelR, unsigned char 
ChannelG, unsigned char ChannelB);
char ndIMG_CreateImage           (struct ndImage_Type *ndImgDest, int LenX, 
int LenY, char ColorFormat);
char ndIMG_LoadImageFromNDFArray (struct ndImage_Type *ndImgDest, int LenX, 
int LenY, unsigned short int *PointerToFirstWord, char ColorFormat);
char ndIMG_InitImage             (struct ndImage_Type *ndImgDest);
char ndIMG_LoadImage             (struct ndImage_Type *MyImage, char 
*NameFile, char ColorFormat);
char ndIMG_ShowImageScaled       (struct ndImage_Type *MyImage, short int 
RRPosX, short int RRPosY, float ScaleX,
                                  float ScaleY, unsigned char WndHeader, 
char RenderNow);
char ndIMG_ShowImage             (struct ndImage_Type *MyImage, short int 
RRPosX, short int RRPosY,
                                  unsigned char WndHeader, char RenderNow);
char ndIMG_SaveImage             (struct ndImage_Type *MyImage, char 
*NameFile);
void ndIMG_ReleaseImage          (struct ndImage_Type *MyImage);
/*
   -----------------------------------------------------------------------------------------
   ROUTINE PER LA GESTIONE DEL PUNTATORE DEL MOUSE
   -----------------------------------------------------------------------------------------
*/
char ndCTRL_AllocateButton    (unsigned short int RRPosX1, unsigned short 
int RRPosY1,
                               unsigned short int RRPosX2, unsigned short 
int RRPosY2,
                               unsigned char WndHeader);
char ndCTRL_CreateButtonComplex (unsigned short int RRPosX1, unsigned short 
int RRPosY1,
                                 unsigned short int RRPosX2, unsigned short 
int RRPosY2,
                                 unsigned char WndHeader,
                                 char *Stringa1, char *Stringa2,
                                 unsigned short int ColorText,
                                 unsigned short int ColorButton,
                                 unsigned short int ColorBorderButton,
                                 unsigned short int Q1PosX1, unsigned short 
int Q1PosY1,
                                 unsigned short int Q1PosX2, unsigned short 
int Q1PosY2,
                                 struct ndImage_Type *IconImage,
                                 unsigned short int Q2PosX1, unsigned short 
int Q2PosY1,
                                 unsigned short int Q2PosX2, unsigned short 
int Q2PosY2,
                                 unsigned short int RenderNow);
char ndCTRL_CreateButton (unsigned short int RRPosX1, unsigned short int 
RRPosY1,
                                 unsigned short int RRPosX2, unsigned short 
int RRPosY2,
                                 char *Stringa1, char *Stringa2,
                                 unsigned short int ColorText,
                                 unsigned short int ColorButton,
                                 unsigned short int ColorBorderButton,
                                 unsigned char WndHeader);
char ndCTRL_CreateButton_NORENDER (unsigned short int RRPosX1, unsigned 
short int RRPosY1,
                                 unsigned short int RRPosX2, unsigned short 
int RRPosY2,
                                 char *Stringa1, char *Stringa2,
                                 unsigned short int ColorText,
                                 unsigned short int ColorButton,
                                 unsigned short int ColorBorderButton,
                                 unsigned char WndHeader);
char ndCTRL_CreateButtonSmart   (unsigned short int RRPosX1, unsigned short 
RRPosY1,
                                 char *Stringa1, char *Stringa2,
                                 unsigned short int ColorText,
                                 unsigned short int ColorButton,
                                 unsigned short int ColorBorderButton,
                                 struct ndImage_Type *ImageIcon,
                                 unsigned char WndHeader);
char ndCTRL_CreateButtonSmart_NORENDER (unsigned short int RRPosX1, unsigned 
short RRPosY1,
                                 char *Stringa1, char *Stringa2,
                                 unsigned short int ColorText,
                                 unsigned short int ColorButton,
                                 unsigned short int ColorBorderButton,
                                 struct ndImage_Type *ImageIcon,
                                 unsigned char WndHeader);
char ndCTRL_MakeOneButton (char *Message, unsigned short int PosY1, unsigned 
short int PosY2,
                           unsigned short int ColorText, unsigned short int 
ColorButton,
                           unsigned short int ColorBorderButton, unsigned 
short int WndHeader,
                           char AutoClose);
char ndCTRL_MakeTwoButton (char *Message1, char *Message2, unsigned short 
int PosY1, unsigned short int PosY2,
                           unsigned short int ColorText, unsigned short int 
ColorButton,
                           unsigned short int ColorBorderButton, unsigned 
short int WndHeader,
                           char AutoClose);
void ndCTRL_DrawMousePointerInPOS (unsigned short int PosX, unsigned short 
int PosY);
void ndCTRL_HideMousePointer (void);
void ndCTRL_ShowMousePointer (void);
void ndCTRL_EventManager (struct ndEvent_Type *IndirizzoEvento, unsigned 
long ButtonsRec);
int  ndCTRL_DrawMenuWindow (unsigned short int WndPosX1, unsigned short int 
WndPosY1,
                       unsigned short int WndPosX2, unsigned short int 
WndPosY2,
                       char *Titolo, unsigned short int TitleColor, unsigned 
short int TitleBGColor,
                       struct ndMenu_Type *MyMenu);
void MouseControl (struct ndEvent_Type *IndirizzoEvento);
/*
   ------------------------------------------------------------------------------------------
   ROUTINE E STRUTTURE PER LA GESTIONE DI LISTE DI INDIRIZZI
   ------------------------------------------------------------------------------------------
*/
struct HEADLIST_Generic_Type
{
   int FirstElementAddr;
   int LastElementAddr;
   int NrElements;
};
struct ELEMENT_Generic_Type
{
  int Addr;
  int NextElementAddr;
};
void ndDB_InitList (struct HEADLIST_Generic_Type *MyListHeader);
char ndDB_AppendElementToList (struct HEADLIST_Generic_Type *MyListHeader, 
int GenericalAddr);
char ndDB_GetElementFromList (struct HEADLIST_Generic_Type *MyListHeader, 
int NrElement, int AddressGet);
char ndDB_GetLastElementFromList (struct HEADLIST_Generic_Type 
*MyListHeader, int AddressGet);
char ndDB_SwapElementInList (struct HEADLIST_Generic_Type *MyListHeader, int 
NrElement);
char ndDB_RemoveLastElementFromList (struct HEADLIST_Generic_Type 
*MyListHeader);
void ndDB_DestroyList (struct HEADLIST_Generic_Type *MyListHeader);
/*
   -------------------------------------------------------------------------------------------
   TIPI VARIABILI E ROUTINE PER LA GESTIONE DI LISTE DI ICONE
   -------------------------------------------------------------------------------------------
*/
struct HEADLIST_Icon_Type
{
   int FirstElementAddr;
   int LastElementAddr;
   int NrElements;
};
struct ELEMENT_Icon_Type
{
  char                        StringID [12];
  char                        Format;             // Segnala se l'icona č 
8x8, 16x16 o 22x22 pixel
  TypeColor                   MNPixel [22][22];   // Magic Number dei pixel
};
extern struct HEADLIST_Icon_Type SystemIcons;     // Struct che contiene le 
icone di sistema
void ndDB_InitListOfIcons (struct HEADLIST_Icon_Type *MyListHeader);
char ndDB_IsPresentIconStringID (struct HEADLIST_Icon_Type *MyListHeader, 
char *StringID);
char ndDB_AppendIconToList (struct HEADLIST_Icon_Type *MyListHeader, char 
*StringID, char Format, struct ndImage_Type *MyImage);
char ndDB_GetIconFromList ( struct HEADLIST_Icon_Type *MyListHeader, char 
*StringID, struct ELEMENT_Icon_Type *MyIcon);
char ndDB_GetIconAddrFromList ( struct HEADLIST_Icon_Type *MyListHeader, 
char *StringID, int *AddrMyIconPointer);
char ndDB_RemoveIconFromList (struct HEADLIST_Icon_Type *MyListHeader, char 
*StringID);
void ndDB_DestroyListOfIcon (struct HEADLIST_Icon_Type *MyListHeader);
void ndIMG_ShowIcon (struct ELEMENT_Icon_Type *MyIcon, unsigned short int 
RRPosX, unsigned short int RRPosY, char XWndHeader);
// Alias per le icone di sistema
#define  IDQuestionPoint    "SYS0000"
#define  IDFolderIcon       "SYS0001"
#define  IDFolderExitIcon   "SYS0002"
#define  IDImageIcon        "SYS0003"
#define  IDOfficeIcon       "SYS0004"
#define  IDVideoIcon        "SYS0005"
#define  IDAudioIcon        "SYS0006"
#define  IDPDFIcon          "SYS0007"
/*
   -------------------------------------------------------------------------------------------
   TIPI VARIABILI E ROUTINE PER LA GESTIONE DELLE LISTE DI CLASSI
   -------------------------------------------------------------------------------------------
*/
struct HEADLIST_Class_Type
{
   int FirstElementAddr;
   int LastElementAddr;
   int NrElements;
};
struct ELEMENT_Class_Type
{
  char NameClass    [64];
  char Extensions   [255];
  char StringIDIcon [12];     // La stringID dell'icona associata al tipo
  int  ThumbFunction;
  // Indirizzo di una funzione che esegue una preview (thumbnail) del file 
in questione
};
extern struct HEADLIST_Class_Type SystemClasses;    // Struct che contiene 
le CLASSI di sistema
void ndDB_InitListOfClasses (struct HEADLIST_Class_Type *MyListHeader);
char ndDB_IsPresentSameNameClass (struct HEADLIST_Class_Type *MyListHeader, 
char *NameClass);
char ndDB_AppendClassToList (struct HEADLIST_Class_Type *MyListHeader, char 
*NameClass,
                        char *Extensions, char *StringIDIcon, int 
PointerToThumbFunc);
char ndDB_GetClassFromList ( struct HEADLIST_Class_Type *MyListHeader, char 
*NameClass,
                        struct ELEMENT_Class_Type *MyClass);
char ndDB_GetClassAddrFromList ( struct HEADLIST_Class_Type *MyListHeader, 
char *NameClass,
                            int *PointerToClassAddr);
char ndDB_RemoveClassFromList (struct HEADLIST_Class_Type *MyListHeader, 
char *NameClass);
void ndDB_DestroyListOfClass (struct HEADLIST_Class_Type *MyListHeader);
char ndDB_FindClassFromExtension (struct HEADLIST_Class_Type *MyListHeader, 
char *Ext,
                             struct ELEMENT_Class_Type *MyClass);
char ndDB_FindClassAddrFromExtension (struct HEADLIST_Class_Type 
*MyListHeader, char *Ext,
                                 int *MyClassAddr);
char ndDB_ModifyClass (struct HEADLIST_Class_Type *MyListHeader, char 
*OldNameClass, char *NewNameClass,
                           char *Extensions, char *StringIDIcon, int 
PointerToThumbFunc);
/*
   -------------------------------------------------------------------------------------------
   TIPI VARIABILI E ROUTINE PER LA GESTIONE DELLE LISTE DI FILE
   -------------------------------------------------------------------------------------------
*/
struct HEADLIST_File_Type
{
   int FirstElementAddr;
   int LastElementAddr;
   int NrElements;
};
struct ELEMENT_File_Type
{
  char                        Name [64];
  char                        Ext  [3];
  int                         Size;
  char                        IsDir;
  struct ndFS_DateTime_Type   DateTime;
};
void ndDB_InitListOfFile (struct HEADLIST_File_Type *MyListHeader);
char ndDB_AppendFileToList (struct HEADLIST_File_Type *MyListHeader, char 
*Namefile, char Ext[3], int Size, char IsDir,
                            struct ndFS_DateTime_Type *MyDateTime);
char ndDB_GetFileFromList ( struct HEADLIST_File_Type *MyListHeader, int 
NrElement, struct ELEMENT_File_Type *MyFile);
char ndDB_GetFileAddrFromList ( struct HEADLIST_File_Type *MyListHeader, int 
NrElement, struct ELEMENT_File_Type *AddressGet);
char ndDB_SwapFileInList (struct HEADLIST_File_Type *MyListHeader, int 
NrElement);
char ndDB_RemoveLastFileFromList (struct HEADLIST_File_Type *MyListHeader);
void ndDB_DestroyListOfFile (struct HEADLIST_File_Type *MyListHeader);
char ndDB_CompareFile (char *Name1, char *Ext1, char IsDir1, char *Name2, 
char *Ext2, char IsDir2);
char ndDB_FillFileList (char *DirPath, struct HEADLIST_File_Type 
*MyListHeader);
/*
   ----------------------------------------------------------------------------------------
   ROUTINE PER LA GESTIONE DELLE THUMBNAIL
   ----------------------------------------------------------------------------------------
*/
char ndIMG_CreateThumbnailFromImage (struct ndImage_Type *ThumbImage, char 
*CompleteNameFile,
                                 unsigned short int KLenX, unsigned short 
int KLenY);
void ndFM_EnableThumbnail ();
void ndFM_DisableThumbnail ();
/*
   -----------------------------------------------------------------------------------------
   FILE MANAGER DI TIPO 2
   -----------------------------------------------------------------------------------------
   Le seguenti routine riguardano il file manager di tipo 2
   -----------------------------------------------------------------------------------------
*/
char FileManager (char *Title, unsigned char TypeManager, unsigned char 
SaveMode, char *StringOutputAddr);
/*
   -----------------------------------------------------------------------------------------
   API STD-IN
   -----------------------------------------------------------------------------------------
*/
#ifndef __STDIN_EMU_H__
        #define __STDIN_EMU_H__
extern char SystemKeyboardType;
extern char SystemKeyboardAutoClose;
extern struct NNMData_Type NNMSystemRecord;
void ndInitStdInSystem ();
char ndSET_SystemKeyboardType (char Type);
char ndSET_SystemKeyboardAutoClose (char Value);
int ndGetChar ();
int ndCloseSystemKeyboard ();
#endif
/*
   -----------------------------------------------------------------------------------------
    DIALOG-BOX STD-OUT, STD-ERR
   -----------------------------------------------------------------------------------------
*/
#ifndef __STDOUT_EMU_H__
        #define __STDOUT_EMU_H__
extern char StdOutWindowActivated;
extern unsigned short int StdOutPosX1, StdOutPosY1, StdOutPosX2, 
StdOutPosY2;
extern TypeColor StdOutColorTitle, StdOutColorBGTitle, StdOutColorWindow, 
StdOutColorBorderWindow;
extern TypeColor StdOutColorText, StdOutColorTextErr;
extern char      StdOutWindowHandler;
// Routine dell'API di controllo
void ndInitStdOutSystem ();
int  ActivateStdOutDialogBox ();
int WriteToStdOut (char Carattere, char TypeChannel, char RenderNow);
void DisableStdOutDialogBox ();
#endif
/*
   -----------------------------------------------------------------------------------------
   ROUTINE PER INTERAZIONE CON IL SISTEMA OPERATIVO
   -----------------------------------------------------------------------------------------
*/
void ndSystemHalt (int ExitCode);
#ifdef __cplusplus
}
#endif
#endif
// Chiude la parentesi di compilazione condizionale legata alla presenza del 
simbolo _PSPWINDOWS_H


The optimist thinks this is the best of all possible worlds.
The pessimist fears it is true.      [J. Robert Oppenheimer]

 compilatore, non li usare.
non sono quelli che iniziano per underscore e che sono tutti maiuscoli?
peccato che non ho ancora potuto guardarlo con calma, ma a occhio ci
vedo degli errori.... tutti quegli extern non mi sembrano sani di mente
e ci sono dei define non troppo felici....

 e ci sono dei define non troppo felici....
Beh almeno l'extern "C" per il C++/Pascal c'e` :)


 
e scrivi solo
#endif /* _PSPWINDOWS_H */
un po' di sintesi.


E' solo un caso: ci possono essere liste concatenate in cui
l'headlist contiene informazioni aggiuntive....
Ciao
Pegasus

 compilatore, non li usare.
Io non so praticamente niente di C, ma davvero non devono cominciare per 
underscore?
Praticamente tutto in linux/include inizia cosě :/
-- 
blog en: 
http://www.riffraff.info
blog it: 
http://riffraff.blogsome.com
jabber : rff.rff at gmail dot com

 Praticamente tutto in linux/include inizia cosě :/
Permettimi una domanda. Se tu non capisci nulla di c, perche' vai a 
spulciare in linux/include?
Intendo dire, quale sottile goduria si assapora a leggere degli header che 
manco si capiscono? 

 manco si capiscono? 
il _praticamente_ significa che non sono un programmatore C di mestiere 
e non scrivo software in C per mestiere, non che non abbia mai scritto 
una riga in quel linguaggio ho fatto qualche tesina di sistemi operativi :P


 l'headlist contiene informazioni aggiuntive....
 sarò il caso, ma leggendo non sembra proprio.
A quando i .c?

 Praticamente tutto in linux/include inizia cosě :/
Che infatti compila con -std=gnu. Mi sa tanto che se fai un bel
gcc -Wall -pedantic -std=c99
qualche errore lo trovi. Forse.
-- 
Sensei <senseiwa@Apple's mail>
Research (n.): a discovery already published by a chinese guy one month
               before you, copying a russian who did it in the 60s.

 ecazo, per fare delle funzioni debug..... quanto vi vuole?
Un semplice ifdef gli basterebbe, ma tant'e`.
Pegasus, puoi fare una cosa del genere (quella che uso sempre io nei 
miei codici):
#ifdef DEBUG
    #define LOG(...) \
        do \
        { \
            time_t now = time(NULL); \
            struct tm *now_s = localtime(&now); \
            printf("LOG [%02d:%02d:%02d] ", \
                   now_s->tm_hour, now_s->tm_min, now_s->tm_sec); \
            fflush(stdout); \
            printf(__VA_ARGS__); \
        } while(0)
#else
        #define LOG(...)
#endif
Usando un makefile opportuno (e gli include giusti)...


 qualche errore lo trovi. Forse.
ah giusto, grazie :)



Scusa Sensei, ma questo pezzo di codice funziona a condizione che
localtime (&now) riporti l'ora e la ponga nella struct now_s.
Ma se tu devi leggere dal tuo programma il valore delle variabili interne
di una routine in una tua libreria (che è per definizione *esterna* al
tuo programma), l'unica è dichiarare extern tale variabile nel file di
definizione .h, in modo che tu possa accederci da qualsiasi punto.
E' ovvio che quando il debug sarà finito, anch'io avrò una bella
ndINFO_GetInfo (...)
che mi fornirà i valori necessari senza bisogno di dichiarare extern
le variabili interne alla libreria, ma al momento non può essere così....

 qualche errore lo trovi. Forse.
ma da nessuna parte c'č scritto che il kernel di linux č ANSI C 99. Mi
spiego: buona parte dei file sono stati aggiornati per la nuova
sintassi, ma afaik nessun kernel puň essere standard ansi al 100%,
perché c'č la parte di boot che non puň essere standard.

 le variabili interne alla libreria, ma al momento non può essere così....
considerando che una funzione può essere fatta in una manciata di minuti
e che dici che non hai tempo, come hai fatto a programmare finora?
PS: non è proprio detto che ti serva dichiarare la variable extern.
Infatti se nel file dove è dichiarata non è static è discrezione del
compilatore se  deve considerrla statica o meno

 compilatore se  deve considerrla statica o meno
AFAIR, in C se una variabile con scope globale non e' static,
e' visibile negli altri moduli e questo NON e' a discrezione
del compilatore. Se un compilatore si comporta diversamente
ha un bug.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 definizione .h, in modo che tu possa accederci da qualsiasi punto.
Pegasus ma compilare una libreria in debug mode non ti viene in mente? 
Testare la libreria? Unit tests?


 ha un bug.
sul ng del c a suo tempo la pensavano diversamente...
oh, sia chiaro, relata refero.

 
Su iclc ci ho bazzicato parecchio e non ricordo niente del
genere. :-)
In ogni caso
<CITE ISO/IEC ISO/IEC 9899:1999 pag. 31>
... If
the declaration of an identifier for an object has file scope
and no storage-class specifier, its linkage is external.
</CITE>


 Testare la libreria? Unit tests?
Che infatti č quello che faccio, solo che quegli extern servono per
comoditŕ mia.
Non vi focalizzate solo sugli extern: molti sono provvisori.....

> Testare la libreria? Unit tests?
Fai sti unit test con una bella libreria in debug mode.



Ed infatti NanoC contiene tutte le funzioni che dici: printf, fopen, fclose,
sono tutte lì....

 Tra parentesi: una libc, di solito, è autonoma.
E questa cosa *DOVE* l'avresti letta di grazia?



Scusami, intendevo dire che la dipendenza avviene
esclusivamente in verticale.
Quindi la libc implementa tutto in termini di chiamate
all'OS sottostante.
Ciò che si trova sopra (applicazioni, o librerie) dipende
dalla libc, ma non viceversa.
Invece, in Nanodesktop c'è una dipendenza orizzontale.
libnanodesktop_PSPE.a ha bisogno di libNanoC_PSPE.a
per funzionare e **viceversa**.
Questo ha delle implicazioni: per esempio la necessità di
scrivere:
psp-ld --start-group -lNanoC_PSPE -lNanodesktop_PSPE
--end-group.
Ma purtroppo non ci posso proprio fare nulla.
Indovina perchè.....

 Indovina perchč.....
Perche` hai una libc di merda e forse hai cominciato a scrivere prima 
di progettare, come accade al 99% dei casi.
Non esistono ``dipendenze orizzontali''. Una dipendenza e` verticale, e 
le mutue dipendenze fanno molto male, un poco di teoria basta per 
comprenderlo.



Ehm....
stavolta purtroppo le cose non stanno esattamente cosě.....
Supponiamo che io voglia fare una cosa del genere:
fread (stdin, 1, 1, &Carattere);
Normalmente, sul PC, la fread implementata nella libc
richiama una funzione del kernel dell'OS che legge un
tasto dalla tastiera.
Ma sulla PSP non si puň fare questo ed č qui che casca
l'asino. Semplicemente perchč la tastiera non c'č.
La mia NanoC allora richiama il codice della Virtual
Keyboard in libNanodesktop_PSPE.a in modo da
potere emulare una tastiera sullo schermo.
D'altra parte, Nanodesktop ha bisogno di funzioni
come strlen(), strcmp(), malloc(), free() ecc. ecc.
per funzionare. E questo significa che Nanodesktop
ha bisogno della libc, cosě come la libc ha bisogno
di Nanodesktop.
Ecco spiegato il problema.
Gli sviluppatori della libc originale della PSP (libc.a),
quelli del gruppo PSPDEV per intenderci, si sono
resi perfettamente conto del problemuccio ed
hanno risolto in modo elegantissimo: ogni volta
che tu puoi a leggere da stdin o a scrivere su
stdout/stderr, fread ed fwrite ignorano la
richiesta di lettura e scrittura.
In questo modo, funzioni come fgets, fgetc, getchar se
ne vanno allegramente a farsi friggere.
Inoltre, siccome non č possibile scrivere su stdout, ecco
che se ne vanno a farsi friggere printf e derivate costringendo
il programmatore PSP a quel meraviglioso
#define DebugScreenPrintf printf
che tanto ti era piaciuto l'altra volta.....
:)))))
La mia NanoC invece, emulando una tastiera sullo schermo
e fornendo un terminale stdout/stderr, consente di recuperare
il 99% delle funzioni C che ci sono note.
Purtroppo con quella brutta mutua dipendenza, ma io
dico che č sempre meglio che lavorare con la libc di
PS2DEV......
Molto, molto, molto meglio....
Ciao
Pegasus

 Molto, molto, molto meglio....
Le mutue dipendenze ti fanno capire che FORSE dovrebbero essere la 
stessa libreria. Vedi la libSystem.
