Commit 0f29dfdd authored by Kurt Zeilenga's avatar Kurt Zeilenga
Browse files

Update contrib with latest from -devel, including php3-tool and gtk-tool.

parent d5bc2084
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.
#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;
}
#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
#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;
// }
}
#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
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
#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;
}
#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
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
#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;
}
#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
#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;
}
#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
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
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.