Commit 557c2906 authored by Pavel Janík's avatar Pavel Janík
Browse files

Remove file.

parent 9e2b2e30
#include "../src/lisp.h"
#include "lwlib-Xol.h"
#include <X11/StringDefs.h>
#include <X11/IntrinsicP.h>
#include <X11/CompositeP.h>
#include <X11/Shell.h>
#include <Xol/Menu.h>
#include <Xol/OpenLook.h>
#include <Xol/MenuButton.h>
#include <Xol/OblongButt.h>
#include <Xol/ControlAre.h>
#include <Xol/Stub.h>
#include <Xol/StaticText.h>
/* forward declarations */
static void
update_menu_widget (widget_instance* instance, Widget widget,
widget_value* val);
/* Menu callbacks */
static void
pre_hook (Widget w, caddr_t client_data, caddr_t call_data)
{
OlVirtualEvent ve = (OlVirtualEvent)call_data;
widget_instance* instance = (widget_instance*)client_data;
if (w->core.being_destroyed)
return;
if (XtParent (w) == instance->widget)
{
if (ve->xevent->type == ButtonPress && instance->info->pre_activate_cb)
instance->info->pre_activate_cb (instance->widget, instance->info->id,
NULL);
}
}
static void
post_hook (Widget w, caddr_t client_data, caddr_t call_data)
{
widget_instance* instance = (widget_instance*)client_data;
if (w->core.being_destroyed)
return;
if (instance->info->post_activate_cb)
instance->info->post_activate_cb (w, instance->info->id, NULL);
}
static void
pick_hook (Widget w, caddr_t client_data, caddr_t call_data)
{
widget_instance* instance = 0;
widget_value* val = (widget_value*)client_data;
if (w->core.being_destroyed)
return;
XtVaGetValues (w, XtNuserData, &instance, 0);
if (!instance)
return;
if (instance->info->selection_cb && val && val->enabled
&& !val->contents)
instance->info->selection_cb (w, instance->info->id, val->call_data);
}
/* creation functions */
static Widget
xol_create_menubar (widget_instance* instance)
{
Widget widget =
XtVaCreateWidget (instance->info->name, controlAreaWidgetClass,
instance->parent, 0);
return widget;
}
static Widget
xol_create_popup_menu (widget_instance* instance)
{
Widget popup_shell =
XtCreatePopupShell (instance->info->name, menuShellWidgetClass,
instance->parent, NULL, 0);
return popup_shell;
}
widget_creation_entry
xol_creation_table [] =
{
{"menubar", xol_create_menubar},
{"popup", xol_create_popup_menu},
{NULL, NULL}
};
Widget
xol_create_dialog (widget_instance* instance)
{
return NULL;
}
Boolean
lw_olit_widget_p (Widget widget)
{
return True;
}
/* update functions */
static void
destroy_all_children (Widget widget)
{
Widget* children;
unsigned int number;
int i;
children = (Widget *) XtCompositeChildren (widget, &number);
if (children)
{
/* Unmanage all children and destroy them. They will only be
* really destroyed when we get out of DispatchEvent. */
for (i = 0; i < number; i++)
{
Widget child = children [i];
if (!child->core.being_destroyed)
{
XtUnmanageChild (child);
XtDestroyWidget (child);
}
}
XtFree (children);
}
}
static Boolean
all_dashes_p (char* s)
{
char* t;
for (t = s; *t; t++)
if (*t != '-')
return False;
return True;
}
static void
make_menu_in_widget (widget_instance* instance, Widget widget,
widget_value* val)
{
widget_value* cur;
Widget button;
Arg al [256];
int ac;
String label;
for (cur = val; cur; cur = cur->next)
{
ac = 0;
XtSetArg (al [ac], XtNsensitive, cur->enabled); ac++;
XtSetArg (al [ac], XtNuserData, instance); ac++;
XtSetArg (al [ac], XtNacceleratorText, cur->key); ac++;
/* label = (char *) resource_string (widget, cur->name);*/
label = cur->name;
if (label)
{
XtSetArg (al [ac], XtNlabel, label); ac++;
}
if (all_dashes_p (cur->name))
{
/* no separator in OpenLook just make some space. */
XtSetArg (al [ac], XtNheight, 5); ac++;
XtSetArg (al [ac], XtNwidth, 5); ac++;
button = XtCreateWidget (cur->name, stubWidgetClass, widget, al, ac);
}
else if (!cur->contents)
{
if (!cur->call_data)
button =
XtCreateManagedWidget (cur->name, staticTextWidgetClass, widget,
al, ac);
else
{
button =
XtCreateManagedWidget (cur->name, oblongButtonWidgetClass,
widget, al, ac);
XtAddCallback (button, XtNselect, pick_hook, cur);
}
}
else
{
Widget menu = NULL;
button =
XtCreateManagedWidget (cur->name, menuButtonWidgetClass, widget,
al, ac);
XtVaGetValues (button, XtNmenuPane, &menu, 0);
if (!menu)
abort ();
make_menu_in_widget (instance, menu, cur->contents);
OlAddCallback (button, XtNconsumeEvent, pre_hook, instance);
}
}
}
static void
update_one_menu_entry (widget_instance* instance, Widget widget,
widget_value* val)
{
Arg al [256];
int ac;
Widget menu;
widget_value* contents;
if (val->change == NO_CHANGE)
return;
/* update the sensitivity */
XtVaSetValues (widget, XtNsensitive, val->enabled, 0);
/* update the pulldown/pullaside as needed */
ac = 0;
menu = NULL;
XtVaGetValues (widget, XtNmenuPane, &menu, 0);
contents = val->contents;
if (!menu)
{
if (contents)
{
/* in OLIT this would have to be a structural change on the
button. */
abort ();
}
}
else if (!contents)
{
/* in OLIT this would have to be a structural change on the button. */
abort ();
}
else if (contents->change != NO_CHANGE)
update_menu_widget (instance, menu, val);
}
static void
update_menu_widget (widget_instance* instance, Widget widget,
widget_value* val)
{
if (val->change == STRUCTURAL_CHANGE
|| val->contents->change == STRUCTURAL_CHANGE)
{
destroy_all_children (widget);
make_menu_in_widget (instance, widget, val->contents);
}
else
{
/* Update all the buttons of the composite widget in order. */
Widget* children;
unsigned int num_children;
int i;
widget_value* cur;
children = (Widget *) XtCompositeChildren (widget, &num_children);
if (children)
{
for (i = 0, cur = val->contents; i < num_children; i++)
{
if (!cur)
abort ();
if (children [i]->core.being_destroyed
|| strcmp (XtName (children [i]), cur->name))
continue;
update_one_menu_entry (instance, children [i], cur);
cur = cur->next;
}
XtFree (children);
}
if (cur)
abort ();
}
}
void
xol_update_one_widget (widget_instance* instance, Widget widget,
widget_value* val, Boolean deep_p)
{
Widget menu = widget;
if (XtIsShell (widget))
XtVaGetValues (widget, XtNmenuPane, &menu, 0);
update_menu_widget (instance, menu, val);
}
void
xol_update_one_value (widget_instance* instance, Widget widget,
widget_value* val)
{
return;
}
void
xol_pop_instance (widget_instance* instance, Boolean up)
{
}
void
xol_popup_menu (Widget widget)
{
OlMenuPost (widget);
}
/* Destruction of instances */
void
xol_destroy_instance (widget_instance* instance)
{
XtDestroyWidget (instance->widget);
}
#ifndef LWLIB_XOL_H
#define LWLIB_XOL_H
#include "lwlib-int.h"
extern widget_creation_entry xol_creation_table [];
extern Widget xol_create_dialog (widget_instance *);
Boolean
lw_olit_widget_p (Widget widget);
void
xol_update_one_widget (widget_instance* instance, Widget widget,
widget_value* val, Boolean deep_p);
void
xol_update_one_value (widget_instance* instance, Widget widget,
widget_value* val);
void
xol_destroy_instance (widget_instance* instance);
void
xol_pop_instance (widget_instance* instance, Boolean up);
void
xol_popup_menu (Widget widget);
#endif /* LWLIB_XOL_H */
/* An OLIT menubar widget, by Chuck Thompson <cthomp@cs.uiuc.edu>
Copyright (C) 1993 Lucid, Inc.
This file is part of the Lucid Widget Library.
The Lucid Widget Library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
The Lucid Widget Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "../src/lisp.h"
#include <X11/IntrinsicP.h>
#include <X11/Intrinsic.h>
#include <X11/CompositeP.h>
#include <X11/Composite.h>
#include "lwlib-Xol-mbP.h"
#include "lwlib-Xol-mb.h"
#define HORIZ_SPACING 4
#define VERT_SPACING 4
static void Initialize();
static void Resize();
static void ChangeManaged();
static Boolean SetValues();
static XtGeometryResult GeometryManager();
static XtGeometryResult PreferredSize();
static void do_layout();
static XtGeometryResult try_layout();
lwMenuBarClassRec lwMenubarClassRec =
{
{
/* core_class members */
(WidgetClass) &compositeClassRec, /* superclass */
"Menubar", /* class_name */
sizeof(lwMenuBarRec), /* widget_size */
NULL, /* class_initialize */
NULL, /* class_part_initialize */
FALSE, /* class_inited */
Initialize, /* initialize */
NULL, /* initialize_hook */
XtInheritRealize, /* realize */
NULL, /* actions */
0, /* num_actions */
NULL, /* resources */
0, /* num_resources */
NULLQUARK, /* xrm_class */
TRUE, /* compress_motion */
XtExposeCompressMaximal, /* compress_exposure */
TRUE, /* compress_enterleave */
FALSE, /* visible_interest */
NULL, /* destroy */
Resize, /* resize */
NULL, /* expose */
NULL, /* set_values */
NULL, /* set_values_hook */
XtInheritSetValuesAlmost, /* set_values_almost */
NULL, /* get_values_hook */
NULL, /* accept_focus */
XtVersion, /* version */
NULL, /* callback_private */
NULL, /* tm_table */
PreferredSize, /* query_geometry */
NULL, /* display_accelerator */
NULL, /* extension */
},
{
/* composite_class members */
GeometryManager, /* geometry_manager */
ChangeManaged, /* change_managed */
XtInheritInsertChild, /* insert_child */
XtInheritDeleteChild, /* delete_child */
NULL, /* extension */
},
{
/* Menubar class members */
0, /* empty */
}
};
WidgetClass lwMenubarWidgetClass = (WidgetClass) &lwMenubarClassRec;
static void Initialize (request, new)
lwMenuBarWidget request, new;
{
if (request->core.width <= 0)
new->core.width = 1;
if (request->core.height <= 0)
new->core.height = 23;
}
static void
Resize (w)
lwMenuBarWidget w;
{
do_layout(w);
}
static void
do_layout (parent)
lwMenuBarWidget parent;
{
Widget child;
int cnt;
int managed_children = 0;
int managed_width = 0;
int new_pos = 0;
/*
* Determine number of children which will fit on one line.
* For now we ignore the rest, making sure they are unmanaged.
*/
cnt = 0;
while ((cnt < (int) parent->composite.num_children) &&
(managed_width < (int) parent->core.width))
{
child = parent->composite.children[cnt++];
managed_children++;
managed_width += child->core.width + child->core.border_width * 2 +
HORIZ_SPACING;
}
if (managed_width > (int) parent->core.width)
managed_children--;
/*
* Correct positioning of children.
*/
cnt = 0;
while (managed_children)
{
child = parent->composite.children[cnt++];
if (!child->core.managed)
XtManageChild (child);
if ((child->core.x != new_pos) || (child->core.y != 0))
XtMoveWidget (child, new_pos, 0);
new_pos += child->core.width + child->core.border_width * 2 +
HORIZ_SPACING;
managed_children--;
}
/*
* Make sure all remaining children are unmanaged.
*/
while (cnt < parent->composite.num_children)
{
child = parent->composite.children[cnt];
if (child->core.managed)
XtUnmanageChild (child);
if ((child->core.x != parent->core.width) ||
(child->core.y != parent->core.height))
XtMoveWidget (child, parent->core.width, parent->core.height);
cnt++;
}
}
static XtGeometryResult
PreferredSize (w, request, preferred)
lwMenuBarWidget w;
XtWidgetGeometry *request, *preferred;
{
Widget child;
int cnt;
/*
* If no changes are being made to the width or height, just agree.
*/
if (!(request->request_mode & CWWidth) &&
!(request->request_mode & CWHeight))
return (XtGeometryYes);
/*
* Right now assume everything goes in one row. Calculate the
* minimum required width and height.
*/
preferred->width = 0;
preferred->height = 0;
for (cnt = 0; cnt < w->composite.num_children; cnt++)
{
child = w->composite.children[cnt];
if (child->core.managed)
{
preferred->width += child->core.width + child->core.border_width*2 +
HORIZ_SPACING;
if (preferred->height < (Dimension) (child->core.height +
child->core.border_width * 2))
preferred->height = child->core.height +
child->core.border_width * 2;
}
}
preferred->request_mode = CWWidth | CWHeight;
/*
* Case: both height and width requested
*/
if ((request->request_mode & CWWidth) &&
(request->request_mode & CWHeight))
{
/*
* Ok if same or bigger.
*/
if (preferred->width <= request->width &&
preferred->height <= request->height)
{
preferred->width = request->width;
return (XtGeometryYes);
}
/*
* If both dimensions are too small, say no.
*/
else
if (preferred->width > request->width &&
preferred->height > request->height)
return (XtGeometryNo);
/*
* Otherwise one must be right, so say almost.
*/
else
return (XtGeometryAlmost);
}
/*
* If only one dimension is requested, either its OK or it isn't.
*/
else
{
if (request->request_mode & CWWidth)
{
if (preferred->width <= request->width)
{
preferred->width = request->width;
return (XtGeometryYes);
}
else
return (XtGeometryNo);
}
else if (request->request_mode & CWHeight)
{
if (preferred->height <= request->height)
{
return (XtGeometryYes);
}
else
return (XtGeometryNo);
}
return (XtGeometryYes);