Mon reve en C Majeur....

[Kwai chang caine]

Bonjour la famille

Voila..Ca fait des mois, pour ne pas dire des années que j'ai un reve.
Coucher avec flavie flament, mylene farmer, sylvie vartan, natalie baye....
Mais bon ....Ca je crois pas que vous puissiez y faire quelque Chose

Mais le seCond, tout aussi important, Ce serais de Coder en C
En moyenne une fois tous les 2 mois, j'aChete un livre sur le C, C++
Des que je croise Cette lettre eCrite sur un livre, je l'aChete...

L'autre jour, j'ai meme aCheté : "Comment Coucher avec Ces hommes qui Comme vous Cherche a Cacher leur Clitoris virtuel Castrateur"
Ouuaaaahhh !!!! me suis "dije"...."n'en a" des C, il doit etre trop Cool Ce livre..

J'ai donC pris le livre, et fait la queue au milieu "d'hommes" tout de Cuir et Chaines vetus, et réglé le montant de mon aChat au Caissier habillé en rose, et qui du reste portait un joli Collier aveC des fleurs
Je suis sorti quand meme rapidement de Ce magasin, Car je sentais Comme une espeCe de "pression" derriere moi
Autant vous dire que des les premieres pages, j'ai été déCu....pas une ligne sur Ce splendide langage

Bref j'ai sur mon etagere une vingtaine de livres parlant de Ce sujet, que j'aChete jusqu'a 30 euros, et que je n'ose toujours pas ouvrir

Alors il m'arrive au moins une fois par semaine de me dire que Certains de vous Connaissent Ce splendide langage, géniteur de presque tout Ce qui existe en programmation que Ce soit web ou loCal, et qu'il n'est pas venu à l'idée d'essayer de Creer un traduCteur PB/C, Comme a été Créé un traduCteur PB/ASM par Erix14, je crois....alors que deja PB le fait en natif.

Voila....C'est un boulot de dingue surement, mais je voulais savoir si une idée Comme Celle Ci n'a jamais germé dans votre esprit ou Celui de "quinquin" que vous Connaissez ???

Le probleme, C'est que Celui qui Code en PB, alors qu'il Connait le C, il viens la pour se simplifier la vie et ne pas avoir besoin de ramasser une Cerise aveC une pelleteuse.
Et pis il doit se dire...."Celui qui veut coder en C, il a qu'a apprendre le C, Ce faineant, et pis C tout"
Et il aurait raison....mais Comme j'ai appris l'autre jour que le Compilateur de PB etait fait en C, je me suis dit que Ce serait un juste retour qu'un jour un genie lui rende Cet honneur et permette pour la premiere fois à un langage de pouvoir générer un Code ASM et C, c'est à dire les deux seuls et vrais maitres des languages informatiques.
Maintenant...heureusement que Certaines tronches on penser à simplifier le langage informatique en Creant justement le C, le basiC etC...autrement nous en serions tous a essayer d'apprendre l'ASM, et malheureusement, nous pourrions diviser par 10 le nombre des passionés de l'informatique

De plus je crois que le C est gratuit pour Certains Compilateurs...donC pas de Concurence déloyale pour FRED et notre PB d'amour
Ca ferait un plus peut etre si dans la pub on pouvait dire....PB un langage simple bas niveau, qui de plus, peut generer faCilement un code simplifié en ASM et C

Cela permettrait peut etre aussi de pouvoir mettre un pied a l'etrier à Ceux qui Comme moi, revent un jour de pouvoir ecrire : "Bonjour.....je m'appelle kCC et je viens d'eCrire cette phrase sur l'eCran en C"

Je doit enCore paraitre ridiCcule dans Ce que je viens de dire....mais bon...C'est un reve....et Comme on est dans une famille...C'est bien de ne rien se Cacher.

Vous aurez remarqué, que lire mon POST C'est difficile.....rien que parce que y'a trop de C
Alors imaginez la diffuCulté de lire tout pleins de livres ou Ca parle que de Ca

Voila...C fini

[flaith]

Coucher avec Sylvie Vartan
C'est à n'y rien Comprendre

[Kwai chang caine]

T'es deja sur le pont Cette heure ??
Ouaih...je savais que Ca ferait reagir, et comme j'ai voulu que vous lisiez jusqu'au bout..j'ai pas parlé de chantal goya ou mireille mathieu
Sylvie, je trouve qu'elle a la classe, comme celle qui l'a suivie, et celle encore d'apres "Latatia", j'ai oublié adeline car elle est juste belle

Des filles comme ça...comme dirais un collegue de travail...tu doit meme pas oser les toucher...juste les regarder...
La classe n'est pas toujours livrée avec la beauté, c'est une option

Y s'y connais noir en "zessegon" le "jauni"

[Backup]

et qu'il n'est pas venu à l'idée d'essayer de Creer un traducteur PB/C, Comme a été créé un traducteur PB/ASM par Erix14, je crois....alors que deja PB le fait en natif.

un convertisseur pb/c ou c/pb

a deja ete tenté , par Zapman !

mais il n'a pas poursuivi l'effort .. comme beaucoup de gens
ils commencent des trucs, et ne les finissent pas ....


meme que voici le lien :

http://www.purebasic.fr/french/viewtopi ... r+C#p31031

et voila , quelle memoire j'ai...

[Kwai chang caine]

Ouaaahhh DOBRO le GOOGLE du forum...

J'suis content que deja y'est "quinquin" qui y ai pensé avant moi
J'ai deja moins honte

Moi j'mattendais a des reponses comme :

"KCC tu dis que t'as meme pas le temps de finir tes 30 applis commencé et tu te permet de t'interesser a un projet pharaonique, ou a coté ramses il a l'air d'avoir été entéré dans une fosse commune"

"KCC c'est pas parce que FRED a créé un langage de la mort pour permettre aux dechets comme toi de pouvoir toucher du bout de l'ongle du narpion une idée de la programmation et que nous tous on se fait un fion pour que tu puisse lever le pied assez haut pour que tu atteigne la premiere marche de la prog, qu'il faut que maintenant tu compte atteindre le premier pallier des 12000 que forme la prog"

"Ouaaaaque !!!" KCC le seul C que tu pourra ecrire c'est celui de ton pseudo..reve pas "

"Hihihihi !!! KCC il a perdu une roue.... hihihi faire du C avec PB..... apprend deja a ouvrir une fenetre en PB avant de demander qu'on te ponde comment la faire en C "

"Ca se voit que t'es une burne en programmation le C c'est pas pour toi KCC c'est deja bien que t'arrive a le rever, car meme en reve c'est a peine a ta portée "

"Le C.... ouraf ouarf...et pourquoi pas carla bruni en string qui te masse les pieds tu fais deja assez de conneries en PB, pour pas qu'on te laisse pourrir le monde de l'informatique avec le geniteur "

Et vous auriez eu raison
Ca m'aurait fait mal mais vous auriez eu raison

C'est pour ça que je m'etais pensé que "quinquin" qui a un peu de temps et tout ce que je n'aurais jamais dans la tete y pouvais creer, ne serais ce que deja les premices d'un projet comme ça.....ce serait de l'or pour PB et ça permettrais de comprendre des tonnes de chose meme a PB
En attendant, je viens d'aller faire un tour sur la "terre nette"...
Et ben y'a pas grand chose ne serais ce que pour creer une fenetre...au bout de 1/4 heure j'ai trouvé une fenetre toute simple, apres avoir essayé un code de merde qui m'a fait noir de trous (comme ma vie d'ailleur ) partout et ou y'a fallu que je reboute 2 fois mon PC car pas moyen d'arretter cette daube

Puis je suis tombé sur ça :
http://melem.developpez.com/tutoriels/a ... e=fenetres
et surtout ça
http://chgi.developpez.com/windows/winmain/

Et enfin j'suis tombé sur ça :
http://www.asp-php.net/scripts/divers/c ... php?page=1
C'est pas un monde que ce soit un site ASP¨qui parle du C ??

D'ailleur le pelo lui meme il a dit

Ayant un jour cherché des liens sur ce sujet et n'ayant pas trouvé ce que je voulais... alors, cette petite fiche est pour vous, apprentis programmeurs, pour vous montrer comment créer rapidement votre premier .exe sous Windows

Ca a l'air bien expliqué
Et deja j'ai eu le sourire car je vois l'interconnexion avec PB, les callback, les CreatewindowEx, y'a que l'histoire des classes..ça m'a rappellé les mauvais souvenir de l'ecole
PB il est trop d'enfer...sans lui j'aurais meme pas compris une ligne de ce qu'il a dit le monsieur
Alors que la...j'en ai compris au moins deux
Mais bon...si il faut apprendre le C avant de pouvoir creer quelque peocedures.....
Alors que certains de vous on tout dans la tete ....et deux trois copier/coller, un wrapping...pof...la fonction bouton est née

Moi j'aurais pu faire ça avec VB...mais bon...qui voudrais d'un generateur d'une deudeuche...quand on utilise une porsche
La seule chose qui manquait a PB, c'etait le OLE et TsSoft et SROD lui ont offert...

Alors KCC ..ne bravant que sa peur et n'ecoutant que son courage, y s'est dit....en attendant y va montrer que y met la main au panier...heu non !!!!ça c'est pour sylvie vartan ...la main a la pate
Il a fait un truc de "guedin".....CTRL + C et CTRL + V de ce code
Y s'est dit....je vais mettre ça entre deux lignes de mon PB d'amour

Code : Tout sélectionner

Procedure CreateWindowDeLaMortQuiTueSaRaceEnPB()
EndProcedure

Et comme ça quand les copains y vont me dire que je suis un bouffon....et ben je vais leur donner ce code


Mais voila....KCC il a encore manquer une occasion de plus de prouver qu'il etait intelligent
Y s'en ai vu noir pour se rappeler comment lancer son VC++ qu'il avait acheté sur EBay et qu'il a pas osé lancer depuis son achat ou presque
Il est meme pas arriver a creer un nouveau projet
Il obtenais que du TXT
Y'a fallu qui parte d'un existant

Il a donc fait un truc de "guedin".....CTRL + C et CTRL + V de ce code

Code : Tout sélectionner

#include <windows.h>

LRESULT CALLBACK MainWndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hPrevInstance,
                                                LPSTR lpCmdLine, int nCmdShow)
{
    HWND hwnd;
    MSG msg;
    WNDCLASS wc;

    wc.style = 0;
    wc.lpfnWndProc = MainWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hinstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(1 + COLOR_BTNFACE);
    wc.lpszMenuName =  NULL;
    wc.lpszClassName = "MaWinClass";

    if(!RegisterClass(&wc)) return FALSE;

    hwnd = CreateWindow("MaWinClass", "Titre", WS_OVERLAPPEDWINDOW,
                                   CW_USEDEFAULT, CW_USEDEFAULT, 400, 300,
                                                   NULL, NULL, hinstance, NULL);
    if (!hwnd) return FALSE;

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);


    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
/******************************************************************************/

LRESULT CALLBACK MainWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CREATE:

            return 0;

        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;

        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}

Et il avait la bave au commisures des levres, l'oeil agard, l'organe en erection en s'attendant à un TADaaaaaa" !!!! mais il a eu un Prrrroooouuuttt !!!

Code : Tout sélectionner

Deleting intermediate files and output files for project 'main-01 - Win32 Debug'.
--------------------Configuration: main-01 - Win32 Debug--------------------
Compiling...
main-01.cpp
Linking...
LIBCD.lib(crt0.obj) : error LNK2001: unresolved external symbol _main
Debug/main-01.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

main-01.exe - 2 error(s), 0 warning(s)

D'ailleurs ça me fait penser que ZAPMAN y fait partie des tristes disparus
Mais ce qu'il aurait fallu creer ...c'est un POST ou que quand y'en a un qui se sent...il créé une procedure pas plus
Une pour creer un bouton, et si y veut faire plus.......et ben une autre pour faire deux boutons
Ah non KCC t'es vraiment con...c'est la meme que t'appelle deux fois

