GUI structure in C

Although I understand OOP may be a better way to go with my GUI project, I decided to stick it out in understanding how to implement this in C. The basic building blocks are:

a) A rectangle
b) A button
c) A textbox

This is an edited (to keep the post shorter) version of my struct for the rectangle:

Code:

---

typedef struct{
    float convertToPixel, convertToOrtho;
   
    float x1, y1, x2, y2;  //bottom left, top right coordinates
    float centreXOrtho, centreYOrtho, length, height;
   
    //Label
    int labelLengthChars;
    float labelLengthOrtho, labelHeightOrtho;
       
    //Final data for drawing functions
    float vertices[4][2];
    float colour[3];
    char label[MAX_LABEL_LENGTH];
    float rasterStartPos[2];

}Rectangle;

//.... a series of functions to initialise struct, setters, getters etc

---

My question is about which route would other people go in creating say a textbox from here. Would it be better to:

a) Copy the Rectangle struct into another header file, relabel the typedef "textbox", copy and paste existing functions (renaming and editing the functions), and add additional functions as necessary

Code:

---

typedef struct {
//....pretty much same or identical contents to Rectangle
}Textbox;

void textboxNew(Textbox *r, float coords[4]);
void textboxGetText(Textbox *r, char *buffer);

---

b) Leave the struct as it is (perhaps adding additional contents to it though), but have a separate set of functions which initialise and use the struct, e.g.:

Code:

---

typedef struct {
//....
}Rectangle;

void buttonNew(Rectangle *r, float coords[4], char *label);  // initialise button

void textboxNew(Rectangle *r, float coords[4]); //initialise textbox
void textboxGetText(Rectangle *r, char * buffer);

---

Thanks for any thoughts on this

I'd go with

Code:

---

typedef struct {
    Rectangle base;
    // other members specific to TextBox
}Textbox;

---

Agreed. I would also really suggest this:

Code:

---

TextBox* newTextBox(float coords[4])

---

rather than your void version, in order to create something in one line.

Thanks for the clear direction on this Salem - your advice makes sense once I started to write the textbox code and makes the whole thing tidier and clearer. In the end I kept a single header file with the two structs (rectangle and textbox) in it and function declarations, but created a new source file for the textbox.

C_ntua - I remember trying this a while ago, but got stuck with the problem that creating instances within functions makes them local, and I ended up with a pointer which pointed into the abyss....

However, it's a much better way to go, so I gave your idea more thought and tried a small program, using the static declaration. I'll post my test program below - is this the right way to go?

Code:

---

#include <stdio.h>

typedef struct number {
    int x;
}Number;

Number * newNumber(int x);


int main (int argc, const char * argv[]) {
    Number *m = newNumber(5);
    printf("\nNumber = %d", m->x);
    return 0;
}

Number *newNumber(int z) {
    static Number n; //is this the right way to do this???
    n.x = z;
    return &n;
}

---

