Core man page on HP-UX

Man page or keyword search:  
man Server   10987 pages
apropos Keyword Search (all sections)
Output format
HP-UX logo
[printable version]

Core()									Core()

  Core widget class - fundamental object class with a window.

  Public Headers:   <X11/StringDefs.h>

  Private Header:   <X11/CoreP.h>

  Class Name:	    Core

  Class Hierarchy:  Object → RectObj → unnamed → Core

  Class Pointer:    widgetClass or coreWidgetClass

  Instantiation:    Core is an Intrinsics meta-class, and is not normally

  Functions/Macros: XtIsWidget()

  Core is the fundamental class for windowed widgets.  All  widgets  with
  windows are subclasses of Core.  Core is sometimes instantiated for use
  as a basic drawing area.

New Resources
  Core has the following resources (some of which are actually defined by
  the Object and RectObj classes):

Name		 Class		  Type		  Default	  Access
XtNaccelerators	 XtCAccelerators  XtAccelerators  NULL		  CSG
XtNancestor-	 XtCSensitive	  Boolean	  dynamic	  G
XtNbackground	 XtCBackground	  Pixel		  dynamic	  CSG
XtNbackground-	 XtCPixmap	  Pixmap	  XmUNSPECIFIED_
Pixmap						  PIXMAP	CSG
XtNborderColor	 XtCBorderColor	  Pixel		  XtDefault-	  CSG
XtNborderPixmap	 XtCPixmap	  Pixmap	  XmUNSPECIFIED_  CSG
XtNborderWidth	 XtCBorderWidth	  Dimension	  1		  CSG
XtNcolormap	 XtCColormap	  Colormap	  dynamic	  CG
XtNdepth	 XtCDepth	  int		  dynamic	  CG
XtNheight	 XtCHeight	  Dimension	  dynamic	  CSG
XtNinitial-	 XtCInitial-	  Boolean	  True		  CG
Resources-	 Resources-
Persistent	 Persistent
XtNmappedWhen-	 XtCMappedWhen-	  Boolean	  True		  CSG
Managed		 Managed
XtNscreen	 XtCScreen	  Screen *	  dynamic	  CG
XtNsensitive	 XtCSensitive	  Boolean	  True		  CSG
XtNtranslations	 XtCTranslations  XtTranslations  NULL		  CSG
XtNwidth	 XtCWidth	  Dimension	  dynamic	  CSG
XtNx		 XtCPosition	  Position	  0		  CSG
XtNy		 XtCPosition	  Position	  0		  CSG

       A  translation  table  bound  with  its	actions	 for a widget.	A
       destination widget can be set up to use	this  accelerator  table.
       See XtInstallAccelerators(1).

       Specifies whether the object has an insensitive ancestor.  Default
       value is (a) True (if the widget is a top-level shell), (b) copied
       from  the  XtNancestorSensitive	resource  of  its  parent (if the
       widget  is  a  popup  shell),  or  (c)  the  bitwise  AND  of  the
       XtNsensitive and XtNancestorSensitive resources of the parent (for
       other widgets).	See XtSetSensitive(1).

       Widget's background color.

       Pixmap with which to tile the background, beginning at the  upper-
       left corner.

       Pixel value that defines the color of the border.

       Pixmap  with which to tile the border, beginning at the upper-left
       corner of the border.

       Width (in pixels) of the window's border.

       Colormap used in converting to pixel values.   Previously  created
       pixel  values are unaffected.  The default value is inherited from
       the widget's parent, or is the default colormap of the screen  for
       root shells that have no parent.

       Number of bits allowed for each pixel.  The Xt Intrinsics set this
       resource when the widget is  created.   As  with	 the  XtNcolormap
       resource,  the default value comes from the screen's default or is
       copied from the parent.

       List of callbacks invoked when the widget is destroyed.

       Window height (in pixels), excluding the border.

       Specifies whether resources should be reference counted.	 If  True
       (default),  it is assumed that the widget won't be destroyed while
       the application is running, and thus the	 widget's  resources  are
       not  reference  counted.	  Set  this  resource  to  False  if your
       application might destroy the widget and will need  to  deallocate
       the resources.  See XtConvertAndStore(1).

       If  True (default), the widget becomes visible (is mapped) as soon
       as it is both realized and managed.   If	 False,	 the  application
       performs	 the  mapping and unmapping of the widget.  If changed to
       False after the widget is realized  and	managed,  the  widget  is
       unmapped.  See XtSetMappedWhenManaged(1).

       Screen of the widget.

       Specifies   whether   a	widget	receives  input	 (is  sensitive).
       XtSetSensitive() can be used to change a widget's sensitivity  and
       to guarantee that if a parent has its XtNsensitive resource set to
       False, then its	children  will	have  their  XtNancestorSensitive
       resource set to False.  See XtSetSensitive(1).

       Points	to   a	 translation   table;	must   be  compiled  with
       XtParseTranslationTable().   See	  XtOverrideTranslations(1)   and

       Window width (in pixels), excluding the border.

       The x-coordinate of the widget's upper-left outer corner, relative
       to the upper-left inner corner of its parent.

       The y-coordinate of the widget's upper-left outer corner, relative
       to the upper-left inner corner of its parent.

