-- Leo's gemini proxy

-- Connecting to git.thebackupbox.net:1965...

-- Connected

-- Sending request

-- Meta line: 20 text/gemini

repo: g15term
action: blob
revision:
path_from: g15term.c
revision_from: refs/heads/trunk:
path_to:
revision_to:

refs/heads/trunk:/g15term.c
 #define _GNU_SOURCE 1

 #include <stdlib.h> // free
 #include <g15daemon_client.h>
 #include <libg15.h>
 #include <libg15render.h>
 #include <stdio.h> // printf
 #include <sys/socket.h> // recv
 #include <unistd.h> // read
 #include <pthread.h>
 #include "libtmt/tmt.h"

 // TEXT_MED seems to be 8 x 5
 // TEXT_SMALL seems to be 6 x ...
 #if 1
 #define FONT G15_TEXT_MED
 #define TERM_ROWS 5
 #define TERM_COLS 32
 #define FONT_HEIGHT 8
 #else
 #define FONT G15_TEXT_SMALL
 #define TERM_ROWS 6
 #define TERM_COLS 40
 #define FONT_HEIGHT 7
 #endif

 int g15screen_fd;
 pthread_cond_t wake_now = PTHREAD_COND_INITIALIZER;


 void g15stats_wait(long seconds,long nsecs) {
     pthread_mutex_t dummy_mutex;
     pthread_mutexattr_t   mta;
     struct timespec timeout;
     /* Create a dummy mutex which doesn't unlock for sure while waiting. */
     pthread_mutexattr_init(&mta);

     pthread_mutex_init(&dummy_mutex, &mta);
     pthread_mutex_lock(&dummy_mutex);

     if (clock_gettime(CLOCK_REALTIME, &timeout) != 0) {
         perror("clock_gettime");
     }

     timeout.tv_sec += seconds;
     timeout.tv_nsec += nsecs;
     if(timeout.tv_nsec > 1000000000) {
         timeout.tv_nsec %= 1000000000;
 	timeout.tv_sec += 1;
     }

     pthread_cond_timedwait(&wake_now, &dummy_mutex, &timeout);
     pthread_mutex_unlock(&dummy_mutex);
     pthread_mutex_destroy(&dummy_mutex);
     pthread_mutexattr_destroy(&mta);
 }

 g15canvas *canvas;

 void tmt_callback(tmt_msg_t m,TMT *vt, const void *a, void *vt_old) {
     const TMTSCREEN *s=tmt_screen(vt);
     char tmp[256];
     size_t c,r;
     switch(m) {
         case TMT_MSG_UPDATE: // screen image changed
             for(r =0 ; r < s->nline; r++) {
                 if(!s->lines[r]->dirty) continue;
                 for(c = 0; c < s->ncol ; c++) {
                     tmp[c]=s->lines[r]->chars[c].c;
                 }
 		tmp[c]='\0';
                 //g15r_renderString (canvas, (unsigned char*)tmp, 0, G15_TEXT_MED, 0, r * 8); //guessing font size
                 g15r_renderString (canvas, (unsigned char*)tmp, 0, FONT, 0, r * FONT_HEIGHT); //guessing font size
 	    }
 	    break;
         case TMT_MSG_ANSWER: // terminal responded to a query
 	case TMT_MSG_BELL: // bep
 	case TMT_MSG_MOVED: // cursor changed position
         default:
 	    printf("unhandled msg type: %d\n",m);
     }
 }

 int main(int argc, char *argv[]){
     canvas = (g15canvas *) malloc (sizeof (g15canvas));
     if(canvas != NULL) {
         g15r_initCanvas(canvas);
     }
     else {
         return -1;
     }

     TMT *vt_old = tmt_open(TERM_ROWS,TERM_COLS,NULL,NULL,NULL);
     if(!vt_old) return 1;
     TMT *vt = tmt_open(TERM_ROWS,TERM_COLS,tmt_callback,vt_old,NULL);
     if(!vt) return 2;
     int i;
     if((g15screen_fd = new_g15_screen(G15_G15RBUF))<0){
         printf("Sorry, cant connect to the G15daemon\n");
         return 3;
     }
     for(i=0;i<G15_BUFFER_LEN;i++) {
         canvas->buffer[i]=0;
     }

     canvas->mode_xor = 0;
     char in[4096];
     int ret;
     while(1) {
        ret=read(0,in,4096);
        if(ret <= 0) {
            perror("read");
 	   return 4;
        }
        tmt_write(vt,in,ret);
        g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
        g15stats_wait(0,100000000);
     }
     close(g15screen_fd);
     free(canvas);
     return 0;
 }

-- Response ended

-- Page fetched on Sun Jun 2 18:23:22 2024