No, you'd only be able to create one number. As you're returning the address of the static variable (which won't be destroyed when the function returns).

Use malloc() / free(), ie

Code:

---

/* returns NULL on failure */
Number * newNumber(int z)
{
  Number * n = NULL;

  n = malloc(sizeof(Number));
  if(n != NULL)
      n->x = z;

  return n;
}

void freeNumber(Number ** num)
{
  if(num != NULL)
  {
      free(*num);
      *num = NULL;
  }
}

---

Brilliant. This is really helpful zacs7. So, the summary that I take from this is that... if malloc'd memory is created within a function it won't disappear when the function ends, and it's available outside of the function as long as I store the returned address.

Yeah, it's allocated on the "heap".

You can do it all on the stack too,

Code:

---

Number newNumber(int z)
{
  Number num;
  num.x = z;
  return num;
}

---

But I wouldn't recommend that.

Quote:

---

Originally Posted by zacs7

Yeah, it's allocated on the "heap".

You can do it all on the stack too,

Code:

---

Number newNumber(int z)
{
  Number num;
  num.x = z;
  return num;
}

---

But I wouldn't recommend that.

---

I would. As long as the struct is small (and this only contains one integer), returning a struct, rather than a pointer to struct is faster than allocating memory.

--
Mats

Quote:

---

Originally Posted by officedog

Brilliant. This is really helpful zacs7. So, the summary that I take from this is that... if malloc'd memory is created within a function it won't disappear when the function ends, and it's available outside of the function as long as I store the returned address.

---

Yeah. In C++ you would do rectangle* rec = new rectangle();
In C you would do rectangle* rec = new_rectangle();
So, it will be easy to use as in C++.

Also, you can try function pointers:

Code:

---

typedef Orthogonio {
    //blah blah
    void (*resize)(Point p1, Point p2);
} Rectangle;

rectangle *rec = new_rectangle(Point p1, Point p2)
{
    rectangle* rec = malloc(sizeof(*rec));
    //rest of initialization
    rec->resize = rectangleResize;
    return rec;
}

Rectangle* rec = new_rectangle(p1, p2);
rec->resize(p1, p2, rec);

---

So you can hide the rectangleResize function in the resize function. That way every object can have a resize function put each will do what you want. Unfortunately you can't avoid passing rec parameter (which would be the this paramater automatically passed in C++).

EDIT: You can also use the above idea and have a init (constructor) function for each object. Then you will be able to choose. For static allocation:

Code:

---

rectangle rec;
rec.init(Point p1, Point p2, &rec);

---

dynamic allocation:

Code:

---

rectangle* rec = new_rectangle(Point p1, Point p2, rec);

rectangle* rec new_rectangle(Point p1, Point p2, rectangle* rec) {
    //as before
    rec->init(Point p1, Point p2, rec);
}

---

Wow! Thanks C_ntua. This is exactly the sort of thing I'm looking for as I am trying to pull together issues of code reuse etc (possibly even inheritance??) without going the whole distance into an OOP language like C++. It'll take a while to sink in though as it feels a bit advanced. I'll read this a few times and let the idea sink in, then see if I can use the ideas. Might have to come back with some questions

> I would. As long as the struct is small (and this only contains one integer), returning a struct, rather than a pointer to struct is faster than allocating memory.

True, but I wouldn't recommend it in general. Perhaps I should be less ambiguous in my posts :p.

Quote:

---

Originally Posted by zacs7

> I would. As long as the struct is small (and this only contains one integer), returning a struct, rather than a pointer to struct is faster than allocating memory.

True, but I wouldn't recommend it in general. Perhaps I should be less ambiguous in my posts :p.

---

But that wouldn't be half as fun ;)

--
Mats

And it's always you who picks it up... Oh I'm onto you ;)

Quote:

---

Originally Posted by officedog

Wow! Thanks C_ntua. This is exactly the sort of thing I'm looking for as I am trying to pull together issues of code reuse etc (possibly even inheritance??) without going the whole distance into an OOP language like C++. It'll take a while to sink in though as it feels a bit advanced. I'll read this a few times and let the idea sink in, then see if I can use the ideas. Might have to come back with some questions

---

Your welcome, but in the end a class is just a struct with function pointers ;) If you kind of think how C++ was implemented, you will see that you can do almost everything with C. You will just have to write more code. But it will be a fun practice.

Like you can even gain some polymorphism. Think of virtual functions.

Code:

---

typedef struct {...} Control;
typedef struct {...} Button;  // : Control
typedef struct {...} DropList; // : Control

---

Now you have this:

Code:

---

typdef struct {
    base Control;
    //rest of control
    void (*resize)(Point P1, Point P2);
} Button;

---

the same for DropList. You want override base.resize which as noted before is a function pointer that points to rectangleResize. So what do you do? You make your buttonResize function and do this:

Code:

---

myButton->base.resize = buttonResize;
myButton->resize = myButton->base.resize;

---

And you have override the function resize. Now both base->resize and resize point to buttonResize.
Now, you can use a void pointer to point to any struct you desire. So you can do this:

Code:

---