Class Structure
  The Core class structure is defined as follows:

     typedef struct _CoreClassPart {
	 WidgetClass superclass;/* pointer to superclass ClassRec */
	 String class_name;    /* widget resource class name */
	 Cardinal widget_size; /* size in bytes of widget record */
	 XtProc class_initialize;/* class initialization proc */
	 XtWidgetClassProc class_part_initialize;/* dynamic initialization */
	 XtEnum class_inited;  /* has class been initialized? */
	 XtInitProc initialize;/* initialize subclass fields */
	 XtArgsProc initialize_hook;/* notify that initialize called */
	 XtRealizeProc realize;/* XCreateWindow for widget */
	 XtActionList actions; /* widget semantics name to proc map */
	 Cardinal num_actions; /* number of entries in actions */
	 XtResourceList resources;/* resources for subclass fields */
	 Cardinal num_resources;/* number of entries in resources */
	 XrmClass xrm_class;   /* resource class quarkified */
	 Boolean compress_motion;/* compress MotionNotify for widget */
	 XtEnum compress_exposure;/* compress Expose events for widget*/
	 Boolean compress_enterleave;/* compress enter and leave events */
	 Boolean visible_interest;/* select for VisibilityNotify */
	 XtWidgetProc destroy; /* free data for subclass pointers */
	 XtWidgetProc resize;  /* geom manager changed widget size */
	 XtExposeProc expose;  /* redisplay window */
	 XtSetValuesFunc set_values;/* set subclass resource values */
	 XtArgsFunc set_values_hook;/* notify that set_values called */
	 XtAlmostProc set_values_almost;/* set_values got "Almost" geo reply */
	 XtArgsProc get_values_hook;/* notify that get_values called */
	 XtAcceptFocusProc accept_focus;/* assign input focus to widget */
	 XtVersionType version;/* version of Intrinsics used */
	 XtPointer callback_private;/* list of callback offsets */
	 String tm_table;      /* default translation table */
	 XtGeometryHandler query_geometry;/* return preferred geometry */
	 XtStringProc display_accelerator;/* display your accelerator */
	 XtPointer extension;  /* pointer to extension record */
      } CoreClassPart;

     typedef struct {
	     CoreClassPart core_class;
     } WidgetClassRec, *WidgetClass, CoreClassRec, *CoreWidgetClass;

  The  meanings	 of each of the fields in the Core class structure are as

       A pointer to the class record of this widget's  superclass.   That
       class record is declared in the superclass' private header file.

       A constant string that names the class.

       The size of the instance structure for this widget.  Use sizeof.

       The   class_initialize()	  method   called   to	perform	 one-time
       initialization for this class.  See the reference page in  Section
       4.   This  is  a chained method which cannot be inherited.  Set to
       NULL if no special initialization is needed for the class.

       The   class_part_initialize()	method	  called    to	  perform
       initialization  for  the	 class part structure.	See the reference
       page in Section 4.  This is  a  chained	method	which  cannot  be
       inherited.  Set to NULL if no special initialization is needed for
       your class part.

       Whether the class structure  has	 been  initialized  yet.   Always
       initialize to False.

       The   initialize()   method  called  to	initialize  the	 instance
       structure.  See the reference  page  in	Section	 4.   This  is	a
       chained	method	which  cannot  be  inherited.	Set to NULL if no
       special initialization of the widget instance structure is needed.

       The (obsolete) initialize_hook() method.	 See the  reference  page
       in Section 4.  This is a chained method which cannot be inherited.
       Set to NULL if no special initialization is needed.

       The realize() method called to create a	window	for  the  widget.
       See  the	 reference  page  in  Section 4.  Use XtInheritRealize to
       inherit the realize() method of the superclass.

       The action name to action procedure mapping which will be used  by
       this widget when binding translation tables to actions.	These are
       automatically  registered  with	the  Intrinsics	 when  the   Core
       class_part_initialize()	method	is  performed.	The array must be
       permanently allocated, and the Intrinsics may overwrite it with an
       internal compiled form of the action table.  The action names must
       be permanently allocated strings.

       The number of elements in the actions array.

       An array of XtResource, each element of	which  defines	a  single
       resource	 for the widget.  See XtGetApplicationResources(1) for an
       explanation of how to define resources.

       The number of elements in the resources array.

       This field is private to the Resource Manager.  Initialize  it  to

       If True, the Intrinsics will only report the last of a sequence of
       pointer motion events.

       Specifies how Expose and GraphicsExpose events should be delivered
       to  the	widget.	  If  False  or	 XtExposeNoCompress, all exposure
       events  will  be	 delivered.   There  are  a   number   of   other
       possibilities; see expose(4) for full details.

       If  True,  the  Intrinsics  will	 discard pairs of enter and leave
       events from the	input  queue  that  have  no  intervening  events
       between them.

       If  True,  the Intrinsics will request VisibilityNotify events for
       the Widget and update the  visible  field  of  the  Core	 instance
       structure  as  they arrive.  The visible field is guaranteed to be
       True by the time an exposure event is processed (i.e., by the time
       the  expose()  method  is  called)  if  any  part of the widget is
       visible, but is	False  if  the	widget	is  fully  obscured.   If
       visible_interest	 is  False,  then  the	visible instance field is
       always True.

       The destroy() method  called  when  a  widget  of  this	class  is
       destroyed.   See	 the  reference	 page  in  Section  4.	This is a
       chained method and cannot be inherited.	Initialize it to NULL  if
       no  special  processing	needs to be done when an instance of this
       widget class is destroyed.

       The resize() method called when a widget of this class is  resized
       by  its	parent.	  See  the  reference  page  in	 Section  4.  Use
       XtInheritResize to inherit the resize() method of the superclass.

       The expose() method called when exposure events	arrive	for  this
       widget.	See the reference page in Section 4.  Use XtInheritExpose
       to inherit the expose() method of the superclass.

       The set_values() method called when an application  sets	 resource
       values  in  the	instance  record  with	XtSetValues().	 See  the
       reference page in Section 4.  This is a chained method and  cannot
       be inherited.  Specify NULL if the widget class has no resources.

       The  (obsolete)	set_values_hook() method.  See the reference page
       in Section 4.  This method is chained and cannot be inherited.

       The set_values_almost() method called when a geometry  request  in
       an  XtSetValues()  call	cannot	be completely satisfied.  See the
       reference page in  Section  4.	Use  XtInheritSetValuesAlmost  to
       inherit the set_values_almost() method of the superclass.

       The  get_values_hook() method called in response to XtGetValues().
       See the reference page in Section 4.  This is a chained method and
       cannot be inherited.

       The  accept_focus()  method  called  by a parent to offer keyboard
       focus to a child.  See the  reference  page  in	Section	 4.   Use
       XtInheritAcceptFocus  to	 inherit the accept_focus() method of the

       The version field indicates  the	 toolkit  implementation  version
       number and is used for runtime consistency checking of the toolkit
       and widgets in an application.  Widget writers must set it to  the
       implementation-defined  symbolic	 value	XtVersion  in  the widget
       class structure initialization.	Those widget writers who  believe
       that   their   widget   binaries	  are	compatible   with   other
       implementations of  the	Intrinsics  can	 put  the  special  value
       XtVersionDontCheck   in	the  version  field  to	 disable  version
       checking	 for  those  widgets.	If  a  widget  needs  to  compile
       alternative   code  for	different  revisions  of  the  Intrinsics
       interface    definition,	    it	   may	   use	   the	   symbol
       XtSpecificationRelease.	 Use  of  XtVersion allows the Intrinsics
       implementation to recognize widget  binaries  that  were	 compiled
       with older implementations.

       This field is private to callback handling; initialize to NULL.

       The  default  translation table for widgets of this class.  It may
       be overridden by clients that set the XtNtranslations resource  of
       the  widget  instance.	This  field  should specify a translation
       table in	 string	 form  (see  Appendix  F  for  the  syntax);  the
       Intrinsics  will	 automatically	compile it into an internal form.
       Use XtInheritTranslations to inherit the translation table of  the

       The query_geometry() method, called by a parent widget to discover
       the preferred geometry of a child.   See	 the  reference	 page  in
       Section	  4.	Use   XtInheritQueryGeometry   to   inherit   the
       query_geometry() method of the superclass.

       The  display_accelerator()  method,   called   when   a	 widget's
       accelerators have been installed on a destination widget.  See the
       reference page in Section 4.  Use  XtInheritDisplayAccelerator  to
       inherit the display_accelerator() method of the superclass.

       A  linked  list	of  extension  records.	  There	 are currently no
       extensions defined for the Core widget class, so this field should
       be initialized to NULL.