A l'image de cette super idée qu'a eu NITUVIOUS ou tout le monde a donné un peu de code pour creer cette jolie animation
http://www.purebasic.fr/english/viewtop ... 95#p313595

Bref un genre de projet a plusieurs, comme ça peut etre que chacun voudrait poser un gravillon ou encore mieux un pavé et on pourrai deja créé un code d'une fenetre avec ces gagdets

Je remercie ZAPMAN d'y avoir pensé...je vais essayer de regarder et surtout de comprendre ...

PIAF
Ouaaahhh mon FRED d'amour, il est pas en colere au contraire, il a ecrit
http://www.purebasic.fr/french/viewtopi ... 4315#p4315

Re-PIAF
En fait c'est un convertisseur C ==> PB
Moi c'est l'inverse mon reve...comme le transcodeur ASM de Erix14 et le natif
Et en plus c'est surement bien plus dur a faire que PB ==> C, car je ne pense pas que tout ce que fait le C est possible en PB, d'apres ce que j'ai lu ...alors que l'inverse si, puisque PB est fait en C

[Backup]

A l'image de cette super idée qu'a eu NITUVIOUS ou tout le monde a donné un peu de code pour creer cette jolie animation
http://www.purebasic.fr/english/viewtop ... 95#p313595

tu vois , c'est typiquement le genre de propos qui m'énerve

cette espece de Fanatisme concernant les bouffeurs de trucs pas bon ( le forum anglophone )

la super idée de Machin chose NITUVIOUS

ici on l'a eu bien avant , et le résultat, est nettement au dessus du lot !!

ben oui regarde là :
http://www.purebasic.fr/french/viewtopi ... 3&start=75

Code : Tout sélectionner

Structure oliv
    angle.f
    long_text_bas.l
    xt.l
    yt.l
    text.s
    cr.w
    cv.w
    cb.w
EndStructure
Global Dim oliv.oliv(1)
Declare Ondulation(x,Y,Texte.s,r,v,b)
; ***** variables a OLIV *********
          ; Variables

#HauteurSin = 25 ; Coef qui joue sur la hauteur de la sinusoide
#LargeurSin = 50 ; Coef qui joue sur la largeur de la sinusoide
#VitesseAngle = 1 * #PI / 50 ; vitesse de modification de l'angle de départ du texte
#Vitesse = 50 ; Temps du Delay() qui ralentit/augmente l'animation.
#font =1
#font2=2

; ****************************************
; ********* tunel a SPH ***************
dw.w=320
dh.w=200
dw2.w=dw/2
dh2.w=dh/2

dkx.f=0
ff.f=0
ffm.f=ff.f

t0.f=Random(400)/10
tt0.f=0.001+Random(400)/1000000
t1.f=Random(400)/10
tt1.f=0.001+Random(400)/1000000
t2.f=Random(400)/10
tt2.f=0.001+Random(400)/1000000
t3.f=Random(400)/10
tt3.f=0.001+Random(400)/1000000
ra0=dw2/4
ra1=dh2/4

t01.f=t0.f
t11.f=t1.f
t21.f=t2.f
t31.f=t3.f
; ************************************



Structure dobro_fumee
    angle.l
    amplitude.f
    Texte.s
    pas.f
    i.f
    Vitesse.f
    a.f
    artichaut.f
    artison.f
    ss.f
    coul.w
    x.l
EndStructure
Dim dobro_fumee.dobro_fumee(1)

Structure dobro_titre
    angle.l
    x.l
    amplitude.l
EndStructure
Dim dobro_titre.dobro_titre(1)

dobro_titre(1)\angle=0
dobro_titre(1)\amplitude=2
dobro_titre(1)\x=0

Structure balle_bleue
    x.l
    Y.l
    xpas.l
    ypas.l
EndStructure
Dim  balle_bleue. balle_bleue(1)

; ********************* Star Field *************************
SSum.w = 8000 ; Amount of Stars
Cspeed.f=1
CameraZ.f=0
Gosub InitStarField
; ********************************************************



; **************************** Raster a Comtois **************************
        ;-Préparation Raster
       
Structure s_Raster
    CentreX.l
    CentreY.l
    Vitesse.f
    angle.f
    amplitude.l
    pas.f
    Fond.l
    Sprite.l[30]
EndStructure
       
Structure s_Texte
    Texte.s
    depx.l
    depy.l
    x.l
    Y.l
    mx.l
    my.l
EndStructure
; ****************************************************************


Global angle1,amplitude
Global amplitude1=2
Texte.s="PUREBASIC 4.10"

Buffer$=Space(128)
mciSendString_("open  5.MID type sequencer alias mid",Buffer$,128,0)
mciSendString_("play mid",0,0,0)


InitSprite()                                    ; Initialise les sprites
InitKeyboard()                                  ; Initialise le clavier