Button* b = new_Button();
DropList* d = new_DropList();
List* list = new_list(); //a list that has void* pointers that can point to anything
list.Add(b, d); //sets the void pointers in the list
Control* c = Control_cast((list.At(1)); // c = b
c->resize();  //call the overriden function

---

The key to the above code is the Control_cast() instead of (Control *). Since there is no built in polymorphism, you want c, that is a Control* to actually point to a Control*. So:

Code:

---

Control* Control_Cast(void* ptr)
{
    switch(findType(void* ptr)
    {
    Control* c, Button* b, DropList* d;
    case CONTROL:
                                c = (Control*)ptr;
                                return c;
    case BUTTON:
                                b = (Button*)ptr;
                                c = &(b->base);
                                return c;
    ........
    default:          //not derived, faulty cast!
                  //something
                  exit(1);                         
    }
}

---

So you just need to know which class derives for what class. That can be done by having a table that saves the type of each struct created. That class will be returned as an enumeration from the findType() function. So each struct that is created will write the value of its address (thus a pointer) to a table with its type. So this two will do the same thing:

Code:

---

Button* b = new_Button();
Control* c = Control_cast(b);
c->resize();  //refers to b->base.resize()
b->resize(); //refers to b->resize which is equal to b->base.resize();

---

Of course, you need to inform the table that Button derives from Control (and make sure all the above actually work :P)

Of course this will be less effective than C++, because something are done automatically in compile time, though everything now will be done in run-time. So you will not have something faster because it is C.

EDIT: Well, the above code needs one more modification. You have to also pass the pointer to the struct inside resize. But that will need to be Button* not Control*. Or DropList*. This can be done, but it will need a bit more work and it will look a bit uglier. My main point stands the same though ;)

OK, just to share my first attempt at embedding function within a struct. I kept it simple so I get the general patterns, before moving back to my GUI. I thought I'd share it, partly for critical feedback, partly cause others might be interested in this. This seems to work reasonably well. Involves some mental gymnastics - the idea of a 'pointer to a function' ...... makes me wonder how a function is actually represented.

Code:

---

#include <stdio.h>
#include <stdlib.h>

typedef struct coords {
    int x,y;
    void (*add)(struct coords *c);  //why does this need to be in brackets??
} Coords;

void addOne(Coords *c);

Coords * coordNew();

int main (int argc, const char * argv[]) {
    Coords *num = coordNew();
    num->add(num);
}

Coords * coordNew() {
    Coords *c = malloc(sizeof(Coords));
    c->x = 1;
    c->y = 100;
    c->add = addOne; //assign function
    return c;
}

void addOne(Coords *c) {
    printf("\nStart: x,y = %d, %d", c->x,c->y);
    c->x ++;
    c->y ++;
    printf("\nEnd: x,y = %d, %d", c->x,c->y);
}

---

I've been crawling my way up this learning curve, going back and forth between the code and the advice. Here I try to implement "inheritance" and I feel a little stuck. Here's what I've got so far. My question is - is this the right direction or not to implementing "C classes"?

The base class:

Code:

---

typedef struct coords {
    int x,y;
    void (*init)(struct coords *c);
    void (*add)(struct coords *c);
} Coords;

// Dynamic allocation and initialisation of Coords 'instance'
Coords * coordNew() {
    Coords *c = malloc(sizeof(Coords));
    if (c != NULL) {
        c->x = 1;
        c->y = 100;
        c->add = addOne;
        c->init = initCoords;
    }
    return c;
}

void initCoords (Coords *c) {
    c->x = 55;
    c->y = 200;
    c->add = addOne;
    c->init = initCoords;  //is this self-reference ok??
    printf("\nInit Coords: x,y = %d, %d", c->x, c->y);
}

---

And this is where I got to with creating a "child class". At the moment it is not much more than a copy of Coords struct.

Code:

---

typedef struct square {
    Coords base;
    void (*init)(struct coords *c);
}Square;

//Dynamic allocation of Square
Square * squareNew() {
    Square *s = malloc(sizeof(Square));
    if (s != NULL) {
        s->init = initCoords;
        s->init(&(s->base));  //static memory allocation??
    }
    return s;
}

---

Am I on the right tracks here?

The things I am struggling with include:

a) Should I dynamically allocate and initialise the base struct by calling coordNew(), or as I have tried to do here, call the initCoords(Coords *c) function.
b) Should I rewrite a new 'initSquare()' function which calls the initCoords function?
c) Won't the Coords struct members which are function pointers (init and add) become redundant and unused?

Well, you can guess that I will say that you can just use C++. Is there a reason you want to do this in C?? If you want this not to be OOP then you shouldn't simulate classes/objects. But creating a GUI is one of the really popular things that show the OOP features.

If you are doing this to learn and for the fun of it, then continue the good job ;)

Let me explain a bit what is a function pointer. There is a block of memory for each function. So when you call a function you actually call the routines/commands of that specific block of memory. The address of that block of memory is the function name. As it is for a variable. So when you point at a function you point at a memory location. As when you point to a variable you point to a memory location. Nothing more.

