Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Estrazione - inizializzazione.cpp

inizializzazione.cpp

 Caricato da: AldoBaldo
Scarica il programma completo

  1. #include "inizializzazione.h"
  2.  
  3.  
  4. extern const char *kStrNomiPulsanti[kTotPulsanti];
  5.  
  6.  
  7. // collocazione e dimensioni degli elementi dell'interfaccia
  8. static const UINT margine        = 0.0125f*kWFinPrinc;
  9. static const UINT wElenchi       = 0.4f*(kWFinPrinc-4*margine);
  10. static const UINT wEstratto      = kWFinPrinc-2*margine;
  11. static const UINT wPulsanti      = kWFinPrinc-4*margine-2*wElenchi;
  12. static const UINT hEstratto      = 0.135f*(kHFinPrinc-3.50f*margine);
  13. static const UINT hEtElenchi     = 1.75f*margine;
  14. static const UINT hElenchi       = kHFinPrinc-3.25f*margine-hEtElenchi-hEstratto;
  15. static const UINT hPulsanti      = 0.085f*kHFinPrinc;
  16. static const UINT hInfo          = kHFinPrinc-(9.25f*margine+hEstratto+hEtElenchi+6.50f*hPulsanti);
  17. static const REAL dimFontEstr    = 0.55f*hEstratto;
  18. static const REAL dimFontEl      = 0.0286f*hElenchi;
  19. static const REAL dimFontPuls    = 0.5f*hPulsanti;
  20.  
  21.  
  22. /// === FUNZIONE DI SUPPORTO A WINMAIN() =======================================
  23.  
  24. UINT RegistraClasseFinestraPrincipale( GLOBALE *g ) {
  25.     WNDCLASSEX wc = {0};
  26.  
  27.     wc.cbSize      = sizeof(WNDCLASSEX);
  28.     wc.lpfnWndProc = MainWndProc;
  29.     wc.hInstance   = g->hndIstanza;
  30.  
  31.     wc.hIcon = LoadIcon ( g->hndIstanza, MAKEINTRESOURCE(IDI_ICONAPROGRAMMA) );
  32.         if( wc.hIcon == NULL ) return kErrClasseNonRegistrata;
  33.     wc.hIconSm = LoadIcon( g->hndIstanza, MAKEINTRESOURCE(IDI_ICONAPROGRAMMA) );
  34.         if( wc.hIconSm == NULL ) return kErrClasseNonRegistrata;
  35.     wc.hbrBackground = CreateSolidBrush( kColoreSfondoFinestraPrincipale );
  36.     if( wc.hbrBackground == NULL ) return kErrClasseNonRegistrata;
  37.  
  38.     wc.lpszClassName = kStrNomeClasse;
  39.  
  40.     if( RegisterClassEx(&wc) != 0 )
  41.         return kErrNessunErrore;
  42.     else return kErrClasseNonRegistrata;
  43. }
  44.  
  45.  
  46. /// === FUNZIONE DI SUPPORTO A WINMAIN() =======================================
  47.  
  48. UINT CreaFinestraPrincipale( HWND *hwnd, GLOBALE *g, int nCmdShow ) {
  49.     RECT wndRect = { 0, 0, kWFinPrinc, kHFinPrinc };
  50.  
  51.     AdjustWindowRectEx( &wndRect, kStileFinPrinc, FALSE, kStileExtFinPrinc );
  52.  
  53.     int wFin = wndRect.right - wndRect.left;
  54.     int hFin = wndRect.bottom - wndRect.top;
  55.  
  56.     if( wFin > kWInizialeSchermo || hFin > kHInizialeSchermo )
  57.         return kErrSchermoTroppoPiccolo;
  58.  
  59.     *hwnd = CreateWindowEx(
  60.         kStileExtFinPrinc,
  61.         kStrNomeClasse,
  62.         kStrNomeProgramma,
  63.         kStileFinPrinc,
  64.         (kWInizialeSchermo-wFin)/2, // centrata
  65.         (kHInizialeSchermo-hFin)/2, // centrata
  66.         wFin, hFin,
  67.         GetDesktopWindow(),         // la genitrice
  68.         (HMENU) NULL,               // il menu
  69.         g->hndIstanza, NULL);
  70.  
  71.     if( *hwnd == NULL ) return kErrFinestraNonCreata;
  72.  
  73.     // "collega" g alla finestra appena creata
  74.     SetLastError( 0 );
  75.     LONG esito = SetWindowLong( *hwnd, GWL_USERDATA, (LONG)g );
  76.     if( esito==0 && GetLastError()!=0 ) return kErrFinestraNonCreata;
  77.  
  78.     ShowWindow( *hwnd, nCmdShow );
  79.  
  80.     return kErrNessunErrore;
  81. }
  82.  
  83.  
  84. UINT RicavaPercorsoFile( HWND hwnd, GLOBALE *g, LPSTR lpCmdLine ) {
  85.     if( (g->percorso_file=RicavaPrimoFileTrascinato(lpCmdLine)) == NULL )
  86.         return kErrMemoriaInsufficiente;
  87.  
  88.     if( *g->percorso_file == '\0' )
  89.         g->percorso_file = IdentificaFile( hwnd, kStrEstensioneFile );
  90.  
  91.     return kErrNessunErrore;
  92. }
  93.  
  94.  
  95. /// === FUNZIONE DI SUPPORTO A WINMAIN() =======================================
  96. //  Chiamata PRIMA della creazione della finestra principale del programma
  97.  
  98. UINT InizializzaGlobale( GLOBALE *g, HINSTANCE hndIstanza ) {
  99.     UINT errore = kErrNessunErrore;
  100.  
  101.     g->hndIstanza = hndIstanza;
  102.  
  103.     errore = InizializzaGdiPlus();
  104.  
  105.     return errore;
  106. }
  107.  
  108.  
  109. static int CaricaScorciatoie( HWND hwnd );
  110. static int CaricaCursore( HWND hwnd );
  111. static int CreaOffscreen( HWND hwnd );
  112. static int CreaRiquadri( HWND hwnd );
  113. static int CreaEstrazione( HWND hwnd, const char *dati );
  114.  
  115.  
  116. //  Chiamata DOPO la creazione della finestra principale del programma
  117.  
  118. UINT InizializzaProgramma( HWND hwnd ) {
  119.     GLOBALE *g = RicavaDatiGlobali( hwnd );
  120.     UINT errore = kErrNessunErrore;
  121.  
  122.     if( (errore=CaricaScorciatoie(hwnd))!=kErrNessunErrore ) return errore;
  123.     if( (errore=CaricaCursore(hwnd))!=kErrNessunErrore ) return errore;
  124.  
  125.     const char *dati = CaricaFileDiTesto( g->percorso_file );
  126.     if( dati == NULL ) return kErrDatiNonCaricati;
  127.  
  128.     errore = CreaEstrazione( hwnd, dati );
  129.     if( errore!=kErrNessunErrore )
  130.         { delete[] dati; return errore; }
  131.     else delete[] dati;
  132.  
  133.     if( (errore=CreaOffscreen(hwnd))!=kErrNessunErrore ) return errore;
  134.     if( (errore=CreaRiquadri(hwnd))!=kErrNessunErrore ) return errore;
  135.  
  136.     AggiornaStatoPulsanti( hwnd );
  137.     TracciaFinestraPrincipale( hwnd );
  138.  
  139.     return errore;
  140. }
  141.  
  142.  
  143. int CaricaScorciatoie( HWND hwnd ) {
  144.     GLOBALE *g = RicavaDatiGlobali( hwnd );
  145.     g->hndScorciatoie = LoadAccelerators(
  146.         g->hndIstanza, MAKEINTRESOURCE(IDR_SCORCIATOIE) );
  147.     if( g->hndScorciatoie == NULL )
  148.         return kErrScorciatoieNonCaricate;
  149.     else return kErrNessunErrore;
  150. }
  151.  
  152.  
  153. int CaricaCursore( HWND hwnd ) {
  154.     GLOBALE *g = RicavaDatiGlobali( hwnd );
  155.     g->hndCursore[kCursoreFreccia] = LoadCursor( NULL, IDC_ARROW );
  156.     if( g->hndCursore[kCursoreFreccia] == NULL ) return kErrCursoreNonCaricato;
  157.     SetCursor( g->hndCursore[kCursoreFreccia] );
  158.  
  159.     g->hndCursore[kCursoreMano] = LoadCursor( NULL, IDC_HAND );
  160.     if( g->hndCursore[kCursoreMano] == NULL )
  161.         return kErrCursoreNonCaricato;
  162.     else return kErrNessunErrore;
  163. }
  164.  
  165.  
  166. int CreaOffscreen( HWND hwnd ) {
  167.     GLOBALE *g = RicavaDatiGlobali( hwnd );
  168.  
  169.     try { // crea l'offscreen
  170.         g->os = new OFFSCREEN( hwnd );
  171.         g->os->set_sfondo( kColoreSfondoFinestraPrincipale );
  172.         g->os->cancella();
  173.         return kErrNessunErrore;
  174.     } catch( const char *err ) {
  175.         return kErrOffscreenNonValido;
  176.     }
  177. }
  178.  
  179.  
  180. int CreaRiquadri( HWND hwnd ) {
  181.     GLOBALE *g = RicavaDatiGlobali( hwnd );
  182.     int i, x, y, wBordo;
  183.  
  184.     try { // crea il riquadro del nome estratto
  185.         wBordo = 0.00416f*kWFinPrinc>1 ? 0.00416f*kWFinPrinc : 1;
  186.         x = margine;
  187.         y = margine;
  188.  
  189.         g->riqEstratto = new PULSANTE( x,y,wEstratto,hEstratto );
  190.         g->riqEstratto->set_offscreen( g->os );
  191.         g->riqEstratto->set_dimensione_font( dimFontEstr, FALSE );
  192.         g->riqEstratto->set_spessore_bordo( wBordo, FALSE );
  193.         g->riqEstratto->set_colori_tratto(
  194.             0xFF666666, 0xFF000000, 0xFFFF9900, 0xFFFF9900, 0xFF000000 );
  195.     } catch( const char *err ) {
  196.         return kErrRiqElenchiNonCreati;
  197.     }
  198.  
  199.     try { // crea i riquadri degli elenchi
  200.         wBordo = 0.00208f*kWFinPrinc>1 ? 0.00208f*kWFinPrinc : 1;
  201.         x = margine;
  202.         y = hEstratto+2.25f*margine+hEtElenchi;
  203.  
  204.         for( i=0; i<kTotElenchi; x+=wElenchi+margine, ++i ) {
  205.             g->riqElenchi[i] = new PULSANTE( x,y,wElenchi,hElenchi );
  206.             g->riqElenchi[i]->set_offscreen( g->os );
  207.             g->riqElenchi[i]->set_dimensione_font( dimFontEl, FALSE );
  208.             g->riqElenchi[i]->set_allineamento_verticale( -1, FALSE );
  209.             g->riqElenchi[i]->set_allineamento_orizzontale( -1, FALSE );
  210.             g->riqElenchi[i]->set_spessore_bordo( wBordo, FALSE );
  211.         }
  212.     } catch( const char *err ) {
  213.         return kErrRiqElenchiNonCreati;
  214.     }
  215.  
  216.     try { // crea le etichette degli elenchi
  217.         x = margine;
  218.         y = 2*margine+hEstratto;
  219.  
  220.         for( i=0; i<kTotElenchi; x+=wElenchi+margine, ++i ) {
  221.             g->riqEtElenchi[i] = new PULSANTE( x,y,wElenchi,hEtElenchi );
  222.             g->riqEtElenchi[i]->set_offscreen( g->os );
  223.             g->riqEtElenchi[i]->set_dimensione_font( dimFontEl, FALSE );
  224.             g->riqEtElenchi[i]->set_allineamento_verticale( -1, FALSE );
  225.             g->riqEtElenchi[i]->set_allineamento_orizzontale( -1, FALSE );
  226.             g->riqEtElenchi[i]->set_spessore_bordo( 0, FALSE );
  227.         }
  228.     } catch( const char *err ) {
  229.         return kErrRiqElenchiNonCreati;
  230.     }
  231.  
  232.     try { // crea i pulsanti
  233.         x = 3*margine+2*wElenchi;
  234.         y = hEstratto+2.25f*margine+hEtElenchi;
  235.         wBordo = 0.00416f*kWFinPrinc>1 ? 0.00416f*kWFinPrinc : 1;
  236.  
  237.         for( i=0; i<kTotPulsanti; y+=hPulsanti+margine, ++i ) {
  238.             g->pulsanti[i] = new PULSANTE(
  239.                 x, y, wPulsanti, hPulsanti, kStrNomiPulsanti[i] );
  240.             g->pulsanti[i]->set_offscreen( g->os );
  241.             g->pulsanti[i]->set_dimensione_font( dimFontPuls, FALSE );
  242.             g->pulsanti[i]->set_spessore_bordo( wBordo, FALSE );
  243.  
  244.             if( i==kPPEstrai ) {
  245.                 g->pulsanti[i]->set_rettangolo(
  246.                     x, kHFinPrinc-margine-1.50f*hPulsanti,
  247.                     wPulsanti, 1.50f*hPulsanti );
  248.                 g->pulsanti[i]->set_dimensione_font( 1.50f*dimFontPuls );
  249.                 y -= hPulsanti+margine;
  250.             }
  251.         }
  252.     } catch( const char *err ) {
  253.         return kErrPulsantiNonCreati;
  254.     }
  255.  
  256.     try { // crea il riquadro delle informazioni
  257.         x = 3*margine+2*wElenchi;
  258.         y = hEstratto+2.25f*margine+hEtElenchi+5*(hPulsanti+margine);
  259.         wBordo = 0;
  260.  
  261.         g->riqInfo = new PULSANTE( x,y,wPulsanti,hInfo );
  262.         g->riqInfo->set_offscreen( g->os );
  263.         g->riqInfo->set_dimensione_font( dimFontEl, FALSE );
  264.         g->riqInfo->set_spessore_bordo( wBordo, FALSE );
  265.         g->riqInfo->set_allineamento_verticale( 1, FALSE );
  266.         g->riqInfo->set_allineamento_orizzontale( -1, FALSE );
  267.  
  268.         g->riqInfo->set_titolo( ComponiStrInfo(), FALSE );
  269.     } catch( const char *err ) {
  270.         return kErrPulsantiNonCreati;
  271.     }
  272.  
  273.     return kErrNessunErrore;
  274. }
  275.  
  276.  
  277. int CreaEstrazione( HWND hwnd, const char *dati ) {
  278.     GLOBALE *g = RicavaDatiGlobali( hwnd );
  279.  
  280.     try {
  281.         g->e = new ESTRAZIONE( dati );
  282.         return kErrNessunErrore;
  283.     } catch( ... ) {
  284.         return kErrEstrazioneNonImpostata;
  285.     }
  286. }
  287.  
  288.  
  289. /// === FUNZIONE PER LA DISMISSIONE DELLE STRUTTURE EVENTUALMENTE ALLOCATE =====
  290. //  Chiamata appena prima che venga interrotta l'esecuzione del programma.
  291.  
  292. void DismettiTutto( GLOBALE *g ) {
  293.     int i;
  294.  
  295.     delete g->e; g->e = NULL;
  296.  
  297.     delete g->riqEstratto; g->riqEstratto = NULL;
  298.  
  299.     for( i=0; i<kTotElenchi; ++i ) {
  300.         delete g->riqElenchi[i]; g->riqElenchi[i] = NULL;
  301.         delete g->riqEtElenchi[i]; g->riqEtElenchi[i] = NULL;
  302.     }
  303.  
  304.     for( i=0; i<kTotPulsanti; ++i )
  305.         { delete g->pulsanti[i]; g->pulsanti[i] = NULL; }
  306.  
  307.     delete g->riqInfo; g->riqInfo = NULL;
  308.  
  309.     delete g->os; g->os = NULL;
  310.  
  311.     delete[] g->percorso_file; g->percorso_file = NULL;
  312.  
  313.     // altre dismissioni da definire
  314.  
  315.     DismettiGdiPlus();
  316. }
  317.  
  318.  
  319. /// === FUNZIONI RELATIVE ALLA PREDISPOSIZIONE DI GDI+, SE RICHIESTA ===========
  320.  
  321. static ULONG_PTR gdiplusToken = 0;
  322.  
  323. UINT InizializzaGdiPlus( void ) {
  324.     GdiplusStartupInput gdiplusStartupInput;
  325.  
  326.     if( GdiplusStartup( &gdiplusToken, &gdiplusStartupInput, NULL ) != Ok )
  327.         return kErrGDIPlusNonInizializzato;
  328.  
  329.     return kErrNessunErrore;
  330. }
  331.  
  332. void DismettiGdiPlus( void ) {
  333.     GdiplusShutdown( gdiplusToken );
  334. }