Instance Structure
  The  Core  instance record contains at least the following fields.  The
  fields need not be in the order  shown,  but	because	 the  Object  and
  RectObj  superclasses	 were  defined	after Core was standardized, Core
  duplicates the instance records of those  classes,  and  the	duplicate
  fields  must	be  in the same position in the Object, RectObj, and Core
  instance structures.

     typedef struct {
	Widget self;	       /* pointer to widget itself */
	WidgetClass widget_class;/* pointer to widget's ClassRec */
	Widget parent;	       /* parent widget */
	Boolean being_destroyed;/* marked for destroy */
	XtCallbackList destroy_callbacks;/* called when widget destroyed */
	XtPointer constraints; /* constraint record */
	Position x, y;	       /* window position */
	Dimension width, height;/* window dimensions */
	Dimension border_width;/* window border width */
	Boolean managed;       /* is widget geometry managed? */
	Boolean sensitive;     /* is widget sensitive to user events */
	Boolean ancestor_sensitive;/* are all ancestors sensitive? */
	XtTranslations accelerators;/* accelerator translations */
	Pixel border_pixel;    /* window border pixel */
	Pixmap border_pixmap;  /* window border pixmap or NULL */
	WidgetList popup_list; /* list of pop ups */
	Cardinal num_popups;   /* how many pop ups */
	String name;	       /* widget resource name */
	Screen *screen;	       /* window's screen */
	Colormap colormap;     /* colormap */
	Window window;	       /* window ID */
	Cardinal depth;	       /* number of planes in window */
	Pixel background_pixel;/* window background pixel */
	Pixmap background_pixmap;/* window background pixmap or NULL */
	Boolean visible;       /* is window mapped and not occluded? */
	Boolean mapped_when_managed;/* map window if it is managed? */
     } CorePart;

     typedef struct {
	CorePart core;
     } WidgetRec, *Widget, CoreRec, *CoreWidget;

See Also
  Core(3), Object(3), RectObj(3),
  class_initialize(4),	     class_part_initialize(4),	      destroy(4),
  display_accelerator(4), expose(4),
  get_values_hook(4),	       initialize(4),	      initialize_hook(4),
  query_geometry(4), realize(4), resize(4),
  set_values(4), set_values_almost(4), set_values_hook(4).

Intrinsics Classes							Core()

List of man pages available for HP-UX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net