a) The whole struct is still allocated on the heap. When you allocate space for a struct you allocate space for each individual member. That goes also for other structs. If you allocate the struct dynamically on the heap EVERYTHING will be in the heap.

b) Of course you will need to make an initSquare function which will initialize also the extra members of square. Well, in your case there is no extra members, but generally for each class there should be one initX function.

c) Yes they will. But that cannot be avoided. The same goes for C++. If you inherit from an class that also has useless members then they will stay useless. That doesn't really matter though.

The tricky part comes when you try to use polymorphism of any kind.

So you have this:

Code:

---

typedef struct coords {
    int x,y;
    void (*init)(struct coords *c);
    void (*add)(struct coords *c);
} Coords;

typedef struct square {
    Coords base;
    void (*init)(struct square* s);
}Square;

Square * squareNew() {
    Square *s = malloc(sizeof(Square));
    if (s != NULL) {
        s->init = initSquare;
        s->init(s);                          //initialize Square       
        s->base.init(&(s->base));  //initialize Coords
    }
    return s;
}

---

So, if that is what you where asking, coords.init() and coords.add() don't become useless! They can be used normally.
What you would want though, is to put inside the initSquare the initialization of the Coords so you call only one init and not to everytime you initialize.

Now, what you can do is use function pointers to make it simpler to call the base structs functions. Like, lets say add is a really good function that you will call a lot of times for every square. You don't want to call everytime this:

Code:

---

s->base.add(...)

---

but you would want to call this:

Code:

---

s->add(...)

---

That is possible if you add this code in the initialization/creation of square:

Code:

---

s->add = s->base.add;

---

provided that you make a function pointer called add inside the square structure.

A big thank you for the time you have taken to explain this C_ntua - it's incredibly helpful. I think with all the advice, coments and explanations in this thread I feel reasonably confident in making progress.

I do understand that the simplest way is actually to simply commit to learning C++ classes and ditch the idea of a GUI in favour of a GUI library (I'm working on a mac which does have lots of ready made stuff). However, this path is interesting, it helps me to learn more about the underlying mechanics of C and GUIs.

I've spent all day so far simply re-working and refining the base struct (rectangle), so I can try out these ideas. I'll post some of the code incase anyone else is interested. The base class is a rectangle, Here is the struct, complete with function pointers:

Code:

---

typedef struct rectangle {
    float convertToOrtho, convertToPixel;
    float x1,y1,x2,y2;
    float centreXOrtho, centreYOrtho;
   
    int screenBoundsMinX;
    int screenBoundsMaxX;
    int screenBoundsMinY;
    int screenBoundsMaxY;
   
    //Final drawing data
    float length, height;
    float vertices[4][2];
    float colour [4]; //rgba
   
    /*******************************************/
    //"public" methods
    void (*init)(struct rectangle *r, float coords[4]);
   
    void (*setCoords)(struct rectangle *r, float coords[4]);
    void (*setCentre)(struct rectangle *r, float coords[2]);
    void (*setLength)(struct rectangle *r, float length);
    void (*setHeight)(struct rectangle *r, float height);
    void (*setColour)(struct rectangle *r, float colour[4]);
    void (*draw)(struct rectangle *r);
   
    //"private" methods
    void (*rprint)(struct rectangle *r);
    void (*updateCentre)(struct rectangle *r);
    void (*updateScreenBounds)(struct rectangle *r);
    void (*updateDimensions)(struct rectangle *r);
    void (*updateVertices)(struct rectangle *r);
} Rectangle;

---

These are the function declarations:

Code:

---

//Constructor
Rectangle * rectNew(float coords[4]);
//still need to make destructor

//setters
void rectSetCoords(Rectangle *r, float coords[4]);
void rectSetCentre(Rectangle *r, float coords[2]);
void rectSetLength(Rectangle *r, float length);
void rectSetHeight(Rectangle *r, float height);
void rectSetColour(Rectangle *r, float colour[4]);

//Draw
void rectDraw(Rectangle *r);

//"Private" functions
void rectPrint(Rectangle *r);

//Updater functions
void rectUpdateCentre(Rectangle *r);
void rectUpdateScreenBounds(Rectangle *r);
void rectUpdateDimensions(Rectangle *r);
void rectUpdateVertices(Rectangle *r);

---

Don't forget to free() it officedog :)

See my original post...

No worries zacs7! Cheers for reminder though. After that my last post I zipped back to your post and hey presto

Code:

---

//Constructor
Rectangle * rectNew(float coords[4]);
void rectInit(Rectangle *r, float coords[4]);

//Destructor
void rectDestroy(Rectangle *r);

---

Code:

---

void rectDestroy(Rectangle *r) {
    if (&r != NULL) {
        free(r);
        r = NULL;
    }
}

---

Still not clear exactly why we're testing the address of the pointer itself though

Thanks again for that help yesterday too. It was a big help in getting this thing going in the right direction.

That's not exactly what I had...

&r != NULL is always true. Have a look again, I pass a pointer to a pointer so it can be set to NULL after it's free'd. Remember free(NULL) is safe and does nothing.

Thanks for picking up the error zacs7 and for explanation. I must have been getting ahead of myself, I thought it was an equivalent. I'll have a re-read and a think over this.

It's just that it makes it safe after you free a Rectangle that it isn't used.

ie,

Code:

---

Rectangle * r = newRectangle();

/* use r */

freeRectangle(&r);      /* notice we pass the address of r */

/* r is now NULL so we won't accidentally use it */

---

Just make sure you don't reference NULL, ie freeRectangle(NULL); should be safe.

PS: I love your name and dp :)

