Initial revision

contrib/gtk-tool/COPYRIGHT

+Copyright 1998 Predrag Balorda, London, UK
+All rights reserved.
+
+Redistribution and use in source and binary forms are permitted only
+as authorized by the OpenLDAP Public License.  A copy of this
+license is available at http://www.OpenLDAP.org/license.html or
+in file LICENSE in the top-level directory of the distribution.
+

contrib/gtk-tool/Gtk_LdapItem.cc

+#include "Gtk_LdapItem.h"
+
+Gtk_LdapItem::Gtk_LdapItem() : Gtk_TreeItem() {
+	cout << "Gtk_LdapItem()" << endl;
+}
+
+Gtk_LdapItem::Gtk_LdapItem(char *c) : Gtk_TreeItem() {
+	cout << "Gtk_LdapItem(" << c << ")" << endl;
+	this->dn = c;
+}
+
+Gtk_LdapItem::Gtk_LdapItem(Gtk_TreeItem *item) : Gtk_TreeItem(*item) {
+	cout << "Gtk_LdapItem(*item)" << endl;	
+}
+
+Gtk_LdapItem::Gtk_LdapItem(Gtk_TreeItem &item) : Gtk_TreeItem(item) {
+	cout << "Gtk_LdapItem(&item)" << endl;	
+}
+
+void Gtk_LdapItem::expand_impl() {
+	cout << this->dn << " expanded" << endl;
+}
+
+void Gtk_LdapItem::collapse_impl() {
+	cout << this->dn << " collapsed" << endl;
+}
+
+void Gtk_LdapItem::select_impl() {
+	cout << this->dn << " selected" << endl;
+}
+
+void Gtk_LdapItem::deselect_impl() {
+	cout << this->dn << " deselected" << endl;
+}
+
+void Gtk_LdapItem::toggle_impl() {
+	cout << this->dn << " toggled" << endl;
+}

contrib/gtk-tool/Gtk_LdapItem.h

+#ifndef GTK_LDAPITEM_H
+#define GTK_LDAPITEM_H
+#include "cpluscommon.h"
+#include "gtk.h"
+#include <Gtk_LdapTreeItem.h>
+class Gtk_LdapTreeItem;
+
+class Gtk_LdapItem {
+public:
+	Gtk_Tree *tree;
+	Gtk_LdapTreeItem *treeitem;
+};
+#endif

contrib/gtk-tool/Gtk_LdapTreeItem.cc

