What’s the minimum amount of work you need to do to create your own EWL widget? Just want something you can build on but don’t know where to start?

Well, hopefully this should give you the base for starting your widget. Assuming you’re creating a widget called My_Widget, the EWL convention is to have a my_widget.c and my_widget.h files. There are only a couple things you need to implement to get a working widget.

First, my_widget.h.

#ifndef MY_WIDGET_H
#define MY_WIDGET_H

#include <ewl.h>

#define MY_WIDGET(w) ((My_Widget *)w)
#define MY_WIDGET_TYPE "my_widget"

typedef struct My_Widget My_Widget;
struct My_Widget
    Ewl_Widget widget;

Ewl_Widget *my_widget_new(void);
int my_widget_init(My_Widget *w);


That wasn’t so bad. What have we got? Well, the MY_WIDGET(w) define gives us a simple macro to cast other widgets to our widget. The second define, MY_WIDGET_TYPE, is a simple macro containing the type name of the widget. We’ll use that a bit later (and in any type checking we add to our widget.)

We then create the widget structure. In this case we’re inheriting from Ewl_Widget so it’s the first item in our struct (and not a pointer, that’s important). This is how EWLs inhertiance works. The widget you’re inheriting from is the first item in the struct and not a pointer. You will now be able to call any of the methods of the inherited class on the new class.

We then declare two methods. The convention in EWL is that the __new()_ function always takes no parameters (void). There is also always a __init()_ function that takes the widget as its only parameter and returns an int, if the initialization succeeded or failed.

With that out of the way, lets take a look at my_widget.c.

#include "my_widget.h"

Ewl_Widget *
    Ewl_Widget *w;

    w = calloc(1, sizeof(My_Widget)));
    if (!w) return NULL;

    if (!my_widget_init(MY_WIDGET(w)))
            return NULL;
    return w;

my_widget_init(My_Widget *w)
     if (!ewl_widget_init(EWL_WIDGET(w)))
            return 0;

    ewl_widget_appearance_set(EWL_WIDGET(w), MY_WIDGET_TYPE);
    ewl_widget_inherit(EWL_WIDGET(w), MY_WIDGET_TYPE);

    return 1;

That’s pretty simple. We create a new widget, initialize it and thats about it. In _my_widget_init()_ we make sure we call _ewl_widget_init()_ as that’s the widget we are inheriting from and we then set our inheritance and appearance strings (notice the use of our type define from earlier).

With that you’ve got a simple widget. It doesn’t do much, but it exists. Build on as you will.