Seems good. I don't think you will have a problem learning C++ :). And from there Java/C# if you are interested, which should be better for a GUI.

P.S.
I would like to finish my idea about polymorphism in C. I don't know if you are familiar with the virtual function concept, but I ll post it anyway just for the sake of completion:

Code:

---

typedef struct control {
    //members
    //rest of control
    void (*resize)(void* ptr, Point P1, Point P2);
} Control;

typdef struct {
    base Control;
    //rest of control
    void (*resize)(void*ptr, Point P1, Point P2);        //this will overwrite Control's resize
} Button;

---

Now you declare the two resizes like this:

Code:

---

void controlResize(void* ptr, Point p1, Point p2)
{
    Control* c = (Control*)ptr
    //do whatever you do
}

void buttonResize(void* ptr, Point p1, Point p2)
{
    Button* b = (Button*)ptr;
    //do whatever you do
}

new_button(Button* b)
{
  //blah blah
  b->resize = b->base.resize = buttonResize;
  return b;
}

---

and in the main program you can do:

Code:

---

Button* b = new_Button();
Control* c = new_Control();
Control* c = Control_cast(c);
c->resize(c, p1, p2);
c = Control_cast(b);
c->resize(c, p1, p2);

---

Now, even if you call the same code, c->resize(c, p1, p2) the code will refer to different functions. The first time it will refer to control's resize. The second time to button's resize.

In C++ the above code would be:

Code:

---

Button* b = new Button();
Control* c = new Control();
Control* c = static_cast<Control*>(c);  //or some other cast
c->resize(p1, p2);
c = static_cast<Control*>(b);
c->resize(p1, p2);

---

the same line of codes.

officedog, if you like the idea of adding some OO features (such as in C_ntua's posts) into C check out glib - http://library.gnome.org/devel/glib/stable/
You'll probably find it has a lot of stuff you're wanting to implement.

But perhaps look into C++ if you want that much OO stuff :p.

Thanks for the comments zacs7. I had a look at Glib and I ended up reading about GObject. So, it's a sort of class type system which extends C via a library, but is not a new language like C++ or objC. Very interesting and very relevant - I'll have a look into this in more detail when I finish this project. Glad you like the dp (does this mean photo?) - it looks like we are both dog owners!

And thanks C_ntua for sharing more of your experience and knowledge on this. There is so much useful stuff in this thread, I'm going to try and make a summary of it for future reference. I'm returning back to some of your earlier posts today as I try to develop a new struct "Label", based on the Rectangle struct.

Am very pleased with the rectangle struct - the functions seem to work perfectly if I call them directly, e.g.
rectSetHeight(Rectangle *r, float height);

Or when calling them from the function pointer in the struct:
r->setHeight(Rectangle *r, float height);

Back to 'work' now

officedog is very pleased. After much painstaking work, the "label" struct is almost complete. The base struct (Rectangle) functions seem to work and there is an added layer now which is the text label itself. I share some of the code for others who may be interested:

This is the new struct "Label"

Code:

---

typedef struct label {
    Rectangle base;  //the foundations
   
    //Font
    void * font;  //to hold GLUT bitmap fonts
    int fontHeightInPixels;
    int fontWidthInPixels;
    float fontHeightInOrtho;
    float fontWidthInOrtho;
    float textColour[4]; //rgba
   
    //Label
    char label[MAX_SIZE_LABEL];
    int LabelLengthInChars;
    float labelLengthInOrtho;
    float labelHeightInOrtho;

    float indentFromLeftInOrtho; // = 1 character
    float indentFromRightInOrtho; // = 1 character
    char justify; // 'l', 'c', 'r' == left, centre, right
   
    float rasterStartPos[2];
   
    /*******************************************/
    // Function pointers - work in progress.....

    void (*init)(struct label *lbl, float coords[4], const char *str);
    //destructor
   
}Label;

---

This is the function which dynamically allocates the struct and calls the init function:

Code:

---

Label * labelNew(float coords[4], const char * str) {
    Label *lbl = malloc(sizeof(Label));
    if (lbl != NULL) {
        lbl->init = labelInit;
        lbl->init(lbl, coords, str);  // calling labelInit via the struct function pointer
    }
    return lbl;
}

---

And this is function which initialises the struct, also calling on the base (Rectangle) init function

Code:

---

void labelInit(Label *lbl, float coords[4], const char * str) {
    lbl->base.init = rectInit;
    lbl->base.init(&(lbl->base), coords);

    lbl->font = GLUT_BITMAP_8_BY_13; //Default font
    lbl->justify = 'c'; //Default: text is centred
    labelUpdateFontDimensions(lbl);
    labelSetLabel(lbl, str);
    labelSetTextColour(lbl, black); //default text col = black   
}

---

Finally here's a snippet of the code which draws the label (using openGL and GLUT):

Code:

---

void ODDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);

    float red[4] = {1,0,0,0};
    float coords[4] = {1,1,2,2};
    Label *lbl = labelNew(coords, "hello");
    labelPrint(lbl);
    lbl->base.setColour(&(lbl->base), red);  //calls base function via function pointer
    labelDraw(lbl);
   
    glFlush();
}

---

Nice. Will wait to see how this progresses

Thanks c-ntua. The help from you and zacs7 has opened a door on something I am only gradually coming to understand. I really appreciate the help I've had with this - these function pointers are fascinating! I'm still working through the GUI objects at the moment (am on a textbox at the moment, and a whichObjectIsTheMouseClickingOn struct).

I'm also trying to abstract out some general rules about the OOP-stye implementation and increase the modularity of my program structure. The reason is partly because the program quickly grows in size and starts to get harder to keep track of. The complexity is also added when I have more than one layer of "inheritance" e.g. a textbox struct which is based on a label struct which is based on a rectangle struct. The issues I'm seeking solutions to at the moment include:

a) Is it better to create wrappers for all of the base struct functions which will be used by the child struct (including the ones which are essentially "private" like the updating functions) or simply assign the child struct function pointer to the base struct function?

I'll try and explain this a little more. As I've been working through this I can see that there are some functions which are nothing more than a wrapper around the base struct function and could be simply assigned:

Code:

---

label->setCoords = label->base.setCoords;

---

Rather than

Code:

---

label->setCoords = labelSetCoords;

---

Where the function labelSetCoords is just a wrapper:

Code:

---

void labelSetCoords(struct label *lbl, coords[4]) {
    lbl->base.setCoords(&(lbl->base), coords);
}

---

Writing it the first way is less complicated when writing the code for the struct but more complicated for the 'user' of the struct because they have to remember to pass the address of the base struct for some functions i.e.

Code:

---

newLabel->setCoords(&(newLabel->base), coords)

---

Rather than a user interface which consistently only requires the 'child' struct pointer:

Code:

---

newLabel->setCoords(newLabel, coords)

---

Potentially this can get more complex with more layers of inheritance, conceivably even resulting in lines like:

Code:

---

newStructType->functionName(&(newLabel->base.base.base), coords)

---

Sorry, this was a more long-winded explanation than intended.... The upshot is, that I feel that I should write wrappers for absolutely all functions that will be used by the child struct (including even the updater functions which are never supposed to be accessed by the 'user'). I wonder if this would lead to bugs which bite later on (with potentially pointers to pointers to pointers to functions being involved), or whether this is the only sensible way to go?

I'll leave the other question until another time

> Is it better to create wrappers for all of the base struct functions which will be used by the child struct
Wrappers IMO. That way if anything internally changes then the user is really none-the-wiser.

Thanks zacs7. Definitely makes sense.

I also noticed you're using glut, which is mostly dead. You may want to look into gflw.

I use it, and it is VERY nice.

Thanks for the link. I'll see if I can get it to load up on my system and give it a spin....

It'll probably mean you'll have to program your own fonts though :-). No more using the glut ones!

If you still want bitmap fonts, perhaps use http://www.angelcode.com/products/bmfont/ . Of course this is all work in the opposite direction of what you're trying to get done really... :p

officedog is resourceful and already has a wonky home-made bitmap alphabet! So assuming glfw can withstand a few officedog characters and an officedog rectangle, all should be well. However we'll investigate angelfonts, just in case. Thanks for all these links, really helpful.

The direction is evolving as these posts go by. We've decided to go back to the drawing board, re-engineer the structs, wrap all functions and develop a programme which will bake the GUI. Shouldn't take more than a couple of days.

I am trying to build a screen manager now. It will detect which object the user clicked with the mouse and work out which function to call. I've returned to C_ntua's earlier post (page 1, no.14) on this. Just wondering whether I'm getting the ideas right.

Here's what I have so far:

Included in the struct for each GUI object is another struct called "objectScreenData". The purpose is to serve as a set of data for use by the screen manager - to check which object has been clicked on and know where to go to call the relevant function.

Here's the struct

Code:

---

typedef struct objectScreenData {
    ScreenBounds objectBounds;
    ScreenBounds resizeBounds;
    ScreenBounds textBounds;
    int type;
    int tag;
    char name[20];
    void * address; //stores address of struct - key issue. Intend to put a cast on it with
                // relevant struct when function is called.
}ObjectScreenData;

---

Each time an object is drawn or redrawn, it sends a pointer to this information to the ScreenManager struct. Here's the screen manager:

Code:

---

typedef struct screenManager {
    ObjectScreenData * objects[20];
    int nObjects;
    int selectedObject;
   
    //Function pointers
    void (*init)(struct screenManager *sm);
    void (*destroy)(struct screenManager **sm);
    int (*add)(struct screenManager *sm, ObjectScreenData *obj);
    void (*checkWhichObject)(struct screenManager *sm, int x, int y);
    int (*checkWhichFunction)(struct screenManager *sm, int x, int y);
    void (*callFunction)(struct screenManager *sm, int tag);
}ScreenManager;

---

This is the add function for the screen manager:

Code:

---

int  screenManagerAdd(ScreenManager *sm, ObjectScreenData *obj) {
    if (sm->nObjects < 19) {
        if ((obj->tag) < 0)
        {
            printf("\n\n+++ Adding %s to screen manager database", obj->name);
            sm->objects[sm->nObjects] = obj;
            sm->nObjects += 1;
            obj->tag = sm->nObjects;
            printf("\nObject added, tag = %d", obj->tag);
            return sm->nObjects;
        }
        else{
            printf("\nObject >>%s, ID = %d already registered", obj->name, obj->tag);
            return obj->tag;
        }
    }
    else{
        printf("\nObject: %s could not be added to the Screen Manager", obj->name);
        return -1;
    }
}

---

And this is the checkWhichObject function. Still work n progress - it's a bit of a building site at the moment, but just to give an idea of where it is (or isn't?) going.

Code:

---

void screenManagerCheckWhichObject(ScreenManager *sm, int x, int y) {
    for (int i = 0; i < sm->nObjects; i++) {
        //get the objects screen boundaries
        int minX = (sm->objects[i])->objectBounds.minX;
        int minY = (sm->objects[i])->objectBounds.minY;
       
        int maxX = (sm->objects[i])->objectBounds.maxX;
        int maxY = (sm->objects[i])->objectBounds.maxY;
       
        if ( x> minX && x < maxX && y > minY && y < maxY) {
            sm->selectedObject = i;
            printf("\nObject ID = %d, name = %s", i, (sm->objects[i])->name);
            sm->checkWhichFunction(sm, x, y);
        }
    }
}

---

Comments are very welcome. The general question is - am I on the right lines, are there any glaring errors in the way I'm doing this?