+#include "Gtk_LdapTreeItem.h"
+
+Gtk_LdapTreeItem::Gtk_LdapTreeItem() : Gtk_TreeItem() {
+}
+Gtk_LdapTreeItem::Gtk_LdapTreeItem(char *c, My_Window *w) : Gtk_TreeItem(c) {
+	this->rdn = c;
+	this->par = w;
+}
+Gtk_LdapTreeItem::Gtk_LdapTreeItem(GtkTreeItem *t) : Gtk_TreeItem(t) {
+}
+int Gtk_LdapTreeItem::search() {
+	int error, entriesCount;
+	BerElement *ber;
+	LDAPMessage *entry;
+	char *attribute, **values;
+	Gtk_CList *table;
+	Gtk_Label *label;
+	GList *child_list;
+	Gtk_Notebook *g;
+	if (this->notebook != NULL) {
+		if (par->scroller2->children != NULL) {
+			par->scroller2->remove_child(0);
+		}
+		par->scroller2->add_child(this->notebook);	
+	//	par->scroller2->remove((Gtk_Object)par->scroller2->children()->first());
+		this->notebook->reparent(par->scroller2);
+		this->notebook->show();
+		par->scroller2->show();
+		return 0;
+	}
+	error = ldap_search_s(this->ld, this->dn, LDAP_SCOPE_BASE, "objectclass=*", NULL, 0, &result_identifier);
+	entriesCount = ldap_count_entries(ld, result_identifier);
+	if (entriesCount == 0) return 0;
+	notebook = new Gtk_Notebook();
+	notebook->set_tab_pos(GTK_POS_LEFT);
+	gchar *titles[] = { "values" };
+	
+	for (entry = ldap_first_entry(ld, result_identifier); entry != NULL; entry = ldap_next_entry(ld, result_identifier)) {
+		for (attribute = ldap_first_attribute(ld, entry, &ber); attribute != NULL; attribute = ldap_next_attribute(ld, entry, ber)) {
+			table = new Gtk_CList(1, titles);
+			values = ldap_get_values(ld, entry, attribute);
+			for (int i=0; i<ldap_count_values(values); i++) {
+				gchar *t[] = { values[i] };
+				table->append(t);
+			}
+			ldap_value_free(values);
+			label = new Gtk_Label(attribute);
+			notebook->append_page(table, label);
+			table->show();
+			label->show();
+		}
+	}
+	if (par->scroller2 != NULL) {
+		cout << "Scroller2 exists" << endl;
+		if (par->scroller2->children[0] != NULL) {
+			cout << "There are children in scroller2" << endl;
+			par->scroller2->remove_child(0);
+		}
+		par->scroller2->add_child(this->notebook);
+		this->notebook->show();
+		par->scroller2->show();
+	}
+	return 0;
+}
+void Gtk_LdapTreeItem::select_impl() {
+//	cout << this->dn << " selected" << endl;
+//	gtk_item_select(GTK_ITEM(GTK_TREE_ITEM(this->gtkobj())));
+	Gtk_c_signals_Item *sig=(Gtk_c_signals_Item *)internal_getsignalbase();
+	if (!sig->select) return;
+	sig->select(GTK_ITEM(gtkobj()));
+	this->search();
+}
+void Gtk_LdapTreeItem::collapse_impl() {
+	cout << this->dn << " collapsed" << endl;
+	Gtk_c_signals_TreeItem *sig=(Gtk_c_signals_TreeItem *)internal_getsignalbase();
+	if (!sig->collapse) return;
+	sig->collapse(GTK_TREE_ITEM(gtkobj()));
+//	gtk_widget_hide(GTK_WIDGET(GTK_TREE(GTK_TREE_ITEM (this->gtkobj())->subtree)));
+}
+void Gtk_LdapTreeItem::expand_impl() {
+	Gtk_c_signals_TreeItem *sig=(Gtk_c_signals_TreeItem *)internal_getsignalbase();
+	if (!sig->expand) return;
+	sig->expand(GTK_TREE_ITEM(gtkobj()));
+//	Gtk_Tree *t;
+//	t = new Gtk_Tree(GTK_TREE(GTK_TREE_ITEM(this->gtkobj())->subtree));
+//	bool vis = t->visible();
+//	if (vis == false) {
+//		gtk_widget_show(GTK_WIDGET(GTK_TREE(GTK_TREE_ITEM (this->gtkobj())->subtree)));
+//		cout << this->dn << " expanded" << endl;
+//	}
+//	else {
+//		gtk_widget_hide(GTK_WIDGET(GTK_TREE(GTK_TREE_ITEM (this->gtkobj())->subtree)));
+//		cout << this->dn << " collapsed" << endl;
+//	}
+}

contrib/gtk-tool/Gtk_LdapTreeItem.h

+#ifndef GTK_LDAPTREEITEM_H
+#define GTK_LDAPTREEITEM_H
+#include "gtk.h"
+#include <My_Window.h>
+#include <lber.h>
+#include <ldap.h>
+
+class My_Window;
+
+class Gtk_LdapTreeItem : public Gtk_TreeItem {
+public:
+	char *dn;
+	char *rdn;
+	LDAP *ld;
+	LDAPMessage *result_identifier;
+	My_Window *par;
+	Gtk_Notebook *notebook;
+	Gtk_LdapTreeItem();
+	Gtk_LdapTreeItem(char *c, My_Window *w);
+	Gtk_LdapTreeItem(GtkTreeItem *t);
+	int search();
+	void select_impl();
+	void collapse_impl();
+	void expand_impl();
+};
+#endif

contrib/gtk-tool/LICENSE

