Baillehache Pascal's personal website

A lightweight structure to display interactive graphics in C

Edit on 2022/12/23: check this article for another approach: X11 and multithreading.

In this article I'll show how to implement a simple interactive graphical display in C using GTK. GTK is a free and open-source cross-platform widget toolkit for creating graphical user interface. It's easy to use and extremely powerful, but has so many features a beginner may feel intimidated with it, and even a more advanced user may think there is too much work to do to only display some simple graphics. The goal of this article is to provide a structure hiding all the GTK mechanics and allowing the user to display and interact with a RGB image, in less than 10 lines of code.

From the user's point of view, displaying RGB images on the screen should really not look more than something like this:

// Include the structure taking care of the graphical display.
#include "display.h"

int main() {

  ...

  // When you're ready, create the display
  Display* display = DisplayAlloc(nbCols, nbRows, "Window's title");
  
  // Draw the image in the display, for example pixel by pixel with
  // DisplaySetPixel(display, x, y, r, g, b);

  // Actually show the display on screen
  DisplayShow(display);

  ...
  
  // You can let the user close the window of the display when needed
  // or close it yourself
  DisplayClose(display);
  
  // Release the resources associated with the display when it's not needed
  // any more
  DisplayFree(&display);

  ...

}

The display should run in parallel, not blocking the user code, and the user should not have to bother about its internal mechanism. It should also be dynamic, if the user updates the graphic with DisplaySetPixel() after showing the display, it should reflect the change. Several displays in parallel should be possible (with no assumption of their order of creation, update and destruction). And finally to make it interactive, there should be a DisplayGetKeyPressed() function to detect and react to key press events on the display. I'll restrain here the functionality to key press but it's straightforward to extend it to mouse events. I'll also impose the display to be non resizable, and don't worry about double buffering during display, as it makes things much more simple and should be already enough to cover many cases. Of course, feel free to extend the code below to fit your need.

Rhe display will run in its own process, spawned when it is shown. A shared segment of memory will be used for interaction between the user code and the process managing the display. And as I said, all the GTK stuff to actually display the window and manage it will be done in the display process. If you really only care of using it, the code of display.h and display.c is available at the end of this article. Copy it and start using it as in the example above. This structure is also available in my LibCapy library as the CapyDisplay class (also providing more functionalities). Instead, if you're interested into how it's implemented, here comes the explanation.

Include the needed headers for GTK and shared memory segments:

#include <gtk/gtk.h>
#include <sys/ipc.h>
#include <sys/shm.h>

The Display structure definition:

typedef struct Display {

  // Dimensions of the Display
  int nbCols, nbRows;

  // Window's title
  char* title;

  // GTK variables to manage the window
  GtkApplication* gtkApp;
  GApplication* gApp;
  GtkWidget* window;
  GdkPixbuf* pixbuf;
  int rowstride;
  int n_channels;
  GtkImage* image;
  unsigned int timerId;

  // Variables to manage the two shared segments (one for the pixels value
  // and for the communication between the Display and the user process).
  int sharedMemId;
  int comId;
  guchar* sharedPixels;
  DisplayCom* com;

} Display;

Definition of the DisplayCom structure (shared data between the user process and the Display process for interaction):

typedef struct DisplayCom {

  // Flag to memorise the request from the client to close the Display
  gboolean flagClose;

  // Buffer to memorise the key pressed waiting to be processed by the
  // user process
  unsigned char keyPressed[256];
  unsigned char idxLastWrite;
  unsigned char idxLastRead;

} DisplayCom;

Declaration of the interface of the Display structure:

// Create an instance of the application
// Inputs:
//   nbCols: number of columns of the Display
//   nbRows: number of rows of the Display
//   title: title displayed in the title bar of the window of the Display
// Output:
//   Return a newly allocated Display
Display* DisplayAlloc(
  int nbCols,
  int nbRows,
  char* title);

// Show a Display on the screen
// Input:
//   display: the Display to show
void DisplayShow(Display* display);

// Free the resource associated with a Display
// Input:
//   display: the Display to free
void DisplayFree(Display** display);

// Close the window of the Display
// Input:
//   display: the Display to close
void DisplayClose(Display* display);