LoadFont ( #font , "Arial" ,40)
LoadFont(#font2, "arial", 20 ,#PB_Font_Italic )

#sprite_balle_bleue=1 ; on donne un numero au sprite
#sprite_raster=1000
#sprite_tonton=2000
#titre=3000
#sprite_tunel=5000
depx=4                                          ; deplacement horizontal
depy=4                                          ; deplacement vertical
etx=0
ety=0
passsx=5
passsy=5
yex=2
yey=2
passsx1=6
passsy1=6
yex1=2
yey1=2
passsx2=2
passsy2=2
yex2=2
yey2=2
bpas=1
rotm.f
depmx.f
depmy.f
depmx1.f
depmy1.f
acc.f=0
depmx=200
depmy=200
Dim tableau(1500)
Dim tableau2(1500)
X1_m.f:Y1_m.f:posi_m.f:a_m.f
emp_m = -10 ; amplitude de depart
negampli_m = -70 ; amplitude inferieur
posampli_m = 70 ; amplitude superieur
decomp_m = 4 ; vitesse
z_m = 0
posi_m = 1
limite_m = posi_m * 80
zoomm = 400
 

If ExamineDesktops()                            ; Liste les bureaux
    
    Width  = DesktopWidth(0)                      ; Largeur actuelle
    Height = DesktopHeight(0)                    ; Hauteur actuelle
    Depth  = DesktopDepth(0)                      ; Profondeur de couleurs actuelle
    CentreX=Width/2
    Rien$ = "BERNARD 13"                                ; Titre de l'application à B13
    
    ; *********** Creation de la balle Bleue **************************
    ;- creation balle bleue
    If OpenScreen(Width, Height, Depth, "Intro")  ; Ouvre l'écran
        CreateSprite(#sprite_balle_bleue,64,64) ; on cree un sprite de 32 par 32
        StartDrawing(SpriteOutput(#sprite_balle_bleue)) ; on va dessiner dedans !!
            Circle(32,32,32,RGB(0,0,155)) ; un rond bleu
            Circle(33,31,25,RGB(0,0,180)) ; un rond bleu
            Circle(34,30,20,RGB(0,0,200)) ; un rond bleu
            Circle(36,28,17,RGB(0,0,225)) ; un rond bleu
            Circle(38,26,15,RGB(0,0,245)) ; un rond bleu
            Circle(40,24,10,RGB(0,0,255)) ; un rond bleu
            Circle(42,22,4,RGB(255,255,255)) ; un rond bleu
        StopDrawing() ; voila notre sprite est pret !! :D
        ; on va pouvoir l'apeler par son nom !! (#sprite)
        balle_bleue(1)\xpas=10 ; ceci va determiner le sens du sprite  pour les X et sa vitesse de deplacement
        balle_bleue(1)\ypas=10; ceci va determiner le sens du sprite  pour les Y et sa vitesse de deplacement
        ; **********************************************************
        
        ;-creation boules a Tonton
        ; ************ creation d'un boule pour les boules a tonton *****************
        CreateSprite(#sprite_tonton,64,64) ; on cree un sprite de 32 par 32
        StartDrawing(SpriteOutput(#sprite_tonton)) ; on va dessiner dedans !!
            Circle(30,32, 20 ,RGB(150,50,50))
            Circle(32,30, 16 ,RGB(170,70,70))
            Circle(34,28, 12 ,RGB(190,90,90))
            Circle(38,26, 4 ,RGB(250,250,250))
        StopDrawing() ; voila notre sprite est pret !! :D
        ; *******************************************************
        
        ;-creation boules pour Tunel a SPH
        ; ************ creation d'un boule pour les boules a tonton *****************
        CreateSprite(#sprite_tunel,8,8) ; on cree un sprite de 8 par 8
        StartDrawing(SpriteOutput(#sprite_tunel)) ; on va dessiner dedans !!
            Circle(4,4, 4, RGB($A5,$1,$A0))
            Circle(4,4, 3 ,RGB($F0,$0,$DE))
            Circle(4,4, 2 ,RGB($FE,$76,$F0))
            Circle(4,4, 1 ,RGB(250,250,250))
        StopDrawing() ; voila notre sprite est pret !! :D
        ; *******************************************************
        
        
        
        
        ;- creation sprite pour le titre
        ; *********** Creation du sprite pour le titre **************************
        
        StartDrawing( ScreenOutput()) ; on va dessiner dans une image reperé   "100"
            FrontColor(RGB($0,$FF,$FF)) ; couleur d'ecriture
            BackColor(RGB(0, 0, 0)) ; couleur de fond
            
            DrawingFont(FontID(#font2))
            DrawingMode(1)
            DrawText(0,0,Texte.s) ; on ecrit "PUREBASIC 4.10" dedans notre image
        StopDrawing()
        
        ; ceci va lire l'image ligne par ligne et recreer autant d'image qu'il y a de ligne !!
        For t=0 To 50
            GrabSprite(#titre+t, 0, t, 250, 1)  ; voila on prend un ligne et on en fait une image d'une ligne de large 1 pixel de haut
        Next t ; on a un bon stock de ligne la :D 101 pour etre exact :)
        ; ******************************************************************
        
        ;- préparation Raster a Comtois
        ; ****************** Raster a Comtois **********************
        Declare DeplaceTexte(*T.s_Texte)
        Global Raster.s_Raster
        Define.s_Texte TexteRaster
        With TexteRaster
            \Texte = "Comtois"
            \depx = 2
            \depy = 2
            \x = Width/2
            \Y = Height/2
            \mx = Width
            \my = Height
        EndWith
        
        Raster\Fond = CreateSprite(#PB_Any,480,480)
        StartDrawing(SpriteOutput(Raster\Fond))
            For l=0 To 479
                Restore Couleur
                For i = 0 To 479
                    Read coul
                    Plot(l,i,coul)
                Next i
            Next l
        StopDrawing()
        
        With Raster
            UseBuffer(\Fond)
            For i = 0 To 29
                \Sprite[i] = GrabSprite(#PB_Any, i * 8, i* 16, 240 - i * 8, 16)
            Next
            UseBuffer(-1)
            FreeSprite(\Fond)
            \CentreX = (Width  - SpriteWidth(\Sprite[0]))  / 2
            \CentreY = (Height - SpriteHeight(\Sprite[0])) / 2
            \Vitesse = 6
            \angle = 0
            \amplitude = 120
            \pas = 3.8
        EndWith     
        ; ***************************************************
        
        
        ; **** Buckethead dotball *******
        too.l = 0
        yC.c = 220
        ; ********************
        
        
        
        Repeat                                      ; Boucle
            ExamineKeyboard()                         ; Scanne l'état du clavier
            StartDrawing(ScreenOutput())              ; Démarre le dessin dans le buffer
                
                ; ************** Star Field ***************************
                Gosub DrawStarField
                Gosub MoveCamera
                ; *************************************************   
                
                
                
                
                
                
                ;-affiche le text Bernard 13
                DrawText((Width/2 - TextWidth(Rien$)/2)+a, (Height/2 - TextHeight(Rien$)/2)+b, "BERNARD 13", $FFFFFF, $000000) ; Dessine
                
                a+depx                                     ;on deplace la position du texte sur l horizontal
                b+depy                                     ;on deplace la position du texte sur la vertical
                If (Width/2 - TextWidth(Rien$)/2)+a>Width-TextWidth(Rien$)  ;si le texte depasse la largeure de l' écran
                    depx=-depx                                ;on inverse le pas horizontal en négatif
                EndIf
                If (Width/2 - TextWidth(Rien$)/2)+a<0      ;si le texte  depasse a gauche de l' écran
                    depx=-depx                                ;on inverse le pas horizontal en positif
                EndIf
                
                If (Height/2 - TextHeight(Rien$)/2)+b>Height-TextHeight(Rien$);si le texte depasse la hauteur de l' écran
                    depy=-depy                                 ;on inverse le pas vertical en negatif
                EndIf
                If (Height/2 - TextHeight(Rien$)/2)+b<0    ;si le texte  depasse en base de l' écran
                    depy=-depy                                ;on inverse le pas vertical en positif
                EndIf
                
                
                
                
                ;-------------debut spectre------------
                
                avx+passsx*veroux
                avy+passsy*verouy
                yyex=yex*veroux
                yyey=yey*verouy
                varix=Random(100)
                variy=Random(100)
                varix1=Random(100)
                variy1=Random(100)
                varix2=Random(100)
                variy2=Random(100)
                
                If avx>Width-150 Or  avx<0 Or varix=50
                    passsx=-passsx
                    veroux=1
                    verouy=0
                    yex=-yex
                EndIf
                If avy>Height-150 Or  avy<0 Or variy=50
                    passsy=-passsy
                    veroux=0
                    verouy=1
                    yey=-yey
                EndIf
                avx0=avx
                avy0=avy
                yyex0=yyex
                yyey0=yyey
                coul=$0000FF
                Gosub spectre
                
                
                avx1+passsx1*veroux1
                avy1+passsy1*verouy1
                yyex1=yex1*veroux1
                yyey1=yey1*verouy1
                
                
                If avx1>Width-150 Or  avx1<0 Or varix1=50
                    passsx1=-passsx1
                    veroux1=1
                    verouy1=0
                    yex1=-yex1
                EndIf
                If avy1>Height-150 Or  avy1<0 Or variy1=50
                    passsy1=-passsy1
                    veroux1=0
                    verouy1=1
                    yey1=-yey1
                EndIf
                avx0=avx1
                avy0=avy1
                yyex0=yyex1
                yyey0=yyey1
                coul=$FF0000
                Gosub spectre
                
                
                avx2+passsx2*veroux2
                avy2+passsy2*verouy2
                yyex2=yex2*veroux2
                yyey2=yey2*verouy2
                
                If avx2>Width-150 Or  avx2<0 Or varix2=50
                    passsx2=-passsx2
                    veroux2=1
                    verouy2=0
                    yex2=-yex2
                EndIf
                If avy2>Height-150 Or  avy2<0 Or variy2=50
                    passsy2=-passsy2
                    veroux2=0
                    verouy2=1
                    yey2=-yey2
                EndIf
                avx0=avx2
                avy0=avy2
                yyex0=yyex2
                yyey0=yyey2
                coul=$00FF00
                Gosub spectre
                
                
                
                ;--------------fin spetcre--------------
                ;debut pacman
                Circle(100+deppac, 100, 25 ,RGB(250,255,00))
                bo+bpas
                deppac+5
                If deppac>1300
                    deppac=0
                EndIf
                If bo>10 Or bo<0
                    bpas=-bpas
                EndIf
                
                If bo=0
                    bo1=0: bo2=0: bo3=0: bo4=0: bo5=0: bo6=0: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                
                If bo=1
                    bo1=1: bo2=0: bo3=0: bo4=0: bo5=0: bo6=0: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=2
                    bo1=1: bo2=1: bo3=0: bo4=0: bo5=0: bo6=0: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=3
                    bo1=1: bo2=1: bo3=1: bo4=0: bo5=0: bo6=0: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=4
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=0: bo6=0: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=5
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=1: bo6=0: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=6
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=1: bo6=1: bo7=0: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=7
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=1 :bo6=1: bo7=1: bo8=0: bo9=0: bo10=0
                EndIf
                If bo=8
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=1: bo6=1: bo7=1: bo8=1: bo9=0: bo10=0
                EndIf
                If bo=9
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=1: bo6=1: bo7=1: bo8=1: bo9=1: bo10=0
                EndIf
                If bo=10
                    bo1=1: bo2=1: bo3=1: bo4=1: bo5=1: bo6=1: bo7=1: bo8=1: bo9=1: bo10=0
                EndIf
                
                
                LineXY(100*bo1+deppac,100*bo1,125*bo1+deppac,100*bo1,RGB(0,0,0))
                LineXY(100*bo1+deppac,100*bo1,125*bo1+deppac,101*bo1,RGB(0,0,0))
                LineXY(100*bo2+deppac,100*bo2,125*bo2+deppac,99*bo2,RGB(0,0,0))
                LineXY(100*bo2+deppac,100*bo2,125*bo2+deppac,102*bo2,RGB(0,0,0))
                LineXY(100*bo3+deppac,100*bo3,125*bo3+deppac,98*bo3,RGB(0,0,0))
                LineXY(100*bo3+deppac,100*bo3,125*bo3+deppac,103*bo3,RGB(0,0,0))
                LineXY(100*bo4+deppac,100*bo4,125*bo4+deppac,97*bo4,RGB(0,0,0))
                LineXY(100*bo4+deppac,100*bo4,125*bo4+deppac,104*bo4,RGB(0,0,0))
                LineXY(100*bo5+deppac,100*bo5,125*bo5+deppac,96*bo5,RGB(0,0,0))
                LineXY(100*bo5+deppac,100*bo5,125*bo5+deppac,105*bo5,RGB(0,0,0))
                LineXY(100*bo6+deppac,100*bo6,125*bo6+deppac,95*bo6,RGB(0,0,0))
                LineXY(100*bo6+deppac,100*bo6,125*bo6+deppac,106*bo6,RGB(0,0,0))
                LineXY(100*bo7+deppac,100*bo7,125*bo7+deppac,94*bo7,RGB(0,0,0))
                LineXY(100*bo7+deppac,100*bo7,125*bo7+deppac,107*bo7,RGB(0,0,0))
                LineXY(100*bo8+deppac,100*bo8,125*bo8+deppac,93*bo8,RGB(0,0,0))
                LineXY(100*bo8+deppac,100*bo8,125*bo8+deppac,108*bo8,RGB(0,0,0))
                LineXY(100*bo9+deppac,100*bo9,125*bo9+deppac,92*bo9,RGB(0,0,0))
                LineXY(100*bo9+deppac,100*bo9,125*bo9+deppac,109*bo9,RGB(0,0,0))
                LineXY(100*bo10+deppac,100*bo10,125*bo10+deppac,91*bo10,RGB(0,0,0))
                LineXY(100*bo10+deppac,100*bo10,125*bo10+deppac,110*bo10,RGB(0,0,0))
                
                ;fin pacman
                ;--------------------- mine storm
                
                If  Random(30)=1
                    gau=1
                    dro=0
                EndIf
                If  Random(30)=2
                    gau=0
                    dro=1
                EndIf
                If gau=1
                    rotm-0.1
                Else
                    rotm+0.1
                EndIf
                If  Random(100)>35
                    acc+0.05
                    If acc>5
                        acc=5
                    EndIf
                    depmx=depmx-Sin(rotm)*acc*acc
                    depmy=depmy+Cos(rotm)*acc*acc
                    rotm1.f=rotm
                    push0=1
                Else
                    acc-0.05
                    depmx=depmx-Sin(rotm1)*acc*acc
                    depmy=depmy+Cos(rotm1)*acc*acc
                    push0=0
                EndIf
                If acc<0
                    acc=0
                EndIf
                
                posxm1=0
                posym1=15
                posxm2=10
                posym2=-15
                posxm3=0
                posym3=-10
                posxm4=-10
                posym4=-15
                
                posxm5=0
                posym5=-12
                posxm6=0
                posym6=-40
                posxm7=-5
                posym7=-38
                posxm8=5
                posym8=-38
                cosrot.f=Cos(rotm)
                sinrot.f=Sin(rotm)
                ixm1=cosrot * posxm1 - sinrot * posym1
                iym1=sinrot * posxm1 + cosrot * posym1
                ixm2=cosrot * posxm2 - sinrot * posym2
                iym2=sinrot * posxm2 + cosrot * posym2
                ixm3=cosrot * posxm3 - sinrot * posym3
                iym3=sinrot * posxm3 + cosrot * posym3
                ixm4=cosrot * posxm4 - sinrot * posym4
                iym4=sinrot * posxm4 + cosrot * posym4
                If depmx>Width
                    depmx=0
                EndIf
                If depmy>Height
                    depmy=0
                EndIf
                If depmx<0
                    depmx=Width
                EndIf
                If depmy<0
                    depmy=Height
                EndIf
                LineXY(ixm1+depmx,iym1+depmy,ixm2+depmx,iym2+depmy,RGB(255,255,255))
                LineXY(ixm2+depmx,iym2+depmy,ixm3+depmx,iym3+depmy,RGB(255,255,255))
                LineXY(ixm3+depmx,iym3+depmy,ixm4+depmx,iym4+depmy,RGB(255,255,255))
                LineXY(ixm4+depmx,iym4+depmy,ixm1+depmx,iym1+depmy,RGB(255,255,255))
                If push0=1
                    If Random(1)=1
                        ixm5=cosrot * posxm5 - sinrot * posym5
                        iym5=sinrot* posxm5 + cosrot * posym5
                        ixm6=cosrot * posxm6 - sinrot * posym6
                        iym6=sinrot * posxm6 + cosrot * posym6
                        ixm7=cosrot * posxm7 - sinrot * posym7
                        iym7=sinrot * posxm7 + cosrot * posym7
                        ixm8=cosrot * posxm8 - sinrot * posym8
                        iym8=sinrot * posxm8 + cosrot * posym8   
                        LineXY(ixm5+depmx,iym5+depmy,ixm6+depmx,iym6+depmy,RGB(255,255,255))
                        LineXY(ixm5+depmx,iym5+depmy,ixm7+depmx,iym7+depmy,RGB(255,255,255))
                        LineXY(ixm5+depmx,iym5+depmy,ixm8+depmx,iym8+depmy,RGB(255,255,255))
                    EndIf
                EndIf
                ;---------- fin mine storm --------------------- 
                ;----------- courbe math --------------   
                prem_m = 0
                x_m = 150
                y_m = 500
                a_m = 0
                X1_m = -150
                Y1_m = -150
                emp_m + decomp_m
                If emp_m > posampli_m Or emp_m < negampli_m
                    decomp_m = -decomp_m
                EndIf
                For i_m = 1 To 1000
                    tableau(i_m) = 1000
                    tableau2(i_m) = 0
                Next
                While a_m < limite_m
                    If prem_m = 0 Or tableau2(x_m) < y_m + z_m
                        tableau2(x_m) = y_m + z_m
                    EndIf
                    If tableau(x_m) >= y_m + z_m
                        tableau(x_m) = y_m + z_m
                    EndIf
                    x_m + 1
                    X1_m + 0.5
                    z1_m = (Cos((Sqr((X1_m * X1_m) / zoomm + (Y1_m * Y1_m) / zoomm)))) * emp_m
                    z_m = z1_m
                    If x_m < 760 + a_m
                        If y_m + z_m < tableau(x_m) Or y_m + z_m > tableau2(x_m) ; test les points à afficher
                            Plot(x_m, y_m + z_m, RGB( 0 , 255 , 255))
                        EndIf
                    Else
                        prem_m = 1
                        x_m = 150
                        X1_m = -150
                        Y1_m + 3.8
                        a_m  + posi_m
                        y_m - 2
                        x_m + a_m
                    EndIf
                Wend
                ;--------------------------------------------------------------------
                
                
                ;Moi RV et mon pixel blanc
                
                Plot(10,10,RGB(255,255,255))        ; un point aux coordonnées 10,10 (coin en haut a gauche) de couleur rgb(255,255,255) blanc donc
                
                
                
                
                ; dotball ------------------------
                too+1
                ol.f = 100 - Abs(140 * Sin(too / 12))
                zoom.f = 3 + Sin(ol / 1024 + too / 128)
                aa.f = too / 40
                xC = Width/2 + 128 * Sin(aa)
                koa.f = Cos(aa)
                sia.f = Sin(aa)
                For u = 0 To 2500
                    uu.f = u / 200
                    co.f = Cos(u)
                    x.f = co * Cos(uu)
                    Y.f = co * Sin(uu)
                    z.f = Sin(u)
                    yy.f = Y * koa - z * sia
                    zz.f = Y * sia + z * koa
                    xxx.f = x * koa + zz * sia
                    zzz.f = zz * koa - x * sia
                    co = 128 + zzz * 64
                    If zzz > 0
                        Plot(256 * (xxx / (zzz + zoom)) + xC,256 * (yy / (zzz + zoom)) + yC + ol,RGB(co / 4,co / 2,co))
                    Else
                        Plot(256 * (xxx / (zzz + zoom)) + xC,256 * (yy / (zzz + zoom))+ yC + ol,RGB(co * 2,co / 2,co))
                    EndIf
                Next u
                ; ------------------------------- / Dotball
                
                
                
                
                
                
                
                
            StopDrawing()                             ; C'est fini
            
            
            
            ; on va tester si le sprite va sortir de l'ecran
            ; et fabriquer un rebond par inversion de la coordonée  au  cas ou ...
            
            balle_bleue(1)\x=balle_bleue(1)\x + balle_bleue(1)\xpas ; on lance l'animation de la coordonées X
            balle_bleue(1)\Y=balle_bleue(1)\Y + balle_bleue(1)\ypas ; on lance l'animation de la coordonées Y
            
            ; on test les sorties d'ecran
            If  balle_bleue(1)\x>Width-32 Or balle_bleue(1)\x<0  ; si la coordonée X du sprite est superieur a la largeur de l'ecran (sortie a droite) ou plus petit que zero (sortie a gauche)
                ; le "-32" sert a ce que la detection de la sortie se fasse a droite du Sprite
                balle_bleue(1)\xpas=-balle_bleue(1)\xpas ; on inverse le sens des x , ce qui aura pour consequence de faire aller le Sprite dans l'autre sens des X
            EndIf
            If  balle_bleue(1)\Y>Height-32 Or balle_bleue(1)\Y<0  ; si la coordonée Y du sprite est superieur a la lhauteur de l'ecran (sortie en bas) ou plus petit que zero (sortie en haut)
                ; le "-32" sert a ce que la detection de la sortie se fasse au dessous du Sprite
                balle_bleue(1)\ypas=-balle_bleue(1)\ypas ; on inverse le sens des Y , ce qui aura pour consequence de faire aller le Sprite dans l'autre sens des Y
            EndIf
            
            DisplayTransparentSprite(#sprite_balle_bleue,balle_bleue(1)\x,balle_bleue(1)\Y) ; on affiche le Sprite aux coordonées
            
            son=Random(1000)+500
            
            oliv(1)\text.s="petite demo pour Bernard 13"
            oliv(1)\xt= oliv(1)\xt+2 :If  oliv(1)\xt>Width: oliv(1)\xt=-500:EndIf ; le text arrive a droite ? on le remet a gauche !!
            oliv(1)\yt=Height-125 ; emplacement verticale de la sinuzoide
            oliv(1)\cr=Random(255)+100
            ;oliv(1)\cv=Random(255)+100
            oliv(1)\cb=Random(255)+100
            Ondulation( oliv(1)\xt, oliv(1)\yt, oliv(1)\text.s, oliv(1)\cr, oliv(1)\cv, oliv(1)\cb) ; appel de la procedure a OLIV on donne les coordonées que l'on veux, le text, et la couleur
            
            
            
            
            
            ;-affiche Raster
            With Raster
                For i = 0 To 29
                    DisplaySprite(\Sprite[i], 10 + i * 4, \CentreY + Sin((\angle + i * \pas * 2)  * 0.0174533) * \amplitude)
                    DisplaySprite(\Sprite[i], Width-240 + i * 4, \CentreY + Sin((\angle + i * \pas * 2)  * 0.0174533) * \amplitude)
                Next i
                \angle + \Vitesse
            EndWith
            
            ;------------- routine boulles en rotation ---------
            rot.f+0.05
            For colon= 0 To 8           ;nombre de ligne  de boulles en rotation!! ou collone pitain je sais plus
                For ligne =0 To 8           ;nombre de collone de boulles en rotation!! ou ligne repitain je sais pas
                    posx=(colon*50)-200             ; pfff ca me gonffle les comment...
                    posy=(ligne*50)-100
                    ix=Cos(rot) * posx - Sin(rot) * posy
                    iy=Sin(rot) * posx + Cos(rot) * posy
                    iz1=Sin(rot) * iy + Cos(rot) * 100
                    cix=1000*ix/(1000-iz1)
                    ciy=1000*(Cos(rot) * iy - Sin(rot) * 100)/(1000-iz1)
                    DisplayTransparentSprite(#sprite_tonton,cix+Width/2,ciy+ 100+Height/2)
                Next ligne
            Next colon
            ;-------------- fin boulles en rotation --------
            
            
            
            
            
            
            
            
            ;-affiche Titre
            ; ********************** Titre ************************************************
            For y1= 0 To 50 ; on va ré afficher nos 101 lignes mais en les positionant par rapport a une sinuzoide :=
                dobro_titre(1)\angle=dobro_titre(1)\angle+1 :If dobro_titre(1)\angle=360*10: dobro_titre(1)\angle=0 :EndIf
                dobro_titre(1)\x+(Sin(dobro_titre(1)\angle*2*#PI/50)*dobro_titre(1)\amplitude) ; le X varie en fonction de Sin()
                DisplayTransparentSprite(#titre+y1,dobro_titre(1)\x+CentreX-200,y1)
            Next y1   ; voila voila !! :D
            ; ********************************************************************
            
            ;- affichage tunel SPH
            ; ***************** tunel a SPH *********************
            x1=dw2
            y1=dh2
            
            r.f=70
            rr.f=0.000002
            cmb=300
            
            For i=1 To 255
                rvb=RGB(i,i,i)
                For u=0 To cmb
                    x2=dw2+Cos(t0)*ra0+Cos(t2)*ra0+Cos(ff)*r
                    y2=dh2+Sin(t)*ra1+Sin(t3)*ra1+Sin(ff)*r
                    ; LineXY(x1,y1,x2,y2,rvb)
                    ; Circle(x1,y1,2,RGB(0,125,125))
                    DisplaySprite(#sprite_tunel,x1,y1)
                    ;Line(x1,y1,1,1,rvb)
                    ff+0.1
                    rr*1.001
                    r+rr
                    t0+tt0
                    t1+tt1
                    t2+tt2
                    t3+tt3
                    
                    
                    x1=dw2+Cos(t0)*ra0+Cos(t2)*ra0+Cos(ff)*r
                    y1=dh2+Sin(t1)*ra1+Sin(t3)*ra1+Sin(ff)*r
                    ;LineXY(x1,y1,x2,y2,rvb)
                    ff+0.1
                    rr*1.001
                    r+rr
                    t0+tt0
                    t1+tt1
                    t2+tt2
                    t3+tt3
                Next
                
                If cmb>10
                    cmb-26
                EndIf
                
            Next
            ; ************************************************
            
            
            
            
            
            
            
            
            FlipBuffers()                             ; Inverse les buffers
            ClearScreen(0)                            ; Efface l'écran
            
            ; *************** Tunel SPH ******************
            
            ff=ffm+1
            ffm+0.03
            
            t01+0.03
            t11+0.04
            t21+0.023
            t31+0.032
            t0=t01
            t1=t11
            t2=t21
            t3=t31
            ; ******************************************
            
            
            
        Until KeyboardPushed(#PB_Key_Escape)        ; On s'en va!!!
        mciSendString_("CLOSE MIDI",0,0,0)
    EndIf
EndIf



End                                             ; Adios!

spectre:
Circle(100+avx0, 100+avy0, 20 ,coul)
Box(80+avx0,100+avy0, 40, 25 ,coul)
Circle(88+avx0, 122+avy0, 3 ,RGB(0,0,0))
Circle(100+avx0, 122+avy0, 3 ,RGB(0,0,0))
Circle(112+avx0, 122+avy0, 3 ,RGB(0,0,0))
Box(85+avx0,122+avy0, 6, 3,RGB(0,0,0))
Box(97+avx0,122+avy0, 6, 3,RGB(0,0,0))
Box(109+avx0,122+avy0, 6, 3,RGB(0,0,0))
Circle(108+avx0, 95+avy0, 5 ,RGB(255,255,255))
Circle(94+avx0, 95+avy0, 5 ,RGB(255,255,255))
Circle(108+avx0+yyex0, 95+avy0+yyey0, 3 ,RGB(0,0,0))
Circle(94+avx0+yyex0, 95+avy0+yyey0, 3 ,RGB(0,0,0))
Return


Procedure Ondulation(x,Y,Texte.s,r,v,b)
    ; procedure realisé par OLIV
    
    StartDrawing ( ScreenOutput ()) ; Pour pouvoir utiliser les commandes des dessin 2D.
        DrawingFont ( FontID ( #font )) ; On change la police
        DrawingMode (1) ; On selectionne le mode pour ne pas avoir de fond derrière les lettres.
        FrontColor ( RGB (r,v,b) ) ; On change la couleur.
        
        oliv(1)\angle + #VitesseAngle ; Angle de départ de la sinusoide en radian
        If  oliv(1)\angle >= 2 * #PI
            oliv(1)\angle = 0
        EndIf
        ; On affiche toute les lettres
        posx = 10 ; Position du caractère
        For n = 1 To Len (Texte) ; Pour chaque lettre du texte
            Lettre.s = Mid (Texte, n, 1) ; on récupère la lettre à la position n
            posy = 50 + #HauteurSin * Sin ( oliv(1)\angle + posx / #LargeurSin ) ; on calcul la position en Y de la lettre
            ; On part du centre de l'image (50) puis on ajoute un sin
            ; #HauteurSin fait varier l'amplitude du mouvement
            ; l'angle mis dans le sinus est d'abord composé de l'angle de départ d'affichage du texte (Angle)
            ; puis on augmente l'angle au fur et à mesure que l'on affiche des lettres avec le coefficient #LargeurSin qui permet de faire varier la largeur de la sinusoide
            
            DrawText (x+posx, Y+posy,Lettre)
            posx + TextWidth (Lettre)
        Next
    StopDrawing () ; On signife que l'on arrête les fonctions dessin 2D.
EndProcedure   

DataSection
    Couleur :
    Data.l $13, $30, $50, $70, $8E, $AE, $CF, $EC
    Data.l $FF, $EB, $CF, $AF, $8E, $71, $50, $30
    Data.l $0, $30914, $61632, $92454, $D3373, $104193, $144FB5, $185CD2
    Data.l $1A65E7, $185CD2, $144FB4, $114193, $D3373, $A2554, $51632, $30A15
    Data.l $1D2D, $314B, $4569, $5785, $6BA3, $7EC1, $90DC, $9CEE
    Data.l $90DB, $7FC2, $6BA3, $5785, $4569, $314B, $1D2C, $D12
    Data.l $62518, $B3E27, $F5837, $136F46, $178755, $1CA165, $1FB673, $22C67D
    Data.l $20B773, $1CA166, $178755, $136F46, $F5837, $B3F28, $62518, $30F0A
    Data.l $152516, $233E25, $315735, $3F6D43, $4D8652, $5B9F62, $67B56F, $70C478
    Data.l $67B56E, $5BA062, $4D8752, $3E6D43, $325635, $243E26, $152417, $80F0A
    Data.l $152209, $24390F, $324F15, $3F651A, $4E7C20, $5C9226, $69A62C, $72B42F
    Data.l $69A62C, $5C9226, $4E7C20, $40641A, $324F15, $24390E, $152209, $90E04
    Data.l $22230B, $393A13, $50511A, $666621, $7C7E29, $939631, $A7AA38, $B5B83C
    Data.l $A7AA37, $939631, $7C7E2A, $656621, $50521B, $393A13, $22230B, $E0E05
    Data.l $423411, $5E4919, $785D1F, $927226, $AD872D, $C89C34, $DFAE3B, $EFBB3F
    Data.l $DEAE3B, $C79C34, $AD872D, $927227, $785D1F, $5D4A18, $423412, $271E0A
    Data.l $251A12, $3E2C1E, $573C2A, $6E4D35, $875F41, $A0704D, $B68058, $C58A5F
    Data.l $B58057, $A0704D, $875F41, $6E4D35, $573D29, $3E2B1E, $251A12, $F0A07
    Data.l $211513, $372321, $4E302D, $633D39, $784C46, $8F5953, $A3665F, $B06E66
    Data.l $A3655E, $8F5A53, $794B46, $623D39, $4E312D, $372220, $211514, $D0808
    Data.l $C0609, $1D0F14, $311921, $44232F, $562C3B, $693649, $7D4056, $8E4961
    Data.l $9A4F6A, $8E4962, $7D4056, $693648, $562C3B, $44232F, $311921, $1D0F14
    Data.l $1D101B, $311B2D, $44263F, $573050, $6B3B62, $7E4673, $8F4F83, $9B568E
    Data.l $8F5083, $7E4673, $6A3B61, $573050, $45263E, $301B2D, $1D101A, $C070B
    Data.l $C0912, $1E142C, $31214A, $452F69, $583C84, $6D49A3, $8157C0, $9262DA
    Data.l $9E6BED, $9262DB, $8157C0, $6D4AA2, $583C85, $462F69, $32224B, $1E152C
    Data.l $211D42, $2E2A5D, $3B3676, $484190, $564EAB, $635AC5, $6E63DC, $766BEC
    Data.l $6E64DC, $6259C6, $554EAB, $48418F, $3B3676, $2F2A5C, $211D41, $141227
    Data.l $18003F, $220058, $2C0070, $350089, $3F00A3, $4900BD, $5100D2, $5700E1
    Data.l $5100D1, $4800BC, $3F00A3, $350089, $2C0070, $220059, $18003E, $E0025
    Data.l $23003E, $320059, $3F0071, $4D008A, $5C00A3, $6A00BD, $7600D3, $7F00E2
    Data.l $7700D2, $6A00BD, $5C00A4, $4D0089, $400071, $320058, $23003F, $150025
    Data.l $220029, $310039, $3E0049, $4B0059, $59006A, $66007A, $720088, $7B0092
    Data.l $730088, $67007A, $59006A, $4A0059, $3E0049, $300039, $220028, $140018
    Data.l $22031C, $310328, $3D0433, $4B053E, $59064A, $670755, $73085F, $7B0966
    Data.l $73085F, $670855, $590649, $4A053E, $3D0433, $300428, $22021C, $140111
    Data.l $220511, $300718, $3E081E, $4A0B25, $590D2C, $670E33, $721038, $7B113D
    Data.l $721039, $670E33, $590C2C, $4A0A25, $3E091F, $300718, $220510, $14030A
    Data.l $29130E, $3A1B13, $4B2219, $5A291F, $6C3125, $7C382A, $8B3E2F, $954332
    Data.l $8B3F2F, $7C382A, $6C3025, $5A291E, $4A2219, $3B1A14, $2A130E, $190B08
    Data.l $E0800, $221400, $382100, $4F2F00, $643B00, $7A4800, $915500, $A56100
    Data.l $B36900, $A56000, $925600, $7B4800, $643B00, $4F2F00, $382100, $221300
    Data.l $120D00, $2C2100, $4A3800, $684E00, $836300, $A17A00, $BF9000, $D9A400
    Data.l $EBB200, $D9A400, $BF9100, $A17A00, $836400, $684E00, $4A3900, $2C2200
    Data.l $D0D00, $1D1F00, $323400, $464900, $595C00, $6C7100, $808500, $929700
    Data.l $9EA400, $919700, $808600, $6C7100, $585B00, $464800, $323300, $1E1F00
    Data.l $1B2C00, $273E00, $314F00, $3B6000, $477300, $528500, $5C9400, $629F00
    Data.l $5B9400, $518500, $477300, $3C6100, $315000, $263E00, $1B2C00, $101A00
    Data.l $50E00, $B2100, $133700, $1A4D00, $216200, $287800, $308F00, $36A200
    Data.l $3BB000, $37A200, $308E00, $297900, $216200, $1A4E00, $133800, $B2100
    Data.l $93722, $D4D31, $11633F, $15794C, $198F5A, $1DA669, $20B975, $22C67D
    Data.l $20B975, $1CA568, $18905B, $15784C, $11633E, $D4E30, $93723, $62114
    Data.l $4344, $5F62, $7A7D, $9497, $B0B4, $CCD0, $E3E8, $F4F9
    Data.l $E3E8, $CCD0, $B1B5, $9597, $7A7D, $6062, $4344, $2829
    Data.l $2B42, $3E5E, $4E77, $5F90, $71AC, $82C7, $91DD, $9CEE
    Data.l $92DE, $83C7, $71AD, $5F91, $4E77, $3D5D, $2B41, $1A27
    Data.l $20812, $4132C, $81F48, $B2C66, $F3881, $12469E, $1552BC, $185DD5
    Data.l $1A65E7, $185DD5, $1552BB, $12459F, $F3881, $B2D66, $82049, $5132C
    Data.l $40011, $8002A, $D0046, $120063, $17007C, $1C0099, $2200B5, $2600CE
    Data.l $2900DF, $2500CE, $2100B5, $1C0099, $17007C, $120063, $D0046, $80029
EndDataSection


; #### INITSTARFIELD ####
InitStarField:
    ; Structure of a star ...
Structure a3DStar
    x.f ; X-Coordinate
    Y.f ; Y-Coordinate
    z.f ; Z-Coordinate
EndStructure
    ; Init Starfield ...
Dim Stars.a3DStar(SSum)

For dummy = 0 To SSum
    Stars(dummy)\x = Random(10000)-5000
    Stars(dummy)\Y = Random(10000)-5000
    Stars(dummy)\z = 100 + Random(1000)
Next dummy
Return
; ### Move Camera ###
MoveCamera:
If CameraZ>1000
    Direction=-1
ElseIf CameraZ<-1000
    Direction=1
EndIf
If Direction=1 And Cspeed<20
    Cspeed=Cspeed+0.01
ElseIf Direction=-1 And Cspeed>-20
    Cspeed=Cspeed-0.01
EndIf
CameraZ=CameraZ+Cspeed
Return
   
   
   
    ; #### Draw StarField ####
DrawStarField:
For dummy = 0 To SSum
    If Stars(dummy)\z<CameraZ
        Stars(dummy)\z=CameraZ+1000
    ElseIf Stars(dummy)\z>(CameraZ+1000)
        Stars(dummy)\z=CameraZ
    EndIf
    
    sx = Stars(dummy)\x / (Stars(dummy)\z-CameraZ)*100+EcranX/2
    sy = Stars(dummy)\Y / (Stars(dummy)\z-CameraZ)*100+EcranY/2
    If sx<Width And sy<Height And sx>0 And sy>0
        star_b.f = 255-(((Stars(dummy)\z)-CameraZ)*(255./1000.))
        c=Int(star_b)
        Rouge =Random(255)+1
        Vert=Random(255)+1
        Bleu=Random(255)+1
        Circle(sx, sy, 1 ,RGB(Rouge,Vert,Bleu) )
    EndIf
Next dummy
Return 

ras le bol de prendre en reference les rosbifs !

[Kwai chang caine]

T'as raison sur ce coup la
Dire que c'est splendide serait encore comme pisser dans un violon

Je ne sais pas si ça a été fait petit morceau par petit morceau, comme sur le US, mais si c'est le cas....t'as raison...c'est bien plus joli et puissant

C'etait juste l'idée que je defendais...mais c'est vrai qu'on est tous pareil...au debut ça peut plaire, puis on a une autre idée, une autre....et on laisse tomber..et apres c'est tellement gros que personne n'ose ou n'a envie de reprendre

Moi ce que je pronais, c'est pas de faire un super code de la mort comme ZAPMAN, car mener un projet comme ça à quelque uns, c'est voué a l'echec d'avance.
Tres peu de nous on le courage et le temps de tenir leur projet, comme GNOZAL, SROD.....
Alors ce qui serait cool, c'est juste une procedure qui exporte dans une variable le code pour creer la fenetre par exemple, pour aller au plus simple.

Je n'y connais rien, mais je crois qu'ils faut plusieurs fichier a C pour comprendre.
Une procedure qui créé ces fichiers, et/ou qui verifie si ils sont bien en place, puis apres on voudrait ouvrir une fenetre, comme on ecris

Code : Tout sélectionner

Resultat = OpenWindow(#Fenetre, x, y, LargeurInterne, HauteurInterne, Titre$ [, Options [, FenetreMereID]])

Et ben on ecrirais

Code : Tout sélectionner

Resultat = OpenWindowC(#Fenetre, x, y, LargeurInterne, HauteurInterne, Titre$ [, Options [, FenetreMereID]])

Et pof on aurait en sortie le code en C qui sort de cette fonction, qui irais ecrire dans un fichier nommé ".cpp" ou je ne sais quoi car je sais que y'a des ".h" etc...

Et hop, je pleurerais pour avoir le code d'un bouton, et un gentil membre me donnerait ce code..et hop on aurait un bouton...et un string...et un If...et un loop...
Et a la fin le mec qui veut se creer son convertisseur y recopie les fonctions une a une, et il l'a...pas besoin de relire tout un code qui est fait par une seule personne et ou malheureusement ou sait bien que c'est souvent illisible, car chacun les mets a sa sauce, ne serais ce que pour commencer par l'indentation

Parce que se lancer dans un decodeur complet de PB ==> C....jamais il sera terminé
J'aurais bien essayé...mais j'sais meme pas ouvrir le RAD, et j'ai toujours pas compris malgré quelques lectures a quoi servent les fichier .h et tout le toutim.

Ce qu'il faudrait c'est des gens qui ne sont pas puristes du C, qui se la pete pas...comme vous quoi !!!!
Qui connaissent le C, meme si ils sont pas des CAIDS, et qui quand ils entendent le mot PB...ils m'insultent pas en me disant qu'ils jouent pas avec des jouets, qu'ils sont programmeurs, pas bidouilleurs
Car quand j'ai essayé de demander sur les forums C a cette epoque, je me suis fait allumé, deja y sont pas drole....et en plus y sont hyper rigoureux
Je sais que le C necessite une rigueur, car il est tres chatouilleux. ..et pourtant ça rigole pas...

Mais si c'etait possible de creer le moins de fichiers possibles, pour que au debut on comprenne, car apres C se charge d'en creer "WattMille" tout autour
Alors c'est la que j'ai abandonné y'a quelques années, mais je regrette tous les jours

Je viens de trouver encore plus simple
http://www.cppfrance.com/codes/TUTORIAL ... 22680.aspx
C'est bien expliqué et en français

Et en plus y'a qu'un seul fichier un CPP, exactement comme je le voulais

Mais c'est pareil...je compile et PROUuuuut !!!

Code : Tout sélectionner

--------------------Configuration: Tutor_Win32_Partie_1 - Win32 Debug--------------------
Linking...
LIBCD.lib(crt0.obj) : error LNK2001: unresolved external symbol _main
Debug/Tutor_Win32_Partie_1.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

Tutor_Win32_Partie_1.exe - 2 error(s), 0 warning(s)

Code : Tout sélectionner

/**********************************************************************************************
               DEMARRER en WIN32 // Implémenté le 10/05/2004 par Eric.
                               (1ère partie)
                               
                               
Compiler avec DEV C++ 4.9.8.0

Cette  étude se présente en plusieurs parties :

           -->  1) CREATION D'UNE FENETRE WINDOWS SIMPLE
                 
 
Ce code, ainsi que les parties qui suivront est destiné aux personnes, qui travaillent
en mode console et souhaitent passer en win32 ; si c'est votre cas, vous pouvez continuer, 
sinon ne perdez pas votre temps!
  
    (La prochaine partie traitera des menus et sera postée d'ici 1 mois)
                    

Il ne sera pas ici question de OpenGl ou autre librairie graphique.
nous nous contenterons de GDI (Graphical Device Interface) dont toutes
les données sont contenus dans l'include wingdi.h.

/**********************************************************************************************

Dans cette partie ; nous étudions simplement les bases de la programmation en win32,
les structures et fonctions utilisées pour créer une simple fenêtre et choisir
la couleur de cette fenêtre.
 

 
A noter : J'ai préféré bâtir un code qui ne fait pas grand chose, mais permet de
comprendre le fonctionnement en profondeur. Les parties suivantes permettrons de
l'étoffer petit à petit.

     Il ne sera pas ici question de OpenGl ou autre librairie graphique.
     nous nous contenterons de GDI (Graphical Device Interface) dont toutes
     les données sont contenus dans l'include wingdi.h.


RAPPELS PREALABLES :

 Différence entre mode console et mode win32 : ---------------------------------------------

 Dans un programme en mode console, on s'adresse directement au système d'exploitation (DOS).
 Sous windows, le programme est asservi et c'est windows qui commande le système 
 d'exploitation. Windows autorise l'exécution simultanée de plusieurs programmes 
 et gère les ressources de l'ordinateur entre ces différents programmes.
 Les programmes windows réagissent à des événements (déplacement, click de souris,
 agrandissement d'une fenêtre ...). Si le programme est correctement codé, windows peut,
 en lui transmettant un message faire déclencher au programme une certaine opération (prévue
 par le programmeur).

 Ainsi, Les programmes windows doivent contenir une fonction destinée à la gestion de ces
 messages (généralement appelée WndProc() ou WindowProc(), (mais que l'on peut nommer 
 autrement car windows y accède via un pointeur déclaré dans la structure  WNDCLASSEX ;
 voir plus loin).

 Remarquons qu'il n'est pas nécessaire d'écrire un code pour chaque message possible.
 On se contente de retenir ceux qui présentent un intérêt pour le programme et de renvoyer
 les autres à windows en appelant une fonction standard de windows ; DefWindowProc(),
 qui se chargera de les traiter.

L'API Windows : ----------------------------------------------------------------------------

 Toutes les communications entre une application et windows font appel à l'Interface de
 Programmation d'Applications Windows. Il s'agit de fonctions fournies en standard avec 
 windows et destinées à être employés par les applications.

Structure d'un programme windows: ----------------------------------------------------------

 Dans sa forme basique, un programme window comporte deux fonctions :

             - WinMain() qui contient les initialisations de base.
                     (équivalent à main() d'un programme console)

             - WinProc() que window appelle pour traiter les messages destiné à l'application

 Ces deux fonctions composent un programme complet mais ne sont pas directement liées.
 C'est windows qui appelle ces deux fonctions indépendamment l'une de l'autre.
 Ces deux fonctions communiquent avec windows en appelant certaines fonctions de l'API;

**********************************************************************************************/

// Avant d'examiner la première de ces deux fonctions ; il nous faut déclarer les includes :
// (ici, un seul suffira) ...



// Fichier d'include nécessaire pour la partie 1.

#include <windows.h> // contient les appels à windef.h, winuser.h et wingdi.h dont nous 
                     // utilisons les structures prédéfinies dans la suite.

// ... déclarer le prototype de la fonction WinProc() que nous étudierons dans la suite


LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);


// nous devons également déclarer les handles que nous utiliserons dans la suite :

// Un handle représente un entier de 32 bit dont la valeur n'a aucune importance et
// qui sert à manipuler un objet. Les handles servent à représenter des objets de toutes
// sortes : fenêtres, couleurs, instance d'application, bitmaps ... Ils permettent
// d'accéder facilement aux objets qu'ils représentent.

// Nous déclarons un handle sur la fenêtre que nous allons créer :


HWND hWnd;  //   Note : Nous trouvons dans l'include Windef.h, 
            //   appelé par windows.h, la macro :  DECLARE_HANDLE  (HWND);

            //   L'appellation hWnd est faites pour faciliter la lecture du code
            //   et aussi pour respecter la règle de nommage :
            //   tout handle sera déclaré sous le nom hToto. (ceci aussi pour
            //   faciliter la lecture du code.)


// Nous déclarons également des handles pour les couleurs ; 

// La couleur de fond de la fenêtre : (HBRUSH  est un Handle sur un brush). 


//HBRUSH  hBackground : pour l'initialisation de cette valeur, nous pouvons utiliser
//                 la macro RGB(), définie dans l'include wingdi.h qui prends 3 arguments
//                 définissant respectivement les composants rouge, vert et bleu de la
//                 valeur correspondant à la couleur (argument compris entre 0 et 255) ;
//                 par ex RGB(0,0,0) donne du noir et
//                 RGB(255,0,0) donne du rouge ... (la valeur rouge est à son maximum)

//                 Pour la mise en oeuvre, nous pouvons utiliser la fonction
//                 CreateSolidBrush(COLORREF) (wingdi.h) ; qui crée un handle sur
//                 un brush de la couleur COLOREFF.
//                 par ex : const HBRUSH hCouleur_Rouge = CreateSolidBrush(RGB(255,0,0));
//                 nous permet de définir un handle (nomme hCouleur_Rouge) sur un brush 
//                 de couleur rouge. 

//  Ainsi, nous pouvons créer nos propres handle sur des couleurs :


// Déclaration et définition de quelques handles pour la couleur de la fenêtre ... 

// Fonction utilisée : HBRUSH CreateSolidBrush(COLORREF);

const HBRUSH hCouleur_Jaune   =  CreateSolidBrush(RGB(255,255,0));
const HBRUSH hCouleur_Blanche =  CreateSolidBrush(RGB(255,255,255));
const HBRUSH hCouleur_Cyan    =  CreateSolidBrush(RGB(0,255,255));
const HBRUSH hCouleur_Bleu    =  CreateSolidBrush(RGB(0,0,255));
const HBRUSH hCouleur_Noir    =  CreateSolidBrush(RGB(0,0,0));
const HBRUSH hCouleur_Vert    =  CreateSolidBrush(RGB(0,255,0));
const HBRUSH hCouleur_Rouge   =  CreateSolidBrush(RGB(255,0,0));
const HBRUSH hCouleur_Orange  =  CreateSolidBrush(RGB(255,150,0)); // on peut varier à l'infini


// On peut aussi utiliser les couleurs prédéfinis dans wingdi.h avec GetStockObject(int)

HBRUSH hTransparent = static_cast <HBRUSH> (GetStockObject(HOLLOW_BRUSH));   
HBRUSH hCouleur_Gris = static_cast <HBRUSH> (GetStockObject(GRAY_BRUSH)); // ...   

// Nous étudierons plus précisément la fonction GetStockObject() dans la 3ème partie,


// Et maintenant ; nous pouvons déclarer et initialiser hBackground ; par ex en jaune ...

HBRUSH hBackground = hCouleur_Jaune; 


// Enfin, il nous reste à nommer notre classe de fenêtre ...

// Nom de la classe windows (Attention rien de commun avec une classe C++ ... 
//                                            vous savez, les constructeurs ...)

static char szClassName[ ] = "Fenêtre Windows simple"; 
                            // sz : string zéro (chaîne se terminant par NULL (0))
                     
// Nous pouvons maintenant passer à l'examen de la fonction WinMain

//---------------------------------------------------------------------------------------------
int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpcmdLine,
                    int nCmdShow)


// Cette fonction renvoie un type int ; WINAPI est une spécification windows liée à l'API.
//  (on peut aussi rencontrer le terme APIENTRY)

// Cette fonction prend 4 arguments : (C'est windows qui les transmets)

//      HINSTANCE hInstance : handle de l'instance (le programme) en cours d'exécution
//          Ce handle permet d'identifier les différentes instances (programmes) en cours

//      HINSTANCE hPrevInstance : handle de l'instance précédente du programme 
//                                dans le cas ou il aurait été ouvert plusieurs fois.
//                                Cet argument était utilisé avec les versions Win 3.X
//                                et mis a 0 (NULL) empêchait d'ouvrir plusieurs
//                                instance du programme. (n'est plus utilisé)

//      LPSTR lpcmdLine : Pointeur long (32 bits) désignant une chaîne qui contient la
//                        ligne de commande ayant servi a démarrer le programme.
//                        (ex : si on utilise Executer du menu Démarrer, la chaine contient
//                         la chaîne correspond au contenu de la zone Ouvrir)

//      int nCmdShow  : int qui indique l'aspect que doit avoir la fenêtre lors de
//                      sa création. Cet argument prend une valeur définie dans l'include
//                      winuser.h (prefixe SW pour ShowWindow)

                        //#define SW_HIDE 0
                        //#define SW_NORMAL 1
                        //#define SW_SHOWNORMAL 1
                        //#define SW_SHOWMINIMIZED 2
                        //#define SW_MAXIMIZE 3
                        //#define SW_SHOWMAXIMIZED 3
                        //#define SW_SHOWNOACTIVATE 4
                        //#define SW_SHOW 5
                        //#define SW_MINIMIZE 6
                        //#define SW_SHOWMINNOACTIVE 7
                        //#define SW_SHOWNA 8
                        //#define SW_RESTORE 9
                        //#define SW_SHOWDEFAULT 10
                        //#define SW_FORCEMINIMIZE 11
                        //#define SW_MAX  11

//  Remarque :         Cet argument pourra être utilisé dans l'instruction :                 
//                     ShowWindow (hWnd, nCmdShow); contenue dans WinMain (voir plus bas)

//                     L'argument transmis par windows est SW_SHOWNORMAL.


{

// Le corps de la fonction WinMain() contient les instructions servant à :

//  - Définir la fenêtre.
//  - Créer et initialiser la fenêtre du programme.
//  - Récupérer les messages windows destiné au programme et les tranmettrent à.
//    LRESULT CALLBACK WindowProcedure () qui les traitera ou les renverra à windows.

// Examinons ces fonctions une par une :

// - Définir la fenêtre : On utilise une stucture appelée WNDCLASSEX qui contient en membre 
// donnés toutes les caractéristiques de la fenêtre.
// examinons cette structure tel qu'elle est déclarée dans l'include winuser.h


//    typedef struct _WNDCLASSEX { 
//          UINT    cbSize;  // unsigned int ; spécifie la taille, en bytes, de la structure
                             // ce membre donné doit être mis a la valeur : sizeof(WNDCLASSEX).

//          UINT    style; Specifies le(s) style(s) de la fenêtre. 

//          WNDPROC lpfnWndProc; // pointeur long sur la fonction que window 
                                 // appelle pour traiter les messages destiné à l'application

//          int     cbClsExtra; // Membre non étudié pour l'instant ; mettre 0
//          int     cbWndExtra; // Membre non étudié pour l'instant ; mettre 0

//          HANDLE  hInstance; // handle de l'instance d'application (du programme)
 
//          HICON   hIcon; // handle de l'icone de la fenêtre

//          HCURSOR hCursor; // handle du type de curseur utilisé dans la fenêtre
 
//          HBRUSH  hbrBackground; // handle de la couleur du fond de la fenêtre

//          LPCTSTR lpszMenuName; // pointeur long spécifiant le nom de la ressource menu

//          LPCTSTR lpszClassName;  // pointeur long désignant le nom de la classe

//          HICON   hIconSm; // handle d'une petite icone de la fenêtre (Sm = Small)
//                              } WNDCLASSEX; 


// A noter que vous pourrez trouver aussi une classe WNDCLASS semblable a WNDCLASSEX, 
// mais ne comportant pas les membres UINT cbSize et HICON hIconSm. Plus guère
// utilisée, elle fonctionne cependant de la même facon que WNDCLASSEX

// Parmi les membres de WNDCLASSEX ; cinq nous intéressent plus particulièrement pour
// l'instant :

//     (1)   HANDLE  hInstance : auquel nous attribuerons la valeur hInstance pour des
//                               raisons de visibilité du code.
 
//     (2)   WNDPROC lpfnWndProc : auquel il faudra veiller a bien attribuer le nom de notre
//                                 fonction qui traite les messages (souvent nommee WndProc
//                                 pour des raisons de visibilite du code.)

//      (3)  HBRUSH  hbrBackground;  Utilise la couleur que nous avons définie 
                                             // dans hBackground


//      (4)  UINT    style : peut prendre un nombre tres varie de valeurs prédéfinies qui
//                           peuvent etre combinées entre elle avec l'opérateur ou (|)   
//                           pour l'instant nous nous contenterons de la valeur : 
//                           CS_HREDRAW | CS_VREDRAW  qui indique à windows que la fenêtre
//                           doit être rafraichit des que sa hauteur ou sa largeur changent.
//                           (A noter le préfixe CS ; Class Style).


// Pour infos ; nous trouvons dans winuser.h les définitions suivantes ;

 
        // Class styles
        //
        //#define CS_VREDRAW          0x0001
        //#define CS_HREDRAW          0x0002
        //#define CS_DBLCLKS          0x0008
        //#define CS_OWNDC            0x0020
        //#define CS_CLASSDC          0x0040
        //#define CS_PARENTDC         0x0080
        //#define CS_NOCLOSE          0x0200
        //#define CS_SAVEBITS         0x0800
        //#define CS_BYTEALIGNCLIENT  0x1000
        //#define CS_BYTEALIGNWINDOW  0x2000
        //#define CS_GLOBALCLASS      0x4000
        //#define CS_IME              0x00010000


//      (5)  LPCTSTR lpszMenuName; Contient le nom que l'on donne a la classe de fenêtre
//                  en general, c'est le nom de l'application. on defini ce membre de 
//                  la facon suivante :  static char szClassName[ ] = "Nom de la classe";

        
// On déclare  donc un objet de type structure WNDCLASSEX :
    
     WNDCLASSEX wincl;        

// Puis on initialise ses membres données

    wincl.hInstance                =            hThisInstance;    //(1) 
    wincl.lpfnWndProc              =            WindowProcedure;  //(2)  
    wincl.hbrBackground            =            hBackground;      //(3)
    wincl.style                    =            CS_HREDRAW | CS_VREDRAW;  //(4)              
    wincl.lpszClassName            =            szClassName;      //(5)
    
// Nous reviendrons sur les autres membres données dans les parties suivantes ...    
    
    wincl.cbSize                   =            sizeof (WNDCLASSEX);  
       
    
    wincl.hIcon                    =            LoadIcon (NULL, IDI_APPLICATION); 
                                                // Utilise l'icone prédéfinie


    wincl.hIconSm                  =            LoadIcon (NULL, IDI_APPLICATION); 
                                                // Utilise l'icone prédéfinie

    wincl.hCursor                  =            LoadCursor (NULL, IDC_ARROW); 
                                                // Utilise le curseur standard (flêche)

    wincl.lpszMenuName = NULL;       // Pointeur sur la ressource menu (ici pas de menu)

    wincl.cbClsExtra = 0;            // Non utilisé pour l'instant
    wincl.cbWndExtra = 0;            // Non utilisé pour l'instant
    
    

// La structure WNDLCLASSEX étant déclarée et ses membres initialisés, il nous faut 
// en informer windows à l'aide de la fonction de l'API windows RegisterClass()
// Par ex si nous avons déclaré l'objet de type WNDLCLASSEX WindowClass;

// l'instruction est ; RegisterClass(&WindowClass);

// Ce qui permet à windows de stocker toutes les valeurs définies dans les membres
// de cette structure. (Attention rien de commun avec une classe C++ ... )

// --------------------------------------------------------------------------------------------

    if (RegisterClassEx (&wincl) == false) // On enregistre la classe déclarée avec WNDCLASSEX 
                 return 0 ;                //  et en cas d'erreur on quitte le programme
                    
    // Sinon ... pour l'exemple ; une petite message box ... qui se passe d'explication
    //                     il suffit d'exécuter le code. (hWnd est le handle de la fenêtre)
    else {
    MessageBox(hWnd,"La classe est bien enregistrée, cliquez sur ok pour ouvrir la fenêtre",
                                            "Info de service",MB_OK);
         }  // Nous étudierons plus en profondeur les boites de dialogue dans la 2ème partie               
                      
// --------------------------------------------------------------------------------------------          


// Il nous reste maintenant à créer la fenêtre avec la fonction de l'API CreateWindowEx ()
// Cette fonction renvoie un handle de la fenêtre que nous créons et nous allons en
// profiter pour le stocker car nous en aurons besoin pour d'autres fonctions 
// (Rappelez vous ; c'est hWnd)


// Cette fonction prend 12 arguments qui sont :


hWnd = CreateWindowEx (
           0,                   // Spécifie une extension du style de la fenêtre
                                // pour l'instant non étudié.

           szClassName,         // Nom de la classe de fenêtre

           "Fenetre simple",       // Titre apparaissant dans la barre de caption (légende)

           WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,  // Style de fenêtre 

           // Cette fenêtre possèdent une barre de légende incluant le menu système
           // et un bouton de réduction (pas de bouton d'agrandissement activé)
           // Elle n'est pas redimensionnable au moyen de la souris.

// Les différents styles possibles sont : (WS = Windows Style)

//WS_BORDER  Crée une fenêtre avec une bordure.

//WS_CAPTION Crée une fenêtre avec une barre de légende (inclu le style WS_BORDER). 

//WS_CHILD   Crée une fenêtre enfant. Ce style ne peut être utilisé avec WS_POPUP. 

//WS_CHILDWINDOW   Identique a WS_CHILD. 

//WS_CLIPCHILDREN  Non étudié pour l'instant.
//WS_CLIPSIBLINGS  Non étudié pour l'instant.

//WS_DISABLED Crée une fenêtre qui ne peut initialement recevoir d'information 
//            de l'utilisateur (disabled).
 
//WS_DLGFRAME Non étudié pour l'instant.
//WS_GROUP    Non étudié pour l'instant.

//WS_HSCROLL Crée une fenêtre avec une barre de défilement (scroll bar) horizontal.
 
//WS_ICONIC  Crée une fenêtre initialement minimisée. Identique à WS_MINIMIZE.
 
//WS_MAXIMIZE Crée une fenêtre initialement maximisée.
 
//WS_MAXIMIZEBOX Crée une fenêtre qui possède un bouton d'agrandissement.
//               Ne peut être combiné avec WS_EX_CONTEXTHELP. (extension du style)
//               WS_SYSMENU doit être spécifié.
  
//WS_MINIMIZE    Identique à WS_ICONIC style. 

//WS_MINIMIZEBOX Crée une fenêtre qui possède un bouton de réduction.
//               Ne peut être combiné avec WS_EX_CONTEXTHELP. (extension du style).
//               WS_SYSMENU doit être spécifié.

//WS_OVERLAPPED  Crée une fenêtre "recouvrable" ou à "chevauchement". 
//               une fenêtre overlapped possède une barre de titre et une bordure.
//               Identique à WS_TILED.
 
//WS_OVERLAPPEDWINDOW  Crée une fenêtre overlapped qui inclu aussi les styles :
//                     WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME,
//                     WS_MINIMIZEBOX, et WS_MAXIMIZEBOX.
//                     Identique à WS_TILEDWINDOW. (C'est le style le plus courant) 

//WS_POPUP   Non étudié pour l'instant.

//WS_POPUPWINDOW  Non étudié pour l'instant.

//WS_SIZEBOX   Crée une fenêtre qui possède une bordure de redimensionnement.
//             Identique à WS_THICKFRAME. 

//WS_SYSMENU   Crée une fenêtre qui possède un menu windows dans la barre des titres.
//             WS_CAPTION doit être spécifié.
 
//WS_TABSTOP   Non étudié pour l'instant.

//WS_THICKFRAME  Identique à WS_SIZEBOX.
 
//WS_TILED  Identique à WS_OVERLAPPED style.  

//WS_TILEDWINDOW Identique à WS_OVERLAPPEDWINDOW style.
  
//WS_VISIBLE   Crée une fenêtre qui est initialement visible. 
//WS_VSCROLL   Crée une fenêtre avec une barre de défilement (scroll bar) verticale.



           CW_USEDEFAULT,       // spécifie la position initial horizontal de la fenêtre.
           CW_USEDEFAULT,       // spécifie la position initial vertical de la fenêtre.
                                // Pour ces deux arguments CW_USEDEFAULT laisse le
                                // choix du positionnement à windows (on peut mettre
                                // des valeurs.)

           644,                 // Largeur de la fenêtre en pixels
           475,                 // Hauteur de la fenêtre en pixels

           HWND_DESKTOP,        // La fenêtre est une fenêtre enfant du bureau
                                // Cette notion sera approfondie ultérieurement

           NULL,                // Pas de menu
           hThisInstance,       //  Handle de l'instance d'application (le programme)
           NULL                 //Non étudié pour l'instant.
           );




// Nous allons maintenant afficher la fenêtre à l'écran avec la fonction de l'API :

ShowWindow (hWnd, nCmdShow); // Ici on peut utiliser les SW_XXXXX dont nous parlions
                             // plus haut en argument pour int nCmdShow
                             // Par ex :

//ShowWindow (hWnd,  SW_MAXIMIZE); //affiche une fenêtre en plein  écran.)                       



// puis on déclare un objet de type structure message qui servira pour l'envoi des
// messages récupérés par la fonction LRESULT CALLBACK WindowProcedure ()

MSG messages;            
    

// --------------------- La structure MSG (dans l'include : winuser.h ) -----------------------
//
//         typedef struct tagMSG {
//                 	HWND hwnd;     // handle de la fenêtre
//                 	UINT message;  // Spécifie le numéro du message.
//                 	WPARAM wParam; // Contient des informations complémentaires au message
//	                LPARAM lParam; // Contient des informations complémentaires au message
//                 	DWORD time;    // Spécifie l'heure à laquelle le message a été posté
//                 	POINT pt;      // Spécifie la position du curseur (coordonnées)
//                               } MSG,*LPMSG,*PMSG;
//
//
// --------------------------------------------------------------------------------------------

// La compréhension de ce qu'est un message est très importante ; cette notion sera
// reprise dans la deuxième partie ; en attendant, il suffit de savoir que le deuxième
// membre de la structure UINT message est de type WM_XXXX (WM = Window Message).
  
// Nous trouvons dans winuser.h :

   
 //Window Messages
 //

        //#define WM_NULL                         0x0000
        //#define WM_CREATE                       0x0001
        //#define WM_DESTROY                      0x0002
        //#define WM_MOVE                         0x0003
        //#define WM_SIZE                         0x0005
        //#define WM_ACTIVATE                     0x0006
        // ... la liste continue.

// Ce deuxième membre définit la nature du message ; par exemple ;

// WM_DESTROY est un message qui ordonne à windows de détruire la fenêtre. C'est le premier
// message que nous allons utiliser.

// Les informations wParam, lParam; transmises par les messages seront étudiées dans les
// parties suivantes.    
// --------------------------------------------------------------------------------------------

// Il nous reste maintenant le traitement des messages ; dans une boucle while 

// La fonction  GetMessage () récupère les messages et les places dans la structure MSG

        // BOOL GetMessage(
                        //  LPMSG lpMsg,         // addresse de la structure MSG
                        //  HWND hWnd,           // handle de la fenêtre :
                        //                       // mis à NULL pour pouvoir récupérer
                        //                          les messages de toutes les fenêtres
                        //  UINT wMsgFilterMin,  // premier message
                        //  UINT wMsgFilterMax   // dernier message
                        //);
 
   // SI LA FONCTION récupère un message WM_QUIT ; elle retourne 0.

    while (GetMessage (&messages, NULL, 0, 0))
    {
        
    TranslateMessage(&messages); // Convertit les messages (touches, click ...) 
                                 // en type MSG (&messages)
        
    DispatchMessage(&messages); // Envoie les messages a LRESULT CALLBACK WindowProcedure()
    }

    // La valeur de retour du programme est 0
    // Cette valeur est fournie par PostQuitMessage(); dans le membre donné wParam.
    return messages.wParam;
}

// Fin de la fonction WinMain() ---------------------------------------------------------------


// Nous pouvons maintenant passer à la deuxième fonction de base :
//---------------------------------------------------------------------------------------------
// La fonction LRESULT CALLBACK WindowProcedure est appelée par la fonction
// DispatchMessage(&messages) que nous avons placée dans la boucle  while (GetMessage();

//  LRESULT  : Signed result of message processing.  
//  CALLBACK : Calling convention for callback functions.

// Cette fonction se présente généralement sous forme d'une instruction switch qui traite
// le message recu.

// Soit le message est traité par la fonction, soit il est renvoyé a windows dans le choix
// default:  return DefWindowProc (hwnd, message, wParam, lParam);
// Par ex : un click gauche sur notre fenêtre générera un message WM_LBUTTONDOWN qui
// sera directement envoye a windows et ne provoquera aucun traitement.

// Ici, nous nous contentons de traiter le message WM_DESTROY qui retourne 0, et nous permets
// d'envoyer un message  PostQuitMessage (0); dont l'argument est un code de sortie.
// Cette fonction de l'API a pour effet de placer un message WM_QUIT dans la file d'attente
// réservée a l'application. La fonction GetMessage() de WinMain() renvoie alors la valeur
// FALSE et met fin a la boucle de messages, ce qui arrête le programme.

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  
    {


        case WM_DESTROY:

            PostQuitMessage (0);       // envoie un message WM_QUIT dans la file d'attente
            break;



        default:                      // Tout les autres messages sont renvoyé à windows.
                                      // avec les paramètres wParam et lParam

            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}
// fin de la fonction LRESULT CALLBACK WindowProcedure () -------------------------------------

// ************************ Fin de la première partie *****************************************

//  Pour ceux à qui ce code a rendu service je vous remercierais, de m'envoyer vos commentaires,
// notamment sur les points insuffisamment clairs ou qui mériteraient plus d'explication,
// afin de pouvoir procéder à des mises à jour.

// La partie 2 traitera des menus et la partie 3 des contrôles et boites de dialogues
// Je n'ai pas encore organisé le contenu des parties suivantes.

[Kwai chang caine]

Bon ayai..j'ai un debut de reponse, pour corriger ces messages d'erreur

Faut creer un projet win32 APP et NON console.

Bon reste a trouver comment faire ça

En plus je viens de me rememorer que y'avais un mode RELEASE et un mode DEBUG
C'est vrai....l'enfer recommence....tiens bon KCC ...tiens bon le vent

[Progi1984]

Tu utilises quel IDE ?

[Kwai chang caine]

Bonjour PROGI super content de te parler
Pour l'instant en boite de mouchoir j'utilise KLEENEX
Mais en IDE j'utilise VC++ 6

J'ai essayé de passer en mode WIN32, j'ai bidouillé, a un moment y m'a demandé si je voulais utiliser MFC, je me rappelle que c'est une bibliotheque pour faciliter la programmation, et j'ai dit "VOUI",
J'suis content maintenant j'ai encore plus d'erreur...j'suis a 13...qui dit mieux

[Frenchy Pilou]

Et Kcc il a pas encore essayé ProCessing? (les cours en français du bas de page seront de la petite bière
Qui est quand même un peu plus accessible!

Voir les 169 vidéos du flight 404

Justement Celle-là s'appelle "the REV" C'est majeur

[Kwai chang caine]

Bonjour FRENCHY

Bah en fait, je sais que y'a plein de langages plus faciles que le C et qui sont efficaces
A commencé par PYTHON, enfin moi j'lai pas trouvé simple

Comme je sais que y'a noir de blondes, de 70 balais avec des liftings..

Mais bon ..quand on est amoureux...ça s'explique pas....y'en a qu'une ou qu'un.
Et moi c'est le C..depuis 10 ans j'y pense presque tous les jours...j'achete tout ce sur quoi je tombe dessus et parlant de lui.

Un peu comme les fans de mylene farmer...j'me ruine pour lui...mais je ne peux jamais le toucher, il reste un reve.
Des languages...y'en a "WattMilles" et y'en aura de plus en plus.
Et moi j'ai qu'une tete, qui serait plus efficace en evier, que ce a quoi elle me sert actuellement.

Alors j'ai décidé de garder notre PB d'amour, vous tous parce que je vous aimes aussi, VB6 parce que j'ai pas le choix au boulot, et le HTML, JAVASCRIPT, et PHP et apres plus rien....je veux plus rien entendre parler en languages, sauf evidement le maitre de la force l'ASM....mais la....le pauvre padawan que je suis doit encore peaufiner trois siecle sa formation
Meme le C#, ou le DOT NET pour l'instant....je ne veux pas en entendre parler, comme le VB.NET...tout ça ce ne sont que des dérivés du C....et moi
J'aime que le C

N'importe comment tout sera créé plus ou moins a partir de l'ASM ou du C...alors pourquoi s'adresser aux "seins"....quand on peut parler a dieu
Et puis un language simple, j'ai la chance d'en connaitre un, et des plus puissants...alors pourquoi chercher ce que j'ai deja

KCC comme toutes les burnes y veut pouvoir peter plus haut que son cul....
Et quand y croisent d'autre programmeurs au boulot...c'est rare mais ça arrive....y veut pouvoir dire qu'il fait du C...sans mentir...car KCC y ment jamais (Dommage d'ailleurs)

Quoi qu'il en soit.....merci du lien

[Kwai chang caine]

Bon alors attention; mesdames et mesdames ....

MILOOOOOUUUUU !!!

Euh non, "j'met trompé"

TIIIIIIIIINTIIIIIIIIIIIIIN !!!

Alors je vais commencé par expliquer ce que j'ai pas encore compris.
Et comme ça comme demain, j'aurais oublié...je pourrais me relire
Pour ceux qui veulent monter dans mon train ......

J'aimerais utiliser le VC++ 6 fourni dans VISUAL STUDIO 6 (Y m'a couté un oeil...alors j'voudrais l'amortir )
Donc faut commencer par faire la seule chose que je savais faire y'a a peine 10 mn

Double cliquer sur l'icone VC++
Aouuaaahhh que de route il a fait KCC en 10 mn

Alors la apparait exactement le meme RAD que VB6....mais rien a voir

Cliquer sur File/New
Un panneau apparait pour vous demander "qu'est ce que c'est" que vous vous voulez faire ??? (Il est con...y sait toujours pas que KCC depuis 10 ans y reve de faire une fenetre )

Faut choisir Win32 application, mettre un nom, mois j'ai mis "PbEnC" au hasard
ATTENTION !!! "PC enc...." c'est pas ce que vous croyez ça veut dire "PB en C" ...non mais
Puis repondre an empty project

Bon.... un texte apparait a gauche ecrit "PBEnC classes"
Apres faire project/add to project/new/C-C++ source file
Mettre un nom moi j'ai mis fenetre....
Copier le code C du dessus, coller le dans la fenetre blanche qui viens de se creer
Cliquer sur le petit icone representant un tas de feuille ou CTRL + F7 (Compile)

Code : Tout sélectionner

--------------------Configuration: PbEnC - Win32 Debug--------------------
Compiling...
Fenetre.cpp
Fenetre.obj - 0 error(s), 0 warning(s)

Puis sur execute program, le point d'exclamation rouge (CTRL + F5)
Il dit que c:\PbEnC\Debug\PbEnc.exe n'existe pas, si on veut le compiler ???
On repond "VOUI" et message "La classe est bien enregistrée, cliquez sur OK pour ouvrir la fenetre"

J'ai tout compris a ce message
Ouaaaahhh !!! deja le C y viens de reconnaitre KCC....il lui dit qu'il a la classe
Qu'il a bien enregistré que maintenant KCC y fait partie des programmeurs en C...et que tellement ça lui donne des bouffées de chaleur...il veut ouvrir la fenetre

Et la mesdames et mesdames...devant vos yeux ebahis s'ouvre une fenetre jaune de la mort qui tue sa race
J'en reviens pas....aujourd'hui 19 fevrier 2010 a 12h55, KCC, viens de mettre le premier pas dans le C...
Non non pas la Crotte le vrai C

[Patrick88]

pourquoi ne pas commencer par la base, le C sous DOS par exemple...
une fois que tu le maitrises, faire du c++ puis passer à windows...

pat

[Kwai chang caine]

Bah en fait, je voudrais faire des application fenestrée, tout comme PB
Tu as raison de dire que je m'y prend a l'envers....mais je ne me sent pas capable d'apprendre le C, si je ne l'applique pas tout de suite a ce que j'ai besoin

De plus..je viens de lire un reponse de BRUNEWS qu'il n'etait pas necessaire de connaitre le C pour s'attaquer au C++, voir meme que certaines fonctions avaient changées et que cela pouvait embrouiller ceux qui ne veulent programmer qu'en C++.
Dans un de mes livres que j'ai acheté, il y avait eu la meme reflexion..alors autant te dire que pour une fois qu'on est pas obligé....je vais pas me flageler tout seul

Laisse tomber le DOS et la console, c'etait bon au siecle dernier, tu ne ferais que perdre du temps.

http://www.cppfrance.com/codes/TUTORIAL ... 22680.aspx

Je pense que PB, me donne une tres vague idée des API, pointeur memoire et tout le toutim, VB et PB une autre de tout ce qui est condition, boucle..
Peut etre que je pourrais m'en sortir avec un peu d'aide par ci par la, pour comprendre le C++ et voir meme pouvoir creer un traducteur ??? pourquoi pas

Puisque peut etre que je pourrais encapsuler chaque code de C que je trouverais dans une procedure PB, et comme ça....element par element peut etre ça pourrait marcher ...
En fin de compte, pour l'instant si deja je pouvais utiliser les code C des autres en compliqué, pour faire ce que PB fait simplement, ce serait deja un grand pas
Et ça permettrais de comprendre comment on créé une fenetre,...etc...
Et aussi tout le boulot que c'est tapé notre FRED....pour que ce soit simple