+The OpenLDAP Public License
+
+Version 1.2, 1 September 1998
+Copyright 1998, The OpenLDAP Foundation.
+All Rights Reserved.
+
+Note:
+	This license is derived from the "Artistic License" as distributed
+	with the Perl Programming Language.  As differences may exist, the
+	complete license should be read.
+
+PREAMBLE
+
+The intent of this document is to state the conditions under which a
+Package may be copied, such that the Copyright Holder maintains some
+semblance of artistic control over the development of the package,
+while giving the users of the package the right to use and distribute
+the Package in a more-or-less customary fashion, plus the right to make
+reasonable modifications.
+
+Definitions:
+
+	"Package" refers to the collection of files distributed by the
+	Copyright Holder, and derivatives of that collection of files
+	created through textual modification.
+
+	"Standard Version" refers to such a Package if it has not been
+	modified, or has been modified in accordance with the wishes
+	of the Copyright Holder.
+
+	"Copyright Holder" is whoever is named in the copyright or
+	copyrights for the package.
+
+	"You" is you, if you're thinking about copying or distributing
+	this Package.
+
+	"Reasonable copying fee" is whatever you can justify on the
+	basis of media cost, duplication charges, time of people involved,
+	and so on.  (You will not be required to justify it to the
+	Copyright Holder, but only to the computing community at large
+	as a market that must bear the fee.)
+
+	"Freely Available" means that no fee is charged for the item
+	itself, though there may be fees involved in handling the item.
+	It also means that recipients of the item may redistribute it
+	under the same conditions they received it.
+
+1. You may make and give away verbatim copies of the source form of the
+Standard Version of this Package without restriction, provided that you
+duplicate all of the original copyright notices and associated disclaimers.
+
+2. You may apply bug fixes, portability fixes and other modifications
+derived from the Public Domain or from the Copyright Holder.  A Package
+modified in such a way shall still be considered the Standard Version.
+
+3. You may otherwise modify your copy of this Package in any way, provided
+that you insert a prominent notice in each changed file stating how and
+when you changed that file, and provided that you do at least ONE of the
+following:
+
+    a) place your modifications in the Public Domain or otherwise make them
+    Freely Available, such as by posting said modifications to Usenet or
+    an equivalent medium, or placing the modifications on a major archive
+    site such as uunet.uu.net, or by allowing the Copyright Holder to include
+    your modifications in the Standard Version of the Package.
+
+    b) use the modified Package only within your corporation or organization.
+
+    c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided, and provide
+    a separate manual page for each non-standard executable that clearly
+    documents how it differs from the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+4. You may distribute the programs of this Package in object code or
+executable form, provided that you do at least ONE of the following:
+
+    a) distribute a Standard Version of the executables and library files,
+    together with instructions (in the manual page or equivalent) on where
+    to get the Standard Version.
+
+    b) accompany the distribution with the machine-readable source of
+    the Package with your modifications.
+
+    c) accompany any non-standard executables with their corresponding
+    Standard Version executables, giving the non-standard executables
+    non-standard names, and clearly documenting the differences in manual
+    pages (or equivalent), together with instructions on where to get
+    the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+5. You may charge a reasonable copying fee for any distribution of this
+Package.  You may charge any fee you choose for support of this Package.
+You may not charge a fee for this Package itself.  However,
+you may distribute this Package in aggregate with other (possibly
+commercial) programs as part of a larger (possibly commercial) software
+distribution provided that you do not advertise this Package as a
+product of your own.
+
+6. The scripts and library files supplied as input to or produced as
+output from the programs of this Package do not automatically fall
+under the copyright of this Package, but belong to whomever generated
+them, and may be sold commercially, and may be aggregated with this
+Package.
+
+7. C subroutines supplied by you and linked into this Package in order
+to emulate subroutines and variables of the language defined by this
+Package shall not be considered part of this Package, but are the
+equivalent of input as in Paragraph 6, provided these subroutines do
+not change the language in any way that would cause it to fail the
+regression tests for the language.
+
+8. The name of the Copyright Holder may not be used to endorse or promote
+products derived from this software without specific prior written permission.
+
+9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+The End

contrib/gtk-tool/LdapEntry.cc