// Return the last key pressed since the last call to DisplayGetKeyPressed
// Input:
//   display: the Display receiving the key pressed event
// Output:
//   Return the key value, or 0 if there wasn't any key pressed
unsigned char DisplayGetKeyPressed(Display* display);

// Set the RGB value of a pixel in the Display
// Inputs:
//   display: the Display to be updated
//   x: the horizontal position of the pixel (starts at 0, from left to right)
//   y: the vertical position of the pixel (starts at 0, from top to bottom)
//   r,g,b: the new RGB values of the pixel
void DisplaySetPixel(
  Display* display,
  int x,
  int y,
  int r,
  int g,
  int b);

Definition of each function of the interface:

// Create an instance of the application
// Inputs:
//   nbCols: number of columns of the Display
//   nbRows: number of rows of the Display
//   title: title displayed in the title bar of the window of the Display
// Output:
//   Return a newly allocated Display
Display* DisplayAlloc(
  int nbCols,
  int nbRows,
  char* title) {

  // Allocate memory for the Display
  Display* display = malloc(sizeof(Display));

  // Set the dimensions and title
  display->nbCols = nbCols;
  display->nbRows = nbRows;
  display->title = title;

  // Create the GTK application
  display->gtkApp = gtk_application_new(
    NULL, 
    G_APPLICATION_FLAGS_NONE);
  display->gApp = G_APPLICATION(display->gtkApp);

  // Connect the callback function on the 'activate' event
  g_signal_connect(
    display->gtkApp, 
    "activate", 
    G_CALLBACK(CbActivate), 
    display);

  // Create the pixbuf needed to draw the RGB array onto the widget
  gboolean has_alpha = FALSE;
  int bits_per_sample = 8;
  display->pixbuf = gdk_pixbuf_new(
    GDK_COLORSPACE_RGB,
    has_alpha,
    bits_per_sample,
    display->nbCols,
    display->nbRows);
  display->rowstride = gdk_pixbuf_get_rowstride(display->pixbuf);
  display->n_channels = gdk_pixbuf_get_n_channels(display->pixbuf);

  // Create the shared segment for the pixels array
  display->sharedMemId =
    shmget(
      IPC_PRIVATE,
      sizeof(guchar) * display->nbRows * display->rowstride,
      0777 | IPC_CREAT);
  display->sharedPixels = (guchar*)shmat(display->sharedMemId, 0, 0);

  // Create the shared segment for communication
  display->comId =
    shmget(
      IPC_PRIVATE,
      sizeof(DisplayCom),
      0777 | IPC_CREAT);
  display->com = (DisplayCom*)shmat(display->comId, 0, 0);

  // Init the communication parameters
  display->com->flagClose = FALSE;
  display->com->idxLastWrite = 0;
  display->com->idxLastRead = 0;

  // Return the new display
  return display;

}

// Free the resource associated with a Display
// Input:
//   display: the Display to free
void DisplayFree(Display** display) {

  // Detach the shared memory segment
  shmdt((*display)->sharedPixels);
  shmdt((*display)->com);

  // Free memory
  g_object_unref((*display)->pixbuf);
  g_object_unref((*display)->gtkApp);
  free(*display);
  *display = NULL;

}

// Show a Display on the screen
// Input:
//   display: the Display to show
void DisplayShow(Display* display) {

  // Fork the process to run the display independently
  if (fork() == 0) {

    // Initialise the GTK library. Make the simplification to pass manually
    // created argc and argv.
    int argc = 1;
    char** argv = {&(display->title)};
    gtk_init(
      &argc, 
      &argv);

    // Run the application at the G level (ignore the return status).
    // Blocking until the user closes the window or it is programmatically
    // closed with gtk_window_close()
    (void)g_application_run(
      display->gApp, 
      0, 
      NULL);

    // Free the resources
    DisplayFree(&display);

    // End the child process
    exit(0);

  }

}

// Close the window of the Display
// Input:
//   display: the Display to close
void DisplayClose(Display* display) {

  // Set the flag in the shared segment, this will trigger gtk_window_close()
  // at the next call of Tick()
  display->com->flagClose = TRUE;

}

