ich möcht doch nur ne linie.



  • Ich bäuchte ein ganz simples beispiel wie ich ne linie unter
    Linux code.

    Den wenn ich mit cc -o bla bla.c compeliere sagt er mir das
    es grahpics.h nicht gibt.

    Bitte nur so einfach und so kurz coden wie möglich.
    Bin der totale linux anfänger.

    danke



  • Neee, grahpics.h gibt es in ANSI C nicht. Das ist doch sicherlich eine proprietäre Erweiterung deines (Borland?) Compiler die nur unter MS-DOS zur Verfügung steht.

    Unter Linux und Unix musst du dagegen mit dem X-Server kommunizieren.

    Auf unterster Ebene (ohne SDL-, Qt- oder GTK-Bibliotheken) müsste es in etwa so ausschauen. Auf die Dauer wirst du allerdings nicht direkt mit den X11 Bibliotheken programmieren wollen weil du mit Hilfe von SDL, Qt oder GTK nicht jedesmal das Rad neu erfinden musst.

    /************************************************************
    *   Rosada Adam 17.09.1999                                  *
    *                                                           *
    *   linie.c fuer X-Window                                   *
    *                                                           *                   
    *   Tabs auf 4 Zeichen einstellen !!!                       *
    *   Als Editor empfehle ich den KWrite oder einen Editor,   *
    *   der einen C-Quelltext farblich darstellen kann.         *
    *   Das vereinfacht die Unterscheidung des eigentlichen     *
    *   Quelltextes von den Kommentaren.                        *                       
    *                                                           *
    *                                                           *
    *   Mit Hilfe dieses Programms kann man eine Linie          *
    *   zeichnen. Beim ersten Mausklick wird der Anfang         *
    *   der Linie gesetzt. Bei gedrueckter Maustaste wird       *
    *   die Linie gezogen (Gummiband-Effekt). Beim Loslassen    *
    *   der Maustaste wird der Endpunkt der Linie gesetzt.      *
    *                                                           *
    *   Das Programm liefert auch sehr viele Ausgaben auf dem   *
    *   Terminal, die zu den einzelnen Ereignissen gehoeren     *
    *   z.B:                                                    *
    *   Mauszeiger bewegen, Maaustaste klicken,                 *
    *   Position des Mauszeigers, Tastaturklick usw.            *
    *                                                           *
    *   Manche von diesen Events haben mit dem Zeichnen der     *
    *   Linie nichts zu tun. Ich habe sie trotzdem eingebaut,   * 
    *   damit man sehen kann, wie einzelne Ereignisse           * 
    *   verarbeitet werden. Es gibt natuerlich noch mehr Events.*
    *                                                           *   
    *   Um die Ausgaben der Events (im Quelltext immer mit      *
    *   ´printf´ beginnend) sehen zu koennen, sollte man        *
    *   das Programm natuerlich auf dem Terminal starten.       *
    *                                                           *   
    *   Zur Compilierung:                                       *
    *   Compiliert wird mit ´gcc´, es muessen die X11R5- bzw.   *
    *   X11R6-Libs eingebunden werden. Der Compilationsaufruf   *
    *   sieht folgendermassen aus:                              *
    *                                                           *
    *   >gcc linie.c -olinie -L/usr/X11R6/lib -lX11             *
    *                                                           *
    *   Das Compilierte Programm heisst dann in diesem Fall     *
    *   ´linie´.                                                *
    *                                                           *
    *   Weitere Informationen in der README-Datei               *
    ************************************************************/                                                       
    
    /* X-include-Dateien */
    #include <X11/Xlib.h>
    #include <X11/Xutil.h>
    
    main(int argc, char **argv)
    {
        char name[] = "Event-Test";
        char los[]  = "los gehts";
    
        /* Vereinbarungen für X */
        Display *display;
        Window window;
        GC gc;              /* Graphikkontext       */
        XEvent event;       /* Ereignisse           */
        KeySym key;         /* Tastatur             */
        XSizeHints hint;    /* Fenstereigenschaften */  
    
        int screen;
        unsigned long black,white;
        int i;
        char text[10];
        int done;
        int anfang_x,anfang_y,anfang=0,alt_x,alt_y;
    
        /*Initialisierungen */
        display = XOpenDisplay("");
        screen  = DefaultScreen(display);
    
        /* Voreinstellungen fuer die Pixelwerte */
        white = WhitePixel(display,screen);
        black = BlackPixel(display,screen);
    
        /* Position und Groesse des Fensters */
        hint.x = 200; hint.y = 300;
        hint.width = 350; hint.height = 250;
        hint.flags = PPosition | PSize;
    
        /* Das Fenster erzeugen */
        window = XCreateSimpleWindow(display,
                                    DefaultRootWindow(display),
                                    hint.x,hint.y,
                                    hint.width,hint.height,
                                    5,black,white);
        XSetStandardProperties(display,window,name,
                                    name,None,argv,
                                    argc,&hint);
    
        /* Grafikkontext erzeugen und initialisieren */                         
        gc = XCreateGC(display,window,0,0);
        XSetBackground(display,gc,white);   /* Hintergrundfarbe */
        XSetForeground(display,gc,black);   /* Vordergrundfarbe */
    
        /* Eingabe-Ereignisse auswaehlen */
        XSelectInput(display,window,    ButtonPressMask     /* Maustaste klicken            */
                                    | ButtonReleaseMask     /* Maustaste loslassen          */
                                    | KeyPressMask          /* Tastaturtaste druecken       */
                                    | KeyReleaseMask        /* Tastaturtaste loslassen      */
                                    | ExposureMask          /* Fenstergroesse aendern       */
                                    | PointerMotionMask     /* Mauszeiger bewegen           */
                                    | EnterWindowMask       /* Mauszeiger verlaesst Window  */
                                    | LeaveWindowMask);     /* Mauszeiger betritt Window    */
        /* Window abbilden */
        XMapRaised(display,window);
    
        /* Hauptschleife mit Abfrage der Ereignisse */
        done = 0;
        while ( done == 0)
        {
            /* Das naechste Ereigniss lesen */
            XNextEvent(display, &event);
            switch (event.type)
            {
                /* Window nach Expose-Event wiederherstellen */
                case Expose:
                    if (event.xexpose.count == 0)
                        XDrawImageString(event.xexpose.display, /* siehe README */
                                    event.xexpose.window,
                                    gc,50,50,los,strlen(los));
                    printf("Expose-Event: Neuzeichnen\n");  /* Terminalausgabe  */
                    break;
    
                /* Abbildungsaenderung der Tastatur. */     
                case MappingNotify:
                    XRefreshKeyboardMapping((XMappingEvent *) &event);
                    break;
    
                /* Druecken der Maustaste */    
                case ButtonPress:
                    printf("ButtonPress: Mausbutton gedrueckt\n");
                    anfang_x=event.xbutton.x;   /* Speichern der Kordinaten beim        */
                    anfang_y=event.xbutton.y;   /* Mausklick für den Anfang der Linie   */                                          
                    anfang=1;                   /* Anfang wird auf 1 gesetzt            */
                    break;
    
                /* Loslassen der Maustaste */   
                case ButtonRelease:
                    printf("ButtonRelease: Mausbutton losgelassen\n");
                    anfang=0;                   /* Anfang wieder auf 0 setzen */
                    break;
    
                /* Tastaturtaste losgelassen */     
                case KeyRelease:
                    printf("KeyRelease: Taste losgelassen\n");
                    break;
    
                /* Bewegung des Mauszeigers*/       
                case MotionNotify:
                    printf("X: %d Y: %d \n",event.xbutton.x,event.xbutton.y);
                    if(anfang>0)    /* Wenn Anfang gesetzt war */
                    {
                        if(anfang>1)  /* Gummiband-Effekt, alte Linie wird geloescht */
                        {
                            XSetForeground(display,gc,white); /* Vordergrundfarbe auf weiss */
                            XDrawLine(event.xexpose.display,  /* siehe README */
                                    event.xexpose.window,gc,
                                    anfang_x,anfang_y,
                                    alt_x,alt_y);
                            XSetForeground(display,gc,black); /* Vordergrundfarbe wieder auf schwarz */
                        }/* if(anfang>1) */
    
                        alt_x=event.xbutton.x;  /* Speichern der Endpunkt-Koordinaten */    
                        alt_y=event.xbutton.y;  
    
                        XDrawLine(event.xexpose.display, /* Zeichnen der Linie */
                                event.xexpose.window,
                                gc,anfang_x,anfang_y,
                                event.xbutton.x,event.xbutton.y);
                        anfang++;   /* Anfang erhoehen, wichtig fuer den Gummiband-Effekt */
                    }/*if anfang>0*/        
                break;
    
                /* Mauszeiger betritt das Fenster */    
                case EnterNotify:
                    printf("EnterNotify: Zeiger betritt Window\n");
                    break;
    
                /* Mauszeiger verlaesst das Fenster */              
                case LeaveNotify:
                    printf("LeaveNotify: Zeiger verlaesst Window\n");
                    break;
    
                /* Tastatureingabe */
                case KeyPress:
                    /* Eingelesenes Zeichen wird gespeichert */         
                    i = XLookupString((XKeyEvent *) &event,text,10,&key,0);
    
                    if ( i==1 && text[0] == 'q')    /* Wenn ´q´ gedrueckt wird,     */
                        done = 1;                   /* wird das Programm beendet    */      
                    printf("KeyPress: Taste gedrueckt\n");
                    break;
    
            }/*switch*/
        }/*while*/
    
        /* Terminierung */
        XFreeGC(display,gc);
        XDestroyWindow(display,window);
        XCloseDisplay(display);
        exit(0);
    }/*main*/
    


  • Warum wollen in letzter Zeit soviele Leute eine Linie in Linux zeichnen 😕

    (FAQ - Linux...) Help??? Kann mir jemand ein Linie codieren!!!



  • Der Hinweise auf das Posting ist nicht schlecht allerdings muss angemerkt werden, dass die dort erwähnte API (ClanLib Game SDK) C++ **voraussetzt der ursprungsposter allerdings mit "cc" lediglich den C Compiler angeworfen hat. In der Hinsicht dürfte GTK+ < http://www.gtk.org/tutorial/ > oder SDL < http://www.libsdl.org/ > < http://www.libsdl.de/ > eher geeignet sein.

    in etwa sowas wie:

    #include <stdlib.h>
    #include "SDL.h"
    #include "SDL_image.h"
    #include "SDL_endian.h" /* Fuer einen 24-Bit-Modus unabhaengig von der Bytereihenfolge. */
                            /* Wird von DrawPixel() benoetigt */
    
    void DrawPixel(SDL_Surface* screen, int x, int y, Uint8 R, Uint8 G, Uint8 B);
    
    int main(int argc, char** argv)
    {
      SDL_Surface* display;
    
      /* init video stuff */
      if ( SDL_Init( SDL_INIT_VIDEO) < 0 )
        {
          fprintf(stderr, "SDL konnte nicht initialisiert werden:  %s\n", SDL_GetError());
          exit(1);
        }
    
      atexit(SDL_Quit);
    
      // init screen
      display = SDL_SetVideoMode( 800, 600, 16, SDL_SWSURFACE);
      if ( display == NULL )
        {
          fprintf(stderr, "Konnte kein Fenster 640x480px oeffnen: %s\n", SDL_GetError());
          exit(1);
        }
    
      for( int x=0; x < 800; x++ )
        {
          DrawPixel( display, x, display->h/2, 255, 255, 255);
        }
    
      SDL_Flip(display);
    
      SDL_Delay(3000);
    
      return 0;
    }
    
    void DrawPixel(SDL_Surface* screen, int x, int y, Uint8 R, Uint8 G, Uint8 B)
    {
      Uint32 color = SDL_MapRGB(screen->format, R, G, B);
    
      if ( SDL_MUSTLOCK(screen) )
        {
          if ( SDL_LockSurface(screen) < 0 )
            {
              return;
            }
        }
      switch (screen->format->BytesPerPixel)
        {
          case 1:
          { /* vermutlich 8 Bit */
            Uint8 *bufp;
    
            bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
            *bufp = color;
          }
          break;
    
          case 2: 
          { /* vermutlich 15 Bit oder 16 Bit */
            Uint16 *bufp;
    
            bufp = (Uint16 *)screen->pixels + y*screen->pitch/2 + x;
            *bufp = color;
          }
          break;
    
          case 3: 
          { /* langsamer 24-Bit-Modus, selten verwendet */
            Uint8 *bufp;
    
            bufp = (Uint8 *)screen->pixels + y*screen->pitch + x * 3;
            if(SDL_BYTEORDER == SDL_LIL_ENDIAN) 
              {
                bufp[0] = color;
                bufp[1] = color >> 8;
                bufp[2] = color >> 16;
              } 
            else
              {
                bufp[2] = color;
                bufp[1] = color >> 8;
                bufp[0] = color >> 16;
              }
          }
          break;
    
          case 4: 
          { /* vermutlich 32 Bit */
            Uint32 *bufp;
    
            bufp = (Uint32 *)screen->pixels + y*screen->pitch/4 + x;
            *bufp = color;
          }
          break;
        }
      if ( SDL_MUSTLOCK(screen) )
        {
          SDL_UnlockSurface(screen);
        }
      SDL_UpdateRect(screen, x, y, 1, 1);
    }
    

    **



  • [QUOTE]Original erstellt von Headhunter:
    **Warum wollen in letzter Zeit soviele Leute eine Linie in Linux zeichnen 😕

    (FAQ - Linux...) Help??? Kann mir jemand ein Linie codieren!!!**[/QUOTE ]

    ich glaub das ist wirklich was für die FAQ, wie man eine Linie zeichnet 🙂


Anmelden zum Antworten