ObjGUI  Check-in [60818c0951]

PREFIX ?= /usr/local

all:
	@objfw-compile -Wall -g --lib 0.0 -o objgui \
		`pkg-config --cflags --libs gtk+-3.0` \
		`ls *.m | fgrep -v test.m`

test:
	@objfw-compile -Wall -g -o test \
		`pkg-config --cflags --libs gtk+-3.0` \
		*.m

install:
	mkdir -p ${PREFIX}/include/ObjGUI
	cp *.h ${PREFIX}/include/ObjGUI/
	cp libobjgui.so ${PREFIX}/lib/libobjgui.so.0.0
	ln -sf libobjgui.so.0.0 ${PREFIX}/lib/libobjgui.so.0
	ln -sf libobjgui.so.0 ${PREFIX}/lib/libobjgui.so

clean:
	rm -f test *.so *.o *~

#include <gtk/gtk.h>

#import <ObjFW/ObjFW.h>

@protocol OGApplicationDelegate <OFObject>
- (void)applicationDidFinishLaunching;
@optional
- (void)applicationWillTerminate;
@end

@interface OGApplication: OFObject <OFApplicationDelegate>
{
	id <OFApplicationDelegate> delegate;
}

+ (void)quit;
@end

#define OG_APPLICATION_DELEGATE(cls)	\
	Class				\
	og_application_delegate() {	\
		return [cls class];	\
	}

#import "OGApplication.h"

OF_APPLICATION_DELEGATE(OGApplication)

extern Class og_application_delegate(void);

@implementation OGApplication
+ (void)quit
{
	gtk_main_quit();
}

- (void)applicationDidFinishLaunching
{
	OFAutoreleasePool *pool;
	int *argc;
	char ***argv;

	delegate = [[og_application_delegate() alloc] init];

	[[OFApplication sharedApplication] getArgumentCount: &argc
					  andArgumentValues: &argv];
	gtk_init(argc, argv);

	pool = [OFAutoreleasePool new];
	[delegate applicationDidFinishLaunching];
	[pool release];

	gtk_main();
}

- (void)applicationWillTerminate
{
	[delegate applicationWillTerminate];
}
@end

#import "OGWidget.h"

@interface OGBox: OGWidget
+ box;

- (void)appendChild: (OGWidget*)child
	     expand: (BOOL)expand
	       fill: (BOOL)fill
	    padding: (float)padding;
- (void)prependChild: (OGWidget*)child
	      expand: (BOOL)expand
		fill: (BOOL)fill
	     padding: (float)padding;
@end

#import "OGBox.h"

@implementation OGBox
+ box
{
	return [[[self alloc] init] autorelease];
}

- init
{
	self = [super init];

	@try {
		if (isa == [OGBox class])
			@throw [OFNotImplementedException
			    exceptionWithClass: isa
				      selector: _cmd];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)appendChild: (OGWidget*)child
	     expand: (BOOL)expand
	       fill: (BOOL)fill
	    padding: (float)padding
{
	gtk_box_pack_start(GTK_BOX(widget), child->widget, expand, fill,
	    padding);
}

- (void)prependChild: (OGWidget*)child
	      expand: (BOOL)expand
		fill: (BOOL)fill
	     padding: (float)padding
{
	gtk_box_pack_end(GTK_BOX(widget), child->widget, expand, fill, padding);
}
@end

#import "OGWidget.h"

@class OGButton;

@protocol OGButtonDelegate <OFObject>
@optional
- (void)buttonWasClicked: (OGButton*)button;
@end

@interface OGButton: OGWidget
{
	id <OGButtonDelegate> delegate;
}

@property (assign) id <OGButtonDelegate> delegate;
@property (copy) OFString *label;

+ button;
@end

#import "OGButton.h"

@interface OGButton ()
- (void)OG_clicked;
@end

static void
clicked(GtkWidget *widget, gpointer data)
{
	[(OGButton*)data OG_clicked];
}

@implementation OGButton
@synthesize delegate;

+ button
{
	return [[[self alloc] init] autorelease];
}

- init
{
	self = [super init];

	widget = gtk_button_new();
	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(clicked),
	    self);

	g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(og_destroy),
	    self);
	[self retain];

	return self;
}

- (OFString*)label
{
	return [OFString stringWithUTF8String:
	    gtk_button_get_label(GTK_BUTTON(widget))];
}

- (void)setLabel: (OFString*)label
{
	gtk_button_set_label(GTK_BUTTON(widget), [label UTF8String]);
}

- (void)OG_clicked
{
	OFAutoreleasePool *pool = [OFAutoreleasePool new];

	if ([delegate respondsToSelector: @selector(buttonWasClicked:)])
	      [delegate buttonWasClicked: self];

	[pool release];
}
@end

#import "OGBox.h"

@interface OGHBox: OGBox
@end

#import "OGHBox.h"

@implementation OGHBox
- init
{
	self = [super init];

	widget = gtk_hbox_new(FALSE, 0);

	g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(og_destroy),
	    self);
	[self retain];

	return self;
}
@end

#import "OGBox.h"

@interface OGVBox: OGBox
@end

#import "OGVBox.h"

@implementation OGVBox
- init
{
	self = [super init];

	widget = gtk_vbox_new(FALSE, 0);

	g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(og_destroy),
	    self);
	[self retain];

	return self;
}
@end

#include <gtk/gtk.h>

#import <ObjFW/ObjFW.h>

@interface OGWidget: OFObject
{
@public
	GtkWidget *widget;
}

- (void)show;
- (void)hide;
@end

extern void og_destroy(GtkWidget*, OGWidget*);

#include "OGWidget.h"

void og_destroy(GtkWidget *widget, OGWidget *object)
{
	[object release];
}

@implementation OGWidget
- init
{
	self = [super init];

	@try {
		if (isa == [OGWidget class])
			@throw [OFNotImplementedException
			    exceptionWithClass: isa
				      selector: @selector(init)];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)show
{
	gtk_widget_show_all(widget);
}

- (void)hide
{
	gtk_widget_hide(widget);
}
@end

#import "OGWidget.h"

@class OGWindow;

@protocol OGWindowDelegate <OFObject>
@optional
- (BOOL)windowWillClose: (OGWindow*)window;
@end

@interface OGWindow: OGWidget
{
	id <OGWindowDelegate> delegate;
}

@property (assign) id <OGWindowDelegate> delegate;
@property (copy) OFString *title;
@property (assign) of_point_t position;
@property (assign) of_dimension_t dimension;

+ window;
- (void)addChild: (OGWidget*)widget;
@end

#import "OGWindow.h"

@interface OGWindow ()
- (BOOL)OG_willClose;
@end

static gboolean
willClose(GtkWidget *widget, GdkEvent *event, gpointer data)
{
	return ([(OGWindow*)data OG_willClose] ? FALSE : TRUE);
}

@implementation OGWindow
@synthesize delegate;

+ window
{
	return [[[self alloc] init] autorelease];
}

- init
{
	self = [super init];

	widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(G_OBJECT(widget), "delete-event",
	    G_CALLBACK(willClose), self);

	g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(og_destroy),
	    self);
	[self retain];

	return self;
}

- (OFString*)title
{
	return [OFString stringWithUTF8String:
	    gtk_window_get_title(GTK_WINDOW(widget))];
}

- (void)setTitle: (OFString*)title
{
	gtk_window_set_title(GTK_WINDOW(widget), [title UTF8String]);
}

- (of_point_t)position
{
	gint x, y;

	gtk_window_get_position(GTK_WINDOW(widget), &x, &y);

	return of_point(x, y);
}

- (void)setPosition: (of_point_t)position
{
	gtk_window_move(GTK_WINDOW(widget), position.x, position.y);
}

- (of_dimension_t)dimension
{
	gint width, height;

	gtk_window_get_size(GTK_WINDOW(widget), &width, &height);

	return of_dimension(width, height);
}

- (void)setDimension: (of_dimension_t)dimension
{
	gtk_window_resize(GTK_WINDOW(widget),
	    dimension.width, dimension.height);
}

- (void)addChild: (OGWidget*)child
{
	gtk_container_add(GTK_CONTAINER(widget), child->widget);
}

- (BOOL)OG_willClose
{
	OFAutoreleasePool *pool = [OFAutoreleasePool new];

	if ([delegate respondsToSelector: @selector(windowWillClose:)])
		return [delegate windowWillClose: self];

	[pool release];

	return YES;
}
@end

#import "OGApplication.h"
#import "OGWindow.h"
#import "OGButton.h"
#import "OGHBox.h"
#import "OGVBox.h"

@interface Test: OFObject <OGApplicationDelegate, OGWindowDelegate,
    OGButtonDelegate>
@end

OG_APPLICATION_DELEGATE(Test)

@implementation Test
- (void)applicationDidFinishLaunching
{
	OGWindow *w = [OGWindow window];
	w.title = @"Hallo Welt!";
	w.position = of_point(100, 100);
	w.dimension = of_dimension(600, 400);
	w.delegate = self;

	OGVBox *vbox = [OGVBox box];
	[w addChild: vbox];

	OGButton *b = [OGButton button];
	b.label = @"Klick mich!";
	b.delegate = self;
	[vbox appendChild: b
		   expand: YES
		     fill: YES
		  padding: 0];

	OGHBox *hbox = [OGHBox box];
	[vbox appendChild: hbox
		   expand: NO
		     fill: NO
		  padding: 0];

	OGButton *b1 = [OGButton button];
	b1.label = @"Ich";
	[hbox appendChild: b1
		   expand: YES
		     fill: YES
		  padding: 0];

	OGButton *b2 = [OGButton button];
	b2.label = @"mach";
	[hbox appendChild: b2
		   expand: YES
		     fill: YES
		  padding: 0];

	OGButton *b3 = [OGButton button];
	b3.label = @"nix";
	[hbox appendChild: b3
		   expand: YES
		     fill: YES
		  padding: 0];

	[w show];
}

- (BOOL)windowWillClose: (OGWindow*)window
{
	[OGApplication quit];

	return YES;
}

- (void)buttonWasClicked: (OGButton*)button
{
	of_log(@"Hallo!");
}
@end