--- /dev/null
+#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>
+
+\f/* forward declarations */
+static void
+update_menu_widget (widget_instance* instance, Widget widget,
+ widget_value* val);
+
+\f/* 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);
+}
+
+\f/* 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;
+}
+
+\f/* 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 woudl have to be a structural change on the
+ button. */
+ abort ();
+ }
+ }
+ else if (!contents)
+ {
+ /* in OLIT this woudl 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);
+}
+
+\f/* Destruction of instances */
+void
+xol_destroy_instance (widget_instance* instance)
+{
+ XtDestroyWidget (instance->widget);
+}
+
#ifndef LWLIB_XOL_H
#define LWLIB_XOL_H
-#include "lwlib-internal.h"
+#include "lwlib-int.h"
extern widget_creation_entry xol_creation_table [];
extern Widget xol_create_dialog (widget_instance *);
--- /dev/null
+/* 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#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);
+ }
+}
+
+
+static XtGeometryResult
+GeometryManager (w, request, reply)
+ Widget w;
+ XtWidgetGeometry *request;
+ XtWidgetGeometry *reply;
+{
+
+ lwMenuBarWidget parent = (lwMenuBarWidget) w->core.parent;
+
+ /*
+ * If the widget wants to move, just say no.
+ */
+
+ if ((request->request_mode & CWX && request->x != w->core.x) ||
+ (request->request_mode & CWY && request->y != w->core.y))
+ return (XtGeometryNo);
+
+ /*
+ * Since everything "fits" for now, grant all requests.
+ */
+
+ if (request->request_mode & CWWidth)
+ w->core.width = request->width;
+ if (request->request_mode & CWHeight)
+ w->core.height = request->height;
+ if (request->request_mode & CWBorderWidth)
+ w->core.border_width = request->border_width;
+
+ do_layout (parent);
+ return (XtGeometryYes);
+}
+
+
+static XtGeometryResult
+try_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++];
+ if (child->core.managed)
+ {
+ managed_children++;
+ managed_width += child->core.width + child->core.border_width * 2 +
+ HORIZ_SPACING;
+ }
+ }
+
+ if (managed_width > (int) parent->core.width)
+ return (XtGeometryNo);
+ else
+ return (XtGeometryYes);
+}
+
+
+
+static void
+ChangeManaged (w)
+ lwMenuBarWidget w;
+{
+ XtGeometryResult result;
+
+ result = try_layout (w);
+
+ if (result != XtGeometryYes)
+ {
+ XtUnmanageChild (w->composite.children[w->composite.num_children - 1]);
+ XtMoveWidget (w->composite.children[w->composite.num_children-1],
+ w->core.width, w->core.height);
+ }
+
+ do_layout (w);
+}
--- /dev/null
+/* 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef LW_MENUBAR_H
+#define LW_MENUBAR_H
+extern WidgetClass lwMenubarWidgetClass;
+typedef struct _lwMenuBarClassRec *lwMenuBarWidgetClass;
+typedef struct _lwMenuBarRec *lwMenuBarWidget;
+#endif /* LW_MENUBAR_H */
--- /dev/null
+/* 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef LW_MENUBARP_H
+#define LW_MENUBARP_H
+
+typedef struct _lwMenuBarClassPart
+{
+ int ignore;
+} lwMenuBarClassPart;
+
+typedef struct _lwMenuBarClassRec
+{
+ CoreClassPart core_class;
+ CompositeClassPart composite_class;
+ lwMenuBarClassPart menubar_class;
+} lwMenuBarClassRec;
+
+extern lwMenuBarClassRec lwMenubarClassRec;
+
+typedef struct
+{
+ int empty;
+} lwMenuBarPart;
+
+typedef struct _lwMenuBarRec
+{
+ CorePart core;
+ CompositePart composite;
+ lwMenuBarPart menubar;
+} lwMenuBarRec;
+
+#endif /* LW_MENUBARP_H */
--- /dev/null
+/* The emacs frame widget private header file.
+ Copyright (C) 1993 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs 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 2, or (at your option)
+any later version.
+
+GNU Emacs 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* Emacs 19 face widget ported by Fred Pierresteguy */
+
+#ifndef _EmacsFrameP_h
+#define _EmacsFrameP_h
+
+#include <X11/IntrinsicP.h>
+#include <X11/CoreP.h>
+#include "widget.h"
+
+typedef struct {
+ struct frame* frame; /* the *emacs* frame object */
+
+ /* Resources that can't be done from lisp.
+ */
+ char* geometry; /* geometry spec of this frame */
+ Boolean iconic; /* whether this frame is iconic */
+
+ /* The rest of this is crap and should be deleted.
+ */
+ int minibuffer; /* 0: normal frames with minibuffers.
+ * 1: frames without minibuffers
+ * 2: minibuffer only. */
+ Boolean unsplittable; /* frame can only have one window */
+
+ int internal_border_width; /* internal borders */
+ int interline; /* skips between lines */
+
+ XFontStruct* font; /* font */
+ Pixel foreground_pixel; /* foreground */
+
+ Pixel cursor_color; /* text cursor color */
+ Boolean bar_cursor; /* 1 if bar, 0 if block */
+
+ Boolean visual_bell; /* flash instead of beep */
+ int bell_volume; /* how loud is beep */
+
+ /* private state */
+
+} EmacsFramePart;
+
+typedef struct _EmacsFrameRec { /* full instance record */
+ CorePart core;
+ EmacsFramePart emacs_frame;
+} EmacsFrameRec;
+
+typedef struct { /* new fields for EmacsFrame class */
+ int dummy;
+} EmacsFrameClassPart;
+
+typedef struct _EmacsFrameClassRec { /* full class record declaration */
+ CoreClassPart core_class;
+ EmacsFrameClassPart emacs_frame_class;
+} EmacsFrameClassRec;
+
+extern EmacsFrameClassRec emacsFrameClassRec; /* class pointer */
+
+
+
+#endif /* _EmacsFrameP_h */
projects / emacs.git / commitdiff