// Return the last key pressed since the last call to DisplayGetKeyPressed
// Input:
//   display: the Display receiving the key pressed event
// Output:
//   Return the key value, or 0 if there wasn't any key pressed
unsigned char DisplayGetKeyPressed(Display* display) {

  // Variable to memorise the returned value
  unsigned char ret = 0;

  // If there are keys waiting in the buffer
  if (display->com->idxLastRead != display->com->idxLastWrite) {

    // Move the index to the next key to read. Simply take advantage of the
    // overflow to loop back to the beginning of the buffer after 256 keys
    (display->com->idxLastRead)++;

    // Update the returned value with the key in the buffer
    ret = display->com->keyPressed[display->com->idxLastRead];

  }

  // Return the last key press value
  return ret;

}

// Set the RGB value of a pixel in the Display
// Inputs:
//   display: the Display to be updated
//   x: the horizontal position of the pixel (starts at 0, from left to right)
//   y: the vertical position of the pixel (starts at 0, from top to bottom)
//   r,g,b: the new RGB values of the pixel
void DisplaySetPixel(
  Display* display,
  int x,
  int y,
  int r,
  int g,
  int b) {

  // Get the index of the pixel
  int idx = y * display->rowstride + x * display->n_channels;

  // Update the RGB values of the pixel in the shared segment. The Tick()
  // function will update the displayed widget with the new values next time
  // it is called.
  display->sharedPixels[idx + 0] = r;
  display->sharedPixels[idx + 1] = g;
  display->sharedPixels[idx + 2] = b;

}

Private functions of display.c:

// Redraw the displayed graphics with the contents of the pixbuf and
// process/update data in the communication shared segment
// Input:
//   data: pointer to the Display
static gboolean Tick(gpointer data) {

  // Get the pointer to the Display
  Display* display = (Display*)data;

  // Update the pixbuf with the data from the client in the shared memory
  memcpy(
    gdk_pixbuf_get_pixels(display->pixbuf),
    display->sharedPixels,
    sizeof(guchar) * display->nbRows * display->rowstride);

  // Refresh the displayed graphics
  gtk_image_set_from_pixbuf(
    display->image,
    display->pixbuf);
  gtk_widget_queue_draw(GTK_WIDGET(display->image));

  // Process the communication with the client
  if (display->com->flagClose == TRUE)
    gtk_window_close(GTK_WINDOW(display->window));

  // Return true to stop the callback chain
  return TRUE;

}

// Callback function for the delete event
// Inputs:
//   widget: Widget receiving the event
//   event: the event
//   data: pointer to the Display
static gboolean CbDeleteEvent(
  GtkWidget* widget,
  GdkEvent* event, 
  gpointer data) {

  // Unused arguments
  (void)widget; (void)event;
  
  // Get the pointer to the Display
  Display* display = (Display*)data;

  // Quit the application at GTK level
  gtk_main_quit();

  // Quit the application at G level
  g_application_quit(display->gApp);

  // Return false to continue the callback chain
  return FALSE;

}

// Callback function for the key press event
// Inputs:
//   widget: Widget receiving the event
//   event: the event
//   data: pointer to the Display
static gboolean CbKeyPressEvent(
  GtkWidget* widget,
  GdkEventKey* event, 
  gpointer data) {

  // Unused arguments
  (void)widget;
  
  // Get the pointer to the Display
  Display* display = (Display*)data;

  // If the buffer is not full
  if (display->com->idxLastWrite + 1 != display->com->idxLastRead) {

    // Increase the index of the last pressed key in the buffer. Take
    // advantage of the overflow to loop back to the beginning of the buffer
    // after 256 keys
    (display->com->idxLastWrite)++;
    
    // Update the key pressed in the buffer
    display->com->keyPressed[display->com->idxLastWrite] = event->keyval;

  }

  // Return true to stop the callback chain
  return FALSE;

}

// Callback function for the activate event
// Inputs:
//   gtkApp: the activated application
//   data: pointer to the Display
static void CbActivate(
  GtkApplication* gtkApp, 
  gpointer data) {

  // Unused arguments
  (void)gtkApp;

  // Get the pointer to the Display
  Display* display = (Display*)data;

  // Get the main window
  display->window = gtk_application_window_new(display->gtkApp);

  // Set the callback on the delete event
  g_signal_connect(
    display->window, 
    "delete-event",
    G_CALLBACK(CbDeleteEvent), 
    display);

  // Set the callback on the key press event
  g_signal_connect(
    display->window, 
    "key-press-event",
    G_CALLBACK(CbKeyPressEvent), 
    display);

  // Create the widget to display the graphics
  display->image = GTK_IMAGE(gtk_image_new_from_pixbuf(display->pixbuf));
  gtk_container_add(
    GTK_CONTAINER(display->window),
    GTK_WIDGET(display->image));

  // Avoid window resizing
  gtk_window_set_resizable(
    GTK_WINDOW(display->window), 
    FALSE);

  // Call the redraw function every 40ms (25 times per second) to update the
  // graphics and process the key pressed
  guint timerIntervalMs = 40;
  display->timerId = g_timeout_add(
    timerIntervalMs,
    Tick,
    display);

  // Display the window on the screen
  gtk_widget_show_all(display->window);

  // Run the application at the GTK level
  gtk_main();

}

Finally, the whole code for the Display structure. display.h:

/*
    Display - a C data structure and the functions to manipulate it, to
    simply display and interact with a graphical display based on GTK
    Copyright (C) 2021  Pascal Baillehache baillehache.pascal@gmail.com
    https://baillehachepascal.dev
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <gtk/gtk.h>
#include <sys/ipc.h>
#include <sys/shm.h>

typedef struct DisplayCom {

  // Flag to memorise the request from the client to close the Display
  gboolean flagClose;

  // Buffer to memorise the key pressed waiting to be processed by the
  // user process
  unsigned char keyPressed[256];
  unsigned char idxLastWrite;
  unsigned char idxLastRead;

} DisplayCom;

typedef struct Display {

  // Dimensions of the Display
  int nbCols, nbRows;

  // Window's title
  char* title;

  // GTK variables to manage the window
  GtkApplication* gtkApp;
  GApplication* gApp;
  GtkWidget* window;
  GdkPixbuf* pixbuf;
  int rowstride;
  int n_channels;
  GtkImage* image;
  unsigned int timerId;

  // Variables to manage the two shared segments (one for the pixels value
  // and for the communication between the Display and the user process).
  int sharedMemId;
  int comId;
  guchar* sharedPixels;
  DisplayCom* com;

} Display;

// Create an instance of the application
// Inputs:
//   nbCols: number of columns of the Display
//   nbRows: number of rows of the Display
//   title: title displayed in the title bar of the window of the Display
// Output:
//   Return a newly allocated Display
Display* DisplayAlloc(
  int nbCols,
  int nbRows,
  char* title);

// Show a Display on the screen
// Input:
//   display: the Display to show
void DisplayShow(Display* display);

// Free the resource associated with a Display
// Input:
//   display: the Display to free
void DisplayFree(Display** display);

// Close the window of the Display
// Input:
//   display: the Display to close
void DisplayClose(Display* display);

// Return the last key pressed since the last call to DisplayGetKeyPressed
// Input:
//   display: the Display receiving the key pressed event
// Output:
//   Return the key value, or 0 if there wasn't any key pressed
unsigned char DisplayGetKeyPressed(Display* display);

// Set the RGB value of a pixel in the Display
// Inputs:
//   display: the Display to be updated
//   x: the horizontal position of the pixel (starts at 0, from left to right)
//   y: the vertical position of the pixel (starts at 0, from top to bottom)
//   r,g,b: the new RGB values of the pixel
void DisplaySetPixel(
  Display* display,
  int x,
  int y,
  int r,
  int g,
  int b);

display.c:

/*
    Display - a C data structure and the functions to manipulate it, to
    simply display and interact with a graphical display based on GTK
    Copyright (C) 2021  Pascal Baillehache baillehache.pascal@gmail.com
    https://baillehachepascal.dev
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "display.h"

// Redraw the displayed graphics with the contents of the pixbuf and
// process/update data in the communication shared segment
// Input:
//   data: pointer to the Display
static gboolean Tick(gpointer data) {

  // Get the pointer to the Display
  Display* display = (Display*)data;

  // Update the pixbuf with the data from the client in the shared memory
  memcpy(
    gdk_pixbuf_get_pixels(display->pixbuf),
    display->sharedPixels,
    sizeof(guchar) * display->nbRows * display->rowstride);

  // Refresh the displayed graphics
  gtk_image_set_from_pixbuf(
    display->image,
    display->pixbuf);
  gtk_widget_queue_draw(GTK_WIDGET(display->image));

  // Process the communication with the client
  if (display->com->flagClose == TRUE)
    gtk_window_close(GTK_WINDOW(display->window));

  // Return true to stop the callback chain
  return TRUE;

}

// Callback function for the delete event
// Inputs:
//   widget: Widget receiving the event
//   event: the event
//   data: pointer to the Display
static gboolean CbDeleteEvent(
  GtkWidget* widget,
  GdkEvent* event, 
  gpointer data) {

  // Unused arguments
  (void)widget; (void)event;
  
  // Get the pointer to the Display
  Display* display = (Display*)data;

  // Quit the application at GTK level
  gtk_main_quit();

  // Quit the application at G level
  g_application_quit(display->gApp);

  // Return false to continue the callback chain
  return FALSE;

}

// Callback function for the key press event
// Inputs:
//   widget: Widget receiving the event
//   event: the event
//   data: pointer to the Display
static gboolean CbKeyPressEvent(
  GtkWidget* widget,
  GdkEventKey* event, 
  gpointer data) {

  // Unused arguments
  (void)widget;
  
  // Get the pointer to the Display
  Display* display = (Display*)data;

  // If the buffer is not full
  if (display->com->idxLastWrite + 1 != display->com->idxLastRead) {

    // Increase the index of the last pressed key in the buffer. Take
    // advantage of the overflow to loop back to the beginning of the buffer
    // after 256 keys
    (display->com->idxLastWrite)++;
    
    // Update the key pressed in the buffer
    display->com->keyPressed[display->com->idxLastWrite] = event->keyval;

  }

  // Return true to stop the callback chain
  return FALSE;

}

// Callback function for the activate event
// Inputs:
//   gtkApp: the activated application
//   data: pointer to the Display
static void CbActivate(
  GtkApplication* gtkApp, 
  gpointer data) {

  // Unused arguments
  (void)gtkApp;

  // Get the pointer to the Display
  Display* display = (Display*)data;

  // Get the main window
  display->window = gtk_application_window_new(display->gtkApp);

  // Set the callback on the delete event
  g_signal_connect(
    display->window, 
    "delete-event",
    G_CALLBACK(CbDeleteEvent), 
    display);

  // Set the callback on the key press event
  g_signal_connect(
    display->window, 
    "key-press-event",
    G_CALLBACK(CbKeyPressEvent), 
    display);

  // Create the widget to display the graphics
  display->image = GTK_IMAGE(gtk_image_new_from_pixbuf(display->pixbuf));
  gtk_container_add(
    GTK_CONTAINER(display->window),
    GTK_WIDGET(display->image));

  // Avoid window resizing
  gtk_window_set_resizable(
    GTK_WINDOW(display->window), 
    FALSE);

  // Call the redraw function every 40ms (25 times per second) to update the
  // graphics and process the key pressed
  guint timerIntervalMs = 40;
  display->timerId = g_timeout_add(
    timerIntervalMs,
    Tick,
    display);

  // Display the window on the screen
  gtk_widget_show_all(display->window);

  // Run the application at the GTK level
  gtk_main();

}





// Create an instance of the application
// Inputs:
//   nbCols: number of columns of the Display
//   nbRows: number of rows of the Display
//   title: title displayed in the title bar of the window of the Display
// Output:
//   Return a newly allocated Display
Display* DisplayAlloc(
  int nbCols,
  int nbRows,
  char* title) {

  // Allocate memory for the Display
  Display* display = malloc(sizeof(Display));

  // Set the dimensions and title
  display->nbCols = nbCols;
  display->nbRows = nbRows;
  display->title = title;

  // Create the GTK application
  display->gtkApp = gtk_application_new(
    NULL, 
    G_APPLICATION_FLAGS_NONE);
  display->gApp = G_APPLICATION(display->gtkApp);

  // Connect the callback function on the 'activate' event
  g_signal_connect(
    display->gtkApp, 
    "activate", 
    G_CALLBACK(CbActivate), 
    display);

  // Create the pixbuf needed to draw the RGB array onto the widget
  gboolean has_alpha = FALSE;
  int bits_per_sample = 8;
  display->pixbuf = gdk_pixbuf_new(
    GDK_COLORSPACE_RGB,
    has_alpha,
    bits_per_sample,
    display->nbCols,
    display->nbRows);
  display->rowstride = gdk_pixbuf_get_rowstride(display->pixbuf);
  display->n_channels = gdk_pixbuf_get_n_channels(display->pixbuf);

  // Create the shared segment for the pixels array
  display->sharedMemId =
    shmget(
      IPC_PRIVATE,
      sizeof(guchar) * display->nbRows * display->rowstride,
      0777 | IPC_CREAT);
  display->sharedPixels = (guchar*)shmat(display->sharedMemId, 0, 0);

  // Create the shared segment for communication
  display->comId =
    shmget(
      IPC_PRIVATE,
      sizeof(DisplayCom),
      0777 | IPC_CREAT);
  display->com = (DisplayCom*)shmat(display->comId, 0, 0);

  // Init the communication parameters
  display->com->flagClose = FALSE;
  display->com->idxLastWrite = 0;
  display->com->idxLastRead = 0;

  // Return the new display
  return display;

}

// Free the resource associated with a Display
// Input:
//   display: the Display to free
void DisplayFree(Display** display) {

  // Detach the shared memory segment
  shmdt((*display)->sharedPixels);
  shmdt((*display)->com);

  // Free memory
  g_object_unref((*display)->pixbuf);
  g_object_unref((*display)->gtkApp);
  free(*display);
  *display = NULL;

}

// Show a Display on the screen
// Input:
//   display: the Display to show
void DisplayShow(Display* display) {

  // Fork the process to run the display independently
  if (fork() == 0) {

    // Initialise the GTK library. Make the simplification to pass manually
    // created argc and argv.
    int argc = 1;
    char** argv = {&(display->title)};
    gtk_init(
      &argc, 
      &argv);

    // Run the application at the G level (ignore the return status).
    // Blocking until the user closes the window or it is programmatically
    // closed with gtk_window_close()
    (void)g_application_run(
      display->gApp, 
      0, 
      NULL);

    // Free the resources
    DisplayFree(&display);

    // End the child process
    exit(0);

  }

}

// Close the window of the Display
// Input:
//   display: the Display to close
void DisplayClose(Display* display) {

  // Set the flag in the shared segment, this will trigger gtk_window_close()
  // at the next call of Tick()
  display->com->flagClose = TRUE;

}

// Return the last key pressed since the last call to DisplayGetKeyPressed
// Input:
//   display: the Display receiving the key pressed event
// Output:
//   Return the key value, or 0 if there wasn't any key pressed
unsigned char DisplayGetKeyPressed(Display* display) {

  // Variable to memorise the returned value
  unsigned char ret = 0;

  // If there are keys waiting in the buffer
  if (display->com->idxLastRead != display->com->idxLastWrite) {

    // Move the index to the next key to read. Simply take advantage of the
    // overflow to loop back to the beginning of the buffer after 256 keys
    (display->com->idxLastRead)++;

    // Update the returned value with the key in the buffer
    ret = display->com->keyPressed[display->com->idxLastRead];

  }

  // Return the last key press value
  return ret;

}

// Set the RGB value of a pixel in the Display
// Inputs:
//   display: the Display to be updated
//   x: the horizontal position of the pixel (starts at 0, from left to right)
//   y: the vertical position of the pixel (starts at 0, from top to bottom)
//   r,g,b: the new RGB values of the pixel
void DisplaySetPixel(
  Display* display,
  int x,
  int y,
  int r,
  int g,
  int b) {

  // Get the index of the pixel
  int idx = y * display->rowstride + x * display->n_channels;

  // Update the RGB values of the pixel in the shared segment. The Tick()
  // function will update the displayed widget with the new values next time
  // it is called.
  display->sharedPixels[idx + 0] = r;
  display->sharedPixels[idx + 1] = g;
  display->sharedPixels[idx + 2] = b;

}

Compile with gcc -std=c18 -Wall -Wextra `pkg-config --cflags gtk+-3.0` -o main main.c display.c `pkg-config --libs gtk+-3.0`.

2021-10-17
in All, C programming, Computer graphics,
357 views