+#include "LdapEntry.h"
+
+LdapEntry* LdapEntry::get_entries(LDAP *ld, char *base_dn, int level,char *filter) {
+	printf("get_entries(%s)\n", base_dn);
+	LDAPMessage **result, *entry;
+	Entry *thing;
+	char *pele;
+	int res;
+	res = ldap_search(ld, base_dn, level, filter, NULL, 0);
+	res = ldap_result(ld, res, 1, NULL, result);
+	printf("%s\n", ldap_err2string(ldap_result2error(ld, *result, 1)));
+	int num_entries = ldap_count_entries(ld, *result);
+	printf("%i results\n", num_entries);
+	int i=0;
+	entry = ldap_first_entry(ld, *result);
+	thing->dn = ldap_get_dn(ld, entry);
+	pele = ldap_get_dn(ld, entry);
+	printf("%s\n", thing->dn);
+	while (entry) {
+		printf("Child %i\n", i);
+		thing->child[i] = get_entries(ld, pele, LDAP_SCOPE_ONELEVEL, filter);
+		i++;
+		entry = ldap_next_entry(ld, entry);
+	}
+	return thing;
+}
+
+Gtk_Tree *LdapEntry::make_tree(Entry *thing) {
+	Gtk_Tree *tree, **subtree;
+	Gtk_TreeItem *treeitem;
+	gchar *c;
+	tree = new Gtk_Tree();
+	tree->set_selection_mode(GTK_SELECTION_BROWSE);
+	tree->set_view_mode(GTK_TREE_VIEW_ITEM);
+	tree->set_view_lines(false);
+	c = g_strdup_printf("%s", thing->dn);
+	printf("%s\n", c);
+	treeitem = new Gtk_TreeItem(c);
+	tree->append(treeitem);
+	treeitem->show();
+	int i=0;
+	while (thing->child[i]) {
+		subtree[i] = make_tree(thing->child[i]);
+		treeitem->set_subtree(subtree[i]);
+		i++;
+	}
+	tree->show();
+	return tree;
+}

contrib/gtk-tool/LdapEntry.h

+#ifdef MY_LDAP_ENTRY_H
+#define MY_LDAP_ENTRY_H
+#include "common.h"
+#include "gtk.h"
+#include <lber.h>
+#include <ldap.h>
+
+class LdapEntry {
+public:
+	char *dn;
+	LdapEntry **children;
+	LdapEntry* get_entries(LDAP *ld, char *base_dn, int level, char *filter);
+	Gtk_Tree* make_tree(LdapEntry *thing);
+}
+#endif

contrib/gtk-tool/Makefile

+HOME_LOCATION=$(shell pwd)
+CC=	gcc
+CPLUS=	g++
+OPTS=-g -DmyDEBUG
+INCLUDES=`gtkmm-config --cflags` -I/usr/include -I/usr/local/gnome/include -I.
+LDFLAGS=`gtkmm-config --libs` -L/usr/lib -L/usr/X11/lib -L/usr/local/gnome/lib -L/usr/local/ldap/lib -lldap -llber
+LIBS=-lXext -lgtkmm -lX11 -lXt -lXxf86dga
+
+.EXPORT_ALL_VARIABLES:
+
+SOURCES=	My_Window.cc My_Scroller.cc Gtk_LdapTreeItem.cc main.cc
+OBJECTS=	My_Window.o My_Scroller.o Gtk_LdapTreeItem.o main.o
+
+################################################################################
+
+all:	$(OBJECTS) $(SOURCES)
+	$(CPLUS) $(OBJECTS) -o main $(LDFLAGS)
+	exec
+
+exec:	all
+	chmod a+x main
+	ls -al main
+
+%.o: %.c
+	$(CC) -c $(OPTS) $(INCLUDES) $<
+
+%.o: %.cc
+	$(CPLUS) -c $(OPTS) $(INCLUDES) $<
+
+clean:	
+	rm -f main a.out *.o straced core

contrib/gtk-tool/My_Scroller.cc

+#include "My_Scroller.h"
+
+#include <gtk--/container.h>
+
+void My_Scroller::remove_child(int i) {
+	cout << "Unparenting child[" << i << "]" << endl;
+	this->children[i]->unparent();
+	cout << "Deleting child[" << i << "] from children" << endl;
+//	this->remove(children()->first());
+	delete this->children[i];
+	cout << "done" << endl;
+}
+void My_Scroller::add_child(Gtk_Widget *w) {
+	cout << "My_Scroller::add_child()" << endl;
+//	w->reparent(this);
+	this->add(w);
+	cout << "done" << endl;
+	this->children[0] = w;
+}

contrib/gtk-tool/My_Scroller.h

+#ifndef MY_SCROLLER_H
+#define MY_SCROLLER_H
+#include <gtk--/container.h>
+#include "gtk.h"
+
+class My_Scroller : public Gtk_ScrolledWindow {
+public:
+	Gtk_Widget *children[2];
+	void add_child(Gtk_Widget *w);
+	void remove_child(int i);
+};
+#endif

contrib/gtk-tool/My_Window.cc

+#include <My_Window.h>
+
+My_Window::My_Window(GtkWindowType t) : Gtk_Window(t) {
+	cout << "My_Window(t)" << endl;
+	Gtk_VBox *main_hbox;
+	Gtk_HBox *top_hbox;
+
+	pane = new Gtk_HPaned();
+	this->scroller = new Gtk_ScrolledWindow();
+	this->scroller->set_policy(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+//	this->scroller->set_usize(this->height(), 400);
+	pane->add1(this->scroller);
+	this->scroller->show();
+
+	this->scroller2 = new My_Scroller();
+	this->scroller2->set_policy(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+	pane->add2(this->scroller2);	
+	this->scroller2->show();
+
+	top_hbox = new Gtk_HBox();
+	this->urlfield = new Gtk_Entry();
+	top_hbox->pack_start(this->urlfield, TRUE, TRUE, 1);
+	this->urlfield->show();
+	this->display_button = new Gtk_Button("Display");
+	connect_to_method(this->display_button->clicked, this, &do_display);
+	top_hbox->pack_end(this->display_button, FALSE, FALSE, 1);
+	this->display_button->show();
+
+	main_hbox = new Gtk_VBox();
+	main_hbox->pack_start(top_hbox, FALSE, TRUE, 1);
+	main_hbox->pack_end(pane, TRUE, TRUE, 1);
+	top_hbox->show();
+	pane->show();
+	this->add(main_hbox);
+	main_hbox->show();
+}
+void My_Window::do_display() {
+	cout << this->urlfield->get_text() << endl;
+}
+void My_Window::expand(Gtk_TreeItem *t) {
+	gchar *name;
+	GtkLabel *label;
+	label = GTK_LABEL (GTK_BIN (t->gtkobj())->child);
+	gtk_label_get (label, &name);
+	g_print("%s selected\n", name);
+}
+
+gint My_Window::delete_event_impl(GdkEventAny *) {
+	Gtk_Main::instance()->quit();
+	return 0;
+}
+
+Gtk_LdapItem* My_Window::make_tree(My_Window *p, LDAP* l_i, char* b_d) {
+//	printf("make_tree(%s)\n", b_d);
+	Gtk_LdapItem *treeresult, *subtreeresult;
+	Gtk_Tree *tree, *subtree, *subsubtree;
+	Gtk_LdapTreeItem *treeitem, *subtreeitem;
+	LDAPMessage *r_i, *entry;
+	gchar *c;
+	char **s;
+	char *c_num;
+	int entriesCount = 0;
+	int error;
+	int r_e_i;
+
+	error = ldap_search_s(l_i, b_d, LDAP_SCOPE_ONELEVEL, "objectclass=*", NULL, 0, &r_i);
+//	printf("%s\n", ldap_err2string(error));
+	entriesCount = ldap_count_entries(l_i, r_i);
+//	printf("%i results\n", entriesCount);
+	s = ldap_explode_dn(b_d, 1);
+	c = g_strdup_printf("%s", s[0]);
+	treeitem = new Gtk_LdapTreeItem(c, p);
+	treeitem->dn = b_d; treeitem->ld = l_i;
+	treeresult = new Gtk_LdapItem();
+	if (entriesCount == 0) { 
+		treeresult->treeitem = new Gtk_LdapTreeItem(*treeitem);
+		treeresult->tree = NULL;
+		return treeresult;
+	}
+	subtree = new Gtk_Tree();
+	subtree->set_selection_mode(GTK_SELECTION_BROWSE);
+	subtree->set_view_mode(GTK_TREE_VIEW_ITEM);
+	subtree->set_view_lines(false);
+	entry = ldap_first_entry(l_i, r_i);
+	while (entry != NULL) {
+		s = ldap_explode_dn(ldap_get_dn(l_i, entry), 1);
+		subtreeresult = make_tree(p, l_i, ldap_get_dn(l_i, entry));
+		subtreeitem = new Gtk_LdapTreeItem(*subtreeresult->treeitem);
+		subtree->append(subtreeitem);
+		printf("inserting %s into %s", s[0], c);
+		if (subtreeresult->tree != NULL) {
+			printf(".");
+			subsubtree = new Gtk_Tree(*subtreeresult->tree);
+			printf(".");
+			subtreeitem->set_subtree(subsubtree);
+			printf(".");
+		}
+		subtreeitem->show();
+		printf("\n");
+		entry = ldap_next_entry(l_i, entry);
+	}
+	treeresult->treeitem = new Gtk_LdapTreeItem(*treeitem);
+	treeresult->tree = new Gtk_Tree(*subtree);
+	return treeresult;
+}

contrib/gtk-tool/My_Window.h

+#ifndef MY_WINDOW_H
+#define MY_WINDOW_H
+#include "cpluscommon.h"
+#include "gtk.h"
+#include <lber.h>
+#include <ldap.h>
+#include "My_Scroller.h"
+#include "Gtk_LdapItem.h"
+#include "Gtk_LdapTreeItem.h"
+class Gtk_LdapTreeItem;
+class Gtk_LdapItem;
+class My_Scroller;
+
+class My_Window : public Gtk_Window {
+public:
+	Gtk_ScrolledWindow *scroller;
+	My_Scroller *scroller2;
+	Gtk_Entry *urlfield;
+	Gtk_Button *display_button;
+	Gtk_Paned *pane;
+	My_Window(GtkWindowType t);
+	void do_display();
+	void expand(Gtk_TreeItem *t);
+	gint delete_event_impl(GdkEventAny *);
+	Gtk_LdapItem* make_tree(My_Window *p, LDAP* l_i, char* b_d);
+};
+#endif

contrib/gtk-tool/README

+This is the first version of this README
+gtk-tool v0.5delta
+
+This package has been tested and run with the latest Gtk+/Gtk--
+OpenLDAP 1.1-devel. This thing doesn't run as it should, please
+read TODO!
+
+I really couldn't think of anything else to put here (at the moment
+that is). But please feel free to add whatever else you consider
+neccessary to understanding how this thing works. Enjoy, and I hope
+this can be useful to you in some miniscule way.
+
+Pele

contrib/gtk-tool/TODO

+LOADS!!!
+
+Someone please figure out how to _remove_ a widget from a container
+in Gtk+/Gtk--. As far as I know, and from my discussion with a
+certain person, it can't due to a design flaw of Gtk+ people. We
+need that first to be able to continue. The bug is reproducable
+when you start the thing, it automatically goes to the top node,
+i.e. University of Michigan, if you expand the tree a bit, then
+click on any one of the items available, it'll blow. That's because
+it needs to remove the contents in the right side of the browser
+window to be able to insert new things about the current node. And
+I didn't want to be an idiot and do it by some other means, because,
+as they've taught me in school, OO programming is meant to be used
+in a black-box fashion. If all else fails, then we'll start thinking
+about stupid solutions and their consenquences. No pun intended.
+
+All emails to -devel list, and plase make sure you put "GTK-TOOL"
+in the subject line, so other people who are not interested don't
+have to read our garbage.
+
+Pele
+pele@openldap.org

contrib/gtk-tool/common.h

+#ifndef MY_COMMON
+#define MY_COMMON
+
+#include "system.h"
+#include "cpluscommon.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <error.h>
+#include <string.h>
+extern int errno;
+#endif

contrib/gtk-tool/cpluscommon.h

+#ifndef MY_CPLUS_COMMON
+#define MY_CPLUS_COMMON
+
+#include <iostream.h>
+#include <iomanip.h>
+#include <fstream.h>
+#include <strstream.h>
+#include <unistd.h>
+#endif

contrib/gtk-tool/gtk.h

+#ifndef MY_GTK_INCLUDES
+#define MY_GTK_INCLUDES
+
+#include <gtk--.h>
+#include <gtk/gtk.h>
+#include <gtk--/widget.h>
+#include <gtk--/button.h>
+#include <gtk--/window.h>
+#include <gtk--/list.h>
+#include <gtk--/main.h>
+#include <gtk--sig.h>
+#include <gtk--/container.h>
+
+#endif

contrib/gtk-tool/ldap_manager.cc

+#include "ldap_entry.h"
+
+class ldap_manager {
+	ldap_entry *entries;
+	int result_identifier;
+	char *search_filter, *base_dn;
+	char *ldap_action, *host;
+	int link_identifier;
+	int entriesCount;
+
+	int connect(char *host) {
+		this->link_identifier = ldap_connect(host);
+		if (this->link_identifier) return 1;
+		return 0;
+	}
+
+	void disconnect() {
+	//	ldap_close($this->link_identifier);
+	}
+
+	int ldapTakeAction(char *a) {
+		char *func_ptr = "ldap_".$a;
+		if (this->result_identifier = func_ptr(this->link_identifier, this->base_dn, this->search_filter)) {
+			this->entriesCount = ldap_count_entries(this->link_identifier, this->result_identifier);
+			return 1;
+		}
+		return 0;
+	}
+	
+	int getEntries() {
+		int i=0;
+		entry = new ldap_entry(this->link_identifier);
+		entry->r_e_i = ldap_first_entry(this->link_identifier, this->result_identifier);
+		while(entry->r_e_i) {
+			entry->dn = ldap_get_dn(this->link_identifier, entry->r_e_i);
+			entry->getAttributes();
+			this->entries[i] = $entry;
+			i++;
+			r = entry->r_e_i;
+			entry = new ldap_entry(this->link_identifier);
+			entry->r_e_i = ldap_next_entry(this->link_identifier, r);
+		}
+//		ldap_free_result(this->result_identifier);
+	}
+
+	void displayEntries() {
+		printf(this->formatHTMLEntries());
+	}
+
+	void loadAttributeNames() {
+		global $attribute_names;
+		fp = fopen("at.conf2", "r");
+		int i = 0;
+		while (!feof(fp)) {
+			string = "";
+			foo = "";
+			string = fgets(fp, 80);
+			foo = strtok(string, " ");
+			attribute_names[i][0] = foo;
+			foo = strtok("\n");
+			attribute_names[i][1] = foo;
+			i++;
+		}
+		return $attribute_names;
+	}
+	char* formatHTMLBaseDN(char *dn) {
+		global $FILE, $host;
+		char *string = "";
+		attribs = ldap_explode_dn(dn, 0);
+		names = ldap_explode_dn(dn, 1);
+		for (int i=0; i<attribs["count"]; i++) {
+			s = attribs[i];
+			for (j=i+1; j<attribs["count"]; j++) {
+				s = sprintf(",", attribs[j]);
+			}
+			if ((s[0] == "c") && (s[1] == "n")) {
+				string = sprintf("<a href=".$FILE."?ldap_action=read&base_dn=".urlencode($s).">".$names[$i]."</a>, ";
+			}
+			else {
+				$string .= "<a href=".$FILE."?ldap_action=list&base_dn=".urlencode($s).">".$names[$i]."</a>, ";
+			}
+		}
+		return $string;
+	}
+
+	cfunction formatHTMLEntries() {
+		$string = "";
+		$string .= '<table width="100%" border=1 cellpadding=0 cellspacing=0>';
+		$string .= "\n";
+		for ($i=0; $i<count($this->entries); $i++) {
+			$e = $this->entries[$i];
+			$string .= $e->formatHTMLAttributes();
+		}	
+		$string .= "</table>\n";
+		return $string;
+	}
+
+	cfunction calculateTime($string, $s_t, $e_t) {
+		$tok1 = strtok($s_t, " ");
+		$msecs1 = $tok1;
+		$tok1 = strtok(" ");
+		$secs1 = $tok1;
+	 
+		$tok2 = strtok($e_t, " ");
+		$msecs2 = $tok2;
+		$tok2 = strtok(" ");
+		$secs2 = $tok2;
+		$t_t = (float) ($secs2 + $msecs2) - (float) ($secs1 + $msecs1);
+		echo "execution time for <b>".$string."</b> : <b>".$t_t."</b> seconds<br>\n";
+	//	echo "start: ".$secs1."<br>\n";
+	//	echo "end: ".$secs2."<br>\n";
+		return (float) $t_t;
+	}
+	
+	cfunction stripString($string, $tokens) {
+		$s = $string;
+		for ($i=0; $i<count($tokens); $i++) {
+			$result = "";
+			$tok = strtok($s, $tokens[$i]);
+			while($tok) {
+				$result .= $tok;
+			//	echo "result = ".$result."\n";
+				$tok = strtok($tokens[$i]);
+			}
+			$s = $result;
+		//	echo "s = ".$s."\n";
+		}
+	//	echo "result = ".$result."\n";
+		return $result;
+	}
+}
+?>