Mercurial > hg > xemacs-beta

comparison src/glyphs-widget.c @ 408:501cfd01ee6d r21-2-34

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-34
author cvs
date Mon, 13 Aug 2007 11:18:11 +0200
parents b8cc9ab3f761
children de805c49cfc1
comparison
equal deleted inserted replaced
407:ed6218a7d4d3 408:501cfd01ee6d
53 Lisp_Object Qtree_view; 53 Lisp_Object Qtree_view;
54 DEFINE_IMAGE_INSTANTIATOR_FORMAT (tab_control); 54 DEFINE_IMAGE_INSTANTIATOR_FORMAT (tab_control);
55 Lisp_Object Qtab_control; 55 Lisp_Object Qtab_control;
56 DEFINE_IMAGE_INSTANTIATOR_FORMAT (layout); 56 DEFINE_IMAGE_INSTANTIATOR_FORMAT (layout);
57 Lisp_Object Qlayout; 57 Lisp_Object Qlayout;
58 DEFINE_IMAGE_INSTANTIATOR_FORMAT (native_layout);
59 Lisp_Object Qnative_layout;
58 60
59 Lisp_Object Q_descriptor, Q_height, Q_width, Q_properties, Q_items; 61 Lisp_Object Q_descriptor, Q_height, Q_width, Q_properties, Q_items;
60 Lisp_Object Q_image, Q_text, Q_orientation, Q_justify, Q_border; 62 Lisp_Object Q_image, Q_text, Q_orientation, Q_justify, Q_border;
63 Lisp_Object Q_margin_width;
61 Lisp_Object Qetched_in, Qetched_out, Qbevel_in, Qbevel_out; 64 Lisp_Object Qetched_in, Qetched_out, Qbevel_in, Qbevel_out;
62 Lisp_Object Vwidget_callback_current_channel;
63 Lisp_Object Qwidget_callback_current_channel;
64 65
65 #ifdef DEBUG_WIDGETS 66 #ifdef DEBUG_WIDGETS
66 int debug_widget_instances; 67 int debug_widget_instances;
67 #endif 68 #endif
68 69
272 /* first see if its a general property ... */ 273 /* first see if its a general property ... */
273 if (!NILP (Fplist_member (IMAGE_INSTANCE_WIDGET_PROPS (ii), prop))) 274 if (!NILP (Fplist_member (IMAGE_INSTANCE_WIDGET_PROPS (ii), prop)))
274 return Fplist_get (IMAGE_INSTANCE_WIDGET_PROPS (ii), prop, Qnil); 275 return Fplist_get (IMAGE_INSTANCE_WIDGET_PROPS (ii), prop, Qnil);
275 276
276 /* .. then try device specific methods ... */ 277 /* .. then try device specific methods ... */
277 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii), 278 meths = decode_device_ii_format (image_instance_device (image_instance),
278 IMAGE_INSTANCE_WIDGET_TYPE (ii), 279 IMAGE_INSTANCE_WIDGET_TYPE (ii),
279 ERROR_ME_NOT); 280 ERROR_ME_NOT);
280 if (meths && HAS_IIFORMAT_METH_P (meths, property)) 281 if (meths && HAS_IIFORMAT_METH_P (meths, property))
281 return IIFORMAT_METH (meths, property, (image_instance, prop)); 282 return IIFORMAT_METH (meths, property, (image_instance, prop));
282 /* ... then format specific methods ... */ 283 /* ... then format specific methods ... */
302 IMAGE_INSTANCE_WIDGET_TEXT (ii) = val; 303 IMAGE_INSTANCE_WIDGET_TEXT (ii) = val;
303 IMAGE_INSTANCE_TEXT_CHANGED (ii) = 1; 304 IMAGE_INSTANCE_TEXT_CHANGED (ii) = 1;
304 } 305 }
305 306
306 /* Now try device specific methods first ... */ 307 /* Now try device specific methods first ... */
307 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii), 308 meths = decode_device_ii_format (image_instance_device (image_instance),
308 IMAGE_INSTANCE_WIDGET_TYPE (ii), 309 IMAGE_INSTANCE_WIDGET_TYPE (ii),
309 ERROR_ME_NOT); 310 ERROR_ME_NOT);
310 if (meths && HAS_IIFORMAT_METH_P (meths, set_property) 311 if (meths && HAS_IIFORMAT_METH_P (meths, set_property)
311 && 312 &&
312 !UNBOUNDP (ret = 313 !UNBOUNDP (ret =
329 = Fplist_put (IMAGE_INSTANCE_WIDGET_PROPS (ii), prop, val); 330 = Fplist_put (IMAGE_INSTANCE_WIDGET_PROPS (ii), prop, val);
330 return val; 331 return val;
331 } 332 }
332 333
333 /* Like the rest of redisplay, we want widget updates to occur 334 /* Like the rest of redisplay, we want widget updates to occur
334 asynchronously. Thus toolkit specific methods for setting properties 335 asynchronously. Thus toolkit specific methods for setting
335 must be called by redisplay instead of by *_set_property. Thus 336 properties must be called by redisplay instead of by
336 *_set_property records the change and this function actually 337 *_set_property. Thus *_set_property records the change and this
337 implements it. We want to be slightly clever about this however by 338 function actually implements it. We want to be slightly clever
338 supplying format specific functions for the updates instead of lumping 339 about this however by supplying format specific functions for the
339 them all into this function. Note that there is no need for format 340 updates instead of lumping them all into this function. Note that
340 generic functions. */ 341 there is no need for format generic functions. */
341 void 342 void
342 update_widget (Lisp_Object widget) 343 update_widget (Lisp_Object widget)
343 { 344 {
344 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (widget); 345 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (widget);
345 struct image_instantiator_methods* meths; 346 struct image_instantiator_methods* meths;
346 347
347 if (IMAGE_INSTANCE_TYPE (ii) != IMAGE_WIDGET) 348 if (!WIDGET_IMAGE_INSTANCEP (widget)
349 || EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qlayout)
350 || EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qnative_layout))
348 return; 351 return;
349 352
350 /* Device generic methods. We must update the widget's size as it 353 /* Device generic methods. We must update the widget's size as it
351 may have been changed by the the layout routines. We also do this 354 may have been changed by the the layout routines. We also do this
352 here so that explicit resizing from lisp does not result in 355 here so that explicit resizing from lisp does not result in
353 synchronous updates. */ 356 synchronous updates. */
354 MAYBE_DEVMETH (XDEVICE (ii->device), update_widget, (ii)); 357 MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain), update_widget, (ii));
355 358
356 /* Device-format specific methods */ 359 /* Device-format specific methods */
357 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii), 360 meths = decode_device_ii_format (image_instance_device (widget),
358 IMAGE_INSTANCE_WIDGET_TYPE (ii), 361 IMAGE_INSTANCE_WIDGET_TYPE (ii),
359 ERROR_ME_NOT); 362 ERROR_ME_NOT);
360 MAYBE_IIFORMAT_METH (meths, update, (widget)); 363 MAYBE_IIFORMAT_METH (meths, update, (widget));
361 364
362 /* Pick up the items we recorded earlier. */ 365 /* Pick up the items we recorded earlier. */
387 if (IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) 390 if (IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii)
388 || 391 ||
389 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii)) 392 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii))
390 { 393 {
391 /* .. then try device specific methods ... */ 394 /* .. then try device specific methods ... */
392 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii), 395 meths = decode_device_ii_format (image_instance_device (image_instance),
393 IMAGE_INSTANCE_WIDGET_TYPE (ii), 396 IMAGE_INSTANCE_WIDGET_TYPE (ii),
394 ERROR_ME_NOT); 397 ERROR_ME_NOT);
395 if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry)) 398 if (meths && HAS_IIFORMAT_METH_P (meths, query_geometry))
396 IIFORMAT_METH (meths, query_geometry, (image_instance, 399 IIFORMAT_METH (meths, query_geometry, (image_instance,
397 width, height, disp, 400 width, height, disp,
435 *height = XINT (dynamic_height); 438 *height = XINT (dynamic_height);
436 } 439 }
437 } 440 }
438 } 441 }
439 442
440 static void 443 static int
441 widget_layout (Lisp_Object image_instance, 444 widget_layout (Lisp_Object image_instance,
442 unsigned int width, unsigned int height, Lisp_Object domain) 445 unsigned int width, unsigned int height, Lisp_Object domain)
443 { 446 {
444 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance); 447 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
445 struct image_instantiator_methods* meths; 448 struct image_instantiator_methods* meths;
446 449
447 /* .. then try device specific methods ... */ 450 /* .. then try device specific methods ... */
448 meths = decode_device_ii_format (IMAGE_INSTANCE_DEVICE (ii), 451 meths = decode_device_ii_format (image_instance_device (image_instance),
449 IMAGE_INSTANCE_WIDGET_TYPE (ii), 452 IMAGE_INSTANCE_WIDGET_TYPE (ii),
450 ERROR_ME_NOT); 453 ERROR_ME_NOT);
451 if (meths && HAS_IIFORMAT_METH_P (meths, layout)) 454 if (meths && HAS_IIFORMAT_METH_P (meths, layout))
452 IIFORMAT_METH (meths, layout, (image_instance, 455 return IIFORMAT_METH (meths, layout, (image_instance,
453 width, height, domain)); 456 width, height, domain));
454 else 457 else
455 { 458 {
456 /* ... then format specific methods ... */ 459 /* ... then format specific methods ... */
457 meths = decode_device_ii_format (Qnil, IMAGE_INSTANCE_WIDGET_TYPE (ii), 460 meths = decode_device_ii_format (Qnil, IMAGE_INSTANCE_WIDGET_TYPE (ii),
458 ERROR_ME_NOT); 461 ERROR_ME_NOT);
459 if (meths && HAS_IIFORMAT_METH_P (meths, layout)) 462 if (meths && HAS_IIFORMAT_METH_P (meths, layout))
460 IIFORMAT_METH (meths, layout, (image_instance, 463 return IIFORMAT_METH (meths, layout, (image_instance,
461 width, height, domain)); 464 width, height, domain));
462 } 465 }
466 return 1;
463 } 467 }
464 468
465 static void 469 static void
466 widget_validate (Lisp_Object instantiator) 470 widget_validate (Lisp_Object instantiator)
467 { 471 {
514 /* initialize_subwindow_image_instance (ii);*/ 518 /* initialize_subwindow_image_instance (ii);*/
515 IMAGE_INSTANCE_WIDGET_TYPE (ii) = type; 519 IMAGE_INSTANCE_WIDGET_TYPE (ii) = type;
516 IMAGE_INSTANCE_WIDGET_PROPS (ii) = Qnil; 520 IMAGE_INSTANCE_WIDGET_PROPS (ii) = Qnil;
517 SET_IMAGE_INSTANCE_WIDGET_FACE (ii, Qnil); 521 SET_IMAGE_INSTANCE_WIDGET_FACE (ii, Qnil);
518 IMAGE_INSTANCE_WIDGET_ITEMS (ii) = allocate_gui_item (); 522 IMAGE_INSTANCE_WIDGET_ITEMS (ii) = allocate_gui_item ();
523 IMAGE_INSTANCE_LAYOUT_CHILDREN (ii) = Qnil;
519 IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii) = Qnil; 524 IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii) = Qnil;
520 IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii) = Qnil; 525 IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii) = Qnil;
521 IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii) = Qnil; 526 IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii) = Qnil;
522 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 1; 527 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 1;
523 IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 1; 528 IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 1;
545 Lisp_Object desc = find_keyword_in_vector (instantiator, Q_descriptor); 550 Lisp_Object desc = find_keyword_in_vector (instantiator, Q_descriptor);
546 Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image); 551 Lisp_Object glyph = find_keyword_in_vector (instantiator, Q_image);
547 Lisp_Object props = find_keyword_in_vector (instantiator, Q_properties); 552 Lisp_Object props = find_keyword_in_vector (instantiator, Q_properties);
548 Lisp_Object items = find_keyword_in_vector (instantiator, Q_items); 553 Lisp_Object items = find_keyword_in_vector (instantiator, Q_items);
549 Lisp_Object orient = find_keyword_in_vector (instantiator, Q_orientation); 554 Lisp_Object orient = find_keyword_in_vector (instantiator, Q_orientation);
555 Lisp_Object mwidth = find_keyword_in_vector (instantiator, Q_margin_width);
550 int pw=0, ph=0, tw=0, th=0; 556 int pw=0, ph=0, tw=0, th=0;
551 557
552 /* this just does pixel type sizing */ 558 /* this just does pixel type sizing */
553 subwindow_instantiate (image_instance, instantiator, pointer_fg, pointer_bg, 559 subwindow_instantiate (image_instance, instantiator, pointer_fg, pointer_bg,
554 dest_mask, domain); 560 dest_mask, domain);
555 561
556 if (!(dest_mask & (IMAGE_WIDGET_MASK | IMAGE_LAYOUT_MASK))) 562 if (!(dest_mask & IMAGE_WIDGET_MASK))
557 incompatible_image_types (instantiator, dest_mask, 563 incompatible_image_types (instantiator, dest_mask, IMAGE_WIDGET_MASK);
558 IMAGE_WIDGET_MASK | IMAGE_LAYOUT_MASK);
559 564
560 initialize_widget_image_instance (ii, XVECTOR_DATA (instantiator)[0]); 565 initialize_widget_image_instance (ii, XVECTOR_DATA (instantiator)[0]);
561 566
562 IMAGE_INSTANCE_TYPE (ii) = IMAGE_WIDGET; 567 IMAGE_INSTANCE_TYPE (ii) = IMAGE_WIDGET;
563 IMAGE_INSTANCE_WIDGET_PROPS (ii) = props; 568 IMAGE_INSTANCE_WIDGET_PROPS (ii) = props;
564 569
565 /* retrieve the fg and bg colors */ 570 /* retrieve the fg and bg colors */
566 if (!NILP (face)) 571 if (!NILP (face))
567 SET_IMAGE_INSTANCE_WIDGET_FACE (ii, Fget_face (face)); 572 SET_IMAGE_INSTANCE_WIDGET_FACE (ii, Fget_face (face));
568 573
569 /* Do layout specific initialisation. This feels a bit tacky, but
570 the alternative is a myriad of different little functions. */
571 if (EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qlayout))
572 {
573 Lisp_Object rest, children = Qnil;
574 Lisp_Object border = find_keyword_in_vector (instantiator, Q_border);
575
576 if (NILP (orient))
577 {
578 IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) = LAYOUT_VERTICAL;
579 }
580 IMAGE_INSTANCE_TYPE (ii) = IMAGE_LAYOUT;
581
582 if (EQ (border, Qt))
583 {
584 IMAGE_INSTANCE_LAYOUT_BORDER (ii) = Qetched_in;
585 }
586 else if (GLYPHP (border))
587 {
588 /* We are going to be sneaky here and add the border text as
589 just another child, the layout and output routines don't know
590 this and will just display at the offsets we prescribe. */
591 Lisp_Object gii = glyph_image_instance (border, domain, ERROR_ME, 1);
592 /* make sure we are designated as the parent. */
593 XIMAGE_INSTANCE_PARENT (gii) = image_instance;
594 children = Fcons (gii, children);
595 IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_int (0);
596 }
597 else
598 {
599 IMAGE_INSTANCE_LAYOUT_BORDER (ii) = border;
600 }
601
602 /* Pick up the sub-widgets. */
603 LIST_LOOP (rest, items)
604 {
605 /* make sure the image is instantiated */
606 Lisp_Object gii = glyph_image_instance (XCAR (rest), domain, ERROR_ME, 1);
607 /* make sure we are designated as the parent. */
608 XIMAGE_INSTANCE_PARENT (gii) = image_instance;
609 children = Fcons (gii, children);
610 }
611 /* Make sure elements in the layout are in the order the
612 user expected. */
613 children = Fnreverse (children);
614 IMAGE_INSTANCE_LAYOUT_CHILDREN (ii) = children;
615 }
616 /* retrieve the gui item information. This is easy if we have been 574 /* retrieve the gui item information. This is easy if we have been
617 provided with a vector, more difficult if we have just been given 575 provided with a vector, more difficult if we have just been given
618 keywords */ 576 keywords */
619 else if (STRINGP (desc) || NILP (desc)) 577 if (STRINGP (desc) || NILP (desc))
620 { 578 {
621 /* big cheat - we rely on the fact that a gui item looks like an instantiator */ 579 /* big cheat - we rely on the fact that a gui item looks like an instantiator */
622 IMAGE_INSTANCE_WIDGET_ITEMS (ii) = 580 IMAGE_INSTANCE_WIDGET_ITEMS (ii) =
623 gui_parse_item_keywords_no_errors (instantiator); 581 gui_parse_item_keywords_no_errors (instantiator);
624 IMAGE_INSTANCE_WIDGET_TEXT (ii) = desc; 582 IMAGE_INSTANCE_WIDGET_TEXT (ii) = desc;
625 } 583 }
626 else 584 else
627 IMAGE_INSTANCE_WIDGET_ITEMS (ii) = 585 IMAGE_INSTANCE_WIDGET_ITEMS (ii) =
628 gui_parse_item_keywords_no_errors (desc); 586 gui_parse_item_keywords_no_errors (desc);
629 587
630 /* Pick up the orientation before we do our first layout. */ 588 /* Pick up the orientation before we do our first layout. */
631 if (EQ (orient, Qleft) || EQ (orient, Qright) || EQ (orient, Qvertical)) 589 if (EQ (orient, Qleft) || EQ (orient, Qright) || EQ (orient, Qvertical))
632 IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) = LAYOUT_VERTICAL; 590 IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) = LAYOUT_VERTICAL;
633 591
634 /* parse more gui items out of the properties */ 592 /* parse more gui items out of the properties */
635 if (!NILP (props) 593 if (!NILP (props)
636 && !EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qlayout)) 594 &&
595 !EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qlayout)
596 && !EQ (IMAGE_INSTANCE_WIDGET_TYPE (ii), Qnative_layout))
637 { 597 {
638 if (NILP (items)) 598 if (NILP (items))
639 { 599 {
640 items = Fplist_get (props, Q_items, Qnil); 600 items = Fplist_get (props, Q_items, Qnil);
641 } 601 }
707 ph = glyph_height (glyph, domain) + 2 * WIDGET_BORDER_HEIGHT; 667 ph = glyph_height (glyph, domain) + 2 * WIDGET_BORDER_HEIGHT;
708 IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0; 668 IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0;
709 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0; 669 IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0;
710 } 670 }
711 671
712 /* When we create the widgets the window system expects a valid 672 /* Pick up the margin width. */
713 size, so If we still don' t have sizes, call layout to pick them 673 if (!NILP (mwidth))
714 up. If query_geometry or layout relies on the widget being in 674 IMAGE_INSTANCE_MARGIN_WIDTH (ii) = XINT (mwidth);
715 existence then we are in catch 22. */ 675
716 image_instance_layout (image_instance, 676 /* Layout for the layout widget is premature at this point since the
717 pw ? pw : IMAGE_UNSPECIFIED_GEOMETRY, 677 children will not have been instantiated. We can't instantiate
718 ph ? ph : IMAGE_UNSPECIFIED_GEOMETRY, 678 them until the device instantiation method for the layout has
719 domain); 679 been executed. We do however want to record any specified
720 680 dimensions. */
681 if (pw) IMAGE_INSTANCE_WIDTH (ii) = pw;
682 if (ph) IMAGE_INSTANCE_HEIGHT (ii) = ph;
683 }
684
685 static void
686 widget_post_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
687 Lisp_Object domain)
688 {
721 #ifdef DEBUG_WIDGETS 689 #ifdef DEBUG_WIDGETS
722 debug_widget_instances++; 690 debug_widget_instances++;
723 stderr_out ("instantiated "); 691 stderr_out ("instantiated ");
724 debug_print (instantiator); 692 debug_print (instantiator);
725 stderr_out ("%d widgets instantiated\n", debug_widget_instances); 693 stderr_out ("%d widgets instantiated\n", debug_widget_instances);
876 844
877 845
878 /***************************************************************************** 846 /*****************************************************************************
879 * widget layout * 847 * widget layout *
880 *****************************************************************************/ 848 *****************************************************************************/
881 static int
882 layout_possible_dest_types (void)
883 {
884 return IMAGE_LAYOUT_MASK;
885 }
886
887 /* we need to convert things like glyphs to images, eval expressions 849 /* we need to convert things like glyphs to images, eval expressions
888 etc.*/ 850 etc.*/
889 static Lisp_Object 851 static Lisp_Object
890 layout_normalize (Lisp_Object inst, Lisp_Object console_type) 852 layout_normalize (Lisp_Object inst, Lisp_Object console_type)
891 { 853 {
907 if (VECTORP (border) || CONSP (border)) 869 if (VECTORP (border) || CONSP (border))
908 { 870 {
909 substitute_keyword_value (inst, Q_border, glyph_instantiator_to_glyph (border)); 871 substitute_keyword_value (inst, Q_border, glyph_instantiator_to_glyph (border));
910 } 872 }
911 return inst; 873 return inst;
874 }
875
876 static void
877 layout_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
878 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
879 int dest_mask, Lisp_Object domain)
880 {
881 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
882 Lisp_Object orient = find_keyword_in_vector (instantiator, Q_orientation);
883 Lisp_Object border = find_keyword_in_vector (instantiator, Q_border);
884
885 /* Do widget type instantiation first. */
886 widget_instantiate (image_instance, instantiator, pointer_fg, pointer_bg,
887 dest_mask, domain);
888
889 if (NILP (orient))
890 {
891 IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) = LAYOUT_VERTICAL;
892 }
893
894 if (EQ (border, Qt))
895 {
896 IMAGE_INSTANCE_LAYOUT_BORDER (ii) = Qetched_in;
897 }
898 else
899 {
900 IMAGE_INSTANCE_LAYOUT_BORDER (ii) = border;
901 }
902 /* We don't do the children yet as we might not have a containing
903 window. */
904 }
905
906 static void
907 layout_post_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
908 Lisp_Object domain)
909 {
910 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
911 Lisp_Object items = find_keyword_in_vector (instantiator, Q_items);
912 Lisp_Object rest, children = Qnil;
913
914 if (GLYPHP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)))
915 {
916 /* We are going to be sneaky here and add the border text as
917 just another child, the layout and output routines don't know
918 this and will just display at the offsets we prescribe. */
919 Lisp_Object gii = glyph_image_instance
920 (IMAGE_INSTANCE_LAYOUT_BORDER (ii),
921 image_instance, ERROR_ME, 1);
922
923 if (!IMAGE_INSTANCEP (gii))
924 return;
925 /* make sure we are designated as the parent. */
926 XIMAGE_INSTANCE_PARENT (gii) = image_instance;
927 children = Fcons (gii, children);
928 IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_int (0);
929 }
930
931 /* Pick up the sub-widgets. */
932 LIST_LOOP (rest, items)
933 {
934 /* make sure the image is instantiated */
935 Lisp_Object gii = glyph_image_instance (XCAR (rest),
936 image_instance, ERROR_ME, 1);
937 if (!IMAGE_INSTANCEP (gii))
938 return;
939 /* make sure we are designated as the parent. */
940 XIMAGE_INSTANCE_PARENT (gii) = image_instance;
941 children = Fcons (gii, children);
942 }
943 /* Make sure elements in the layout are in the order the
944 user expected. */
945 children = Fnreverse (children);
946 IMAGE_INSTANCE_LAYOUT_CHILDREN (ii) = children;
912 } 947 }
913 948
914 /* Layout widget. Sizing commentary: we have a number of problems that 949 /* Layout widget. Sizing commentary: we have a number of problems that
915 we would like to address. Some consider some of these more 950 we would like to address. Some consider some of these more
916 important than others. It used to be that size information was 951 important than others. It used to be that size information was
967 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1002 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
968 Lisp_Object items = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii), rest; 1003 Lisp_Object items = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii), rest;
969 int maxph = 0, maxpw = 0, nitems = 0, ph_adjust = 0; 1004 int maxph = 0, maxpw = 0, nitems = 0, ph_adjust = 0;
970 unsigned int gheight, gwidth; 1005 unsigned int gheight, gwidth;
971 1006
1007 /* If we are not initialized then we won't have any children. */
1008 if (!IMAGE_INSTANCE_INITIALIZED (ii))
1009 return;
1010
972 /* First just set up what we already have. */ 1011 /* First just set up what we already have. */
973 if (width) *width = IMAGE_INSTANCE_WIDTH (ii); 1012 if (width) *width = IMAGE_INSTANCE_WIDTH (ii);
974 if (height) *height = IMAGE_INSTANCE_HEIGHT (ii); 1013 if (height) *height = IMAGE_INSTANCE_HEIGHT (ii);
975 1014
976 /* If we are not allowed to dynamically size then return. */ 1015 /* If we are not allowed to dynamically size then return. */
1016 if (INTP (dynamic_width)) 1055 if (INTP (dynamic_width))
1017 *width = XINT (dynamic_width); 1056 *width = XINT (dynamic_width);
1018 } 1057 }
1019 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) 1058 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
1020 == LAYOUT_HORIZONTAL) 1059 == LAYOUT_HORIZONTAL)
1021 *width = maxpw + (nitems + 1) * WIDGET_BORDER_WIDTH * 2; 1060 *width = maxpw + ((nitems + 1) * WIDGET_BORDER_WIDTH +
1061 IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2;
1022 else 1062 else
1023 *width = maxpw + 2 * WIDGET_BORDER_WIDTH * 2; 1063 *width = maxpw + 2 * (WIDGET_BORDER_WIDTH * 2 +
1064 IMAGE_INSTANCE_MARGIN_WIDTH (ii));
1024 1065
1025 /* Work out vertical spacings. */ 1066 /* Work out vertical spacings. */
1026 if (!NILP (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii))) 1067 if (!NILP (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii)))
1027 { 1068 {
1028 Lisp_Object dynamic_height = 1069 Lisp_Object dynamic_height =
1030 if (INTP (dynamic_height)) 1071 if (INTP (dynamic_height))
1031 *height = XINT (dynamic_height); 1072 *height = XINT (dynamic_height);
1032 } 1073 }
1033 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) 1074 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
1034 == LAYOUT_VERTICAL) 1075 == LAYOUT_VERTICAL)
1035 *height = maxph + (nitems + 1) * WIDGET_BORDER_HEIGHT * 2 + ph_adjust; 1076 *height = maxph + ((nitems + 1) * WIDGET_BORDER_HEIGHT +
1077 IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2 + ph_adjust;
1036 else 1078 else
1037 *height = maxph + 2 * WIDGET_BORDER_HEIGHT * 2 + ph_adjust; 1079 *height = maxph + (2 * WIDGET_BORDER_HEIGHT +
1038 } 1080 IMAGE_INSTANCE_MARGIN_WIDTH (ii)) * 2 + ph_adjust;
1039 1081 }
1040 static void 1082
1083 int
1041 layout_layout (Lisp_Object image_instance, 1084 layout_layout (Lisp_Object image_instance,
1042 unsigned int width, unsigned int height, Lisp_Object domain) 1085 unsigned int width, unsigned int height, Lisp_Object domain)
1043 { 1086 {
1044 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); 1087 Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
1045 Lisp_Object rest; 1088 Lisp_Object rest;
1046 Lisp_Object items = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii); 1089 Lisp_Object items = IMAGE_INSTANCE_LAYOUT_CHILDREN (ii);
1047 int x, y, maxph = 0, maxpw = 0, nitems = 0, 1090 int x, y, maxph = 0, maxpw = 0, nitems = 0,
1048 horiz_spacing, vert_spacing, ph_adjust = 0; 1091 horiz_spacing, vert_spacing, ph_adjust = 0;
1049 unsigned int gheight, gwidth; 1092 unsigned int gheight, gwidth;
1050 1093
1094 /* If we are not initialized then we won't have any children. */
1095 if (!IMAGE_INSTANCE_INITIALIZED (ii))
1096 return 0;
1097
1051 /* Pick up the border text if we have one. */ 1098 /* Pick up the border text if we have one. */
1052 if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) 1099 if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)))
1053 { 1100 {
1054 Lisp_Object border = XCAR (items); 1101 Lisp_Object border = XCAR (items);
1055 items = XCDR (items); 1102 items = XCDR (items);
1093 horiz_spacing = WIDGET_BORDER_WIDTH * 2; 1140 horiz_spacing = WIDGET_BORDER_WIDTH * 2;
1094 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) 1141 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
1095 == LAYOUT_HORIZONTAL) 1142 == LAYOUT_HORIZONTAL)
1096 /* We have a larger area to display in so distribute the space 1143 /* We have a larger area to display in so distribute the space
1097 evenly. */ 1144 evenly. */
1098 horiz_spacing = (width - maxpw) / (nitems + 1); 1145 horiz_spacing = (width - (maxpw +
1146 IMAGE_INSTANCE_MARGIN_WIDTH (ii) * 2))
1147 / (nitems + 1);
1099 else 1148 else
1100 horiz_spacing = (width - maxpw) / 2; 1149 horiz_spacing = (width - maxpw) / 2
1150 - IMAGE_INSTANCE_MARGIN_WIDTH (ii);
1101 1151
1102 if (height < maxph) 1152 if (height < maxph)
1103 vert_spacing = WIDGET_BORDER_HEIGHT * 2; 1153 vert_spacing = WIDGET_BORDER_HEIGHT * 2;
1104 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) 1154 else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii)
1105 == LAYOUT_VERTICAL) 1155 == LAYOUT_VERTICAL)
1106 vert_spacing = (height - (maxph + ph_adjust)) / (nitems + 1); 1156 vert_spacing = (height - (maxph + ph_adjust +
1157 IMAGE_INSTANCE_MARGIN_WIDTH (ii) * 2))
1158 / (nitems + 1);
1107 else 1159 else
1108 vert_spacing = (height - (maxph + ph_adjust)) / 2; 1160 vert_spacing = (height - (maxph + ph_adjust)) / 2
1109 1161 - IMAGE_INSTANCE_MARGIN_WIDTH (ii);
1110 y = vert_spacing + ph_adjust; 1162
1111 x = horiz_spacing; 1163 y = vert_spacing + ph_adjust + IMAGE_INSTANCE_MARGIN_WIDTH (ii);
1164 x = horiz_spacing + IMAGE_INSTANCE_MARGIN_WIDTH (ii);
1112 1165
1113 /* Now flip through putting items where we want them, paying 1166 /* Now flip through putting items where we want them, paying
1114 attention to justification. Make sure we don't mess with the 1167 attention to justification. Make sure we don't mess with the
1115 border glyph. */ 1168 border glyph. */
1116 LIST_LOOP (rest, items) 1169 LIST_LOOP (rest, items)
1154 } 1207 }
1155 1208
1156 /* Now layout subwidgets if they require it. */ 1209 /* Now layout subwidgets if they require it. */
1157 image_instance_layout (glyph, gwidth, gheight, domain); 1210 image_instance_layout (glyph, gwidth, gheight, domain);
1158 } 1211 }
1212 return 1;
1213 }
1214
1215 /* Layout subwindows if they are real subwindows. */
1216 static int
1217 native_layout_layout (Lisp_Object image_instance,
1218 unsigned int width, unsigned int height,
1219 Lisp_Object domain)
1220 {
1221 Lisp_Image_Instance* ii = XIMAGE_INSTANCE (image_instance);
1222 Lisp_Object rest;
1223
1224 /* The first time this gets called, the layout will be only
1225 partially instantiated. The children get done in
1226 post_instantiate. */
1227 if (!IMAGE_INSTANCE_INITIALIZED (ii))
1228 return 0;
1229
1230 /* Defining this overrides the default layout_layout so we first have to call that to get
1231 suitable instances and values set up. */
1232 layout_layout (image_instance, width, height, domain);
1233
1234 LIST_LOOP (rest, IMAGE_INSTANCE_LAYOUT_CHILDREN (ii))
1235 {
1236 struct display_glyph_area dga;
1237 dga.xoffset = 0;
1238 dga.yoffset = 0;
1239 dga.width = IMAGE_INSTANCE_WIDTH (ii);
1240 dga.height = IMAGE_INSTANCE_HEIGHT (ii);
1241
1242 map_subwindow (XCAR (rest),
1243 IMAGE_INSTANCE_XOFFSET (ii),
1244 IMAGE_INSTANCE_YOFFSET (ii), &dga);
1245 }
1246 return 1;
1159 } 1247 }
1160 1248
1161 1249
1162 /************************************************************************/ 1250 /************************************************************************/
1163 /* initialization */ 1251 /* initialization */
1174 defkeyword (&Q_image, ":image"); 1262 defkeyword (&Q_image, ":image");
1175 defkeyword (&Q_text, ":text"); 1263 defkeyword (&Q_text, ":text");
1176 defkeyword (&Q_orientation, ":orientation"); 1264 defkeyword (&Q_orientation, ":orientation");
1177 defkeyword (&Q_justify, ":justify"); 1265 defkeyword (&Q_justify, ":justify");
1178 defkeyword (&Q_border, ":border"); 1266 defkeyword (&Q_border, ":border");
1267 defkeyword (&Q_margin_width, ":margin-width");
1179 1268
1180 defsymbol (&Qetched_in, "etched-in"); 1269 defsymbol (&Qetched_in, "etched-in");
1181 defsymbol (&Qetched_out, "etched-out"); 1270 defsymbol (&Qetched_out, "etched-out");
1182 defsymbol (&Qbevel_in, "bevel-in"); 1271 defsymbol (&Qbevel_in, "bevel-in");
1183 defsymbol (&Qbevel_out, "bevel-out"); 1272 defsymbol (&Qbevel_out, "bevel-out");
1184 defsymbol (&Qwidget_callback_current_channel, "widget-callback-current-channel");
1185 } 1273 }
1186 1274
1187 #define VALID_GUI_KEYWORDS(type) do { \ 1275 #define VALID_GUI_KEYWORDS(type) do { \
1188 IIFORMAT_VALID_NONCOPY_KEYWORD (type, Q_active, check_valid_anything); \ 1276 IIFORMAT_VALID_NONCOPY_KEYWORD (type, Q_active, check_valid_anything); \
1189 IIFORMAT_VALID_KEYWORD (type, Q_suffix, check_valid_anything); \ 1277 IIFORMAT_VALID_KEYWORD (type, Q_suffix, check_valid_anything); \
1223 { 1311 {
1224 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (button, "button"); 1312 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (button, "button");
1225 IIFORMAT_HAS_SHARED_METHOD (button, validate, widget); 1313 IIFORMAT_HAS_SHARED_METHOD (button, validate, widget);
1226 IIFORMAT_HAS_SHARED_METHOD (button, possible_dest_types, widget); 1314 IIFORMAT_HAS_SHARED_METHOD (button, possible_dest_types, widget);
1227 IIFORMAT_HAS_SHARED_METHOD (button, instantiate, widget); 1315 IIFORMAT_HAS_SHARED_METHOD (button, instantiate, widget);
1316 IIFORMAT_HAS_SHARED_METHOD (button, post_instantiate, widget);
1228 IIFORMAT_HAS_SHARED_METHOD (button, normalize, widget); 1317 IIFORMAT_HAS_SHARED_METHOD (button, normalize, widget);
1318 IIFORMAT_HAS_SHARED_METHOD (button, governing_domain, subwindow);
1229 IIFORMAT_HAS_METHOD (button, query_geometry); 1319 IIFORMAT_HAS_METHOD (button, query_geometry);
1230 IIFORMAT_VALID_KEYWORD (button, 1320 IIFORMAT_VALID_KEYWORD (button,
1231 Q_image, check_valid_glyph_or_instantiator); 1321 Q_image, check_valid_glyph_or_instantiator);
1232 VALID_WIDGET_KEYWORDS (button); 1322 VALID_WIDGET_KEYWORDS (button);
1233 VALID_GUI_KEYWORDS (button); 1323 VALID_GUI_KEYWORDS (button);
1237 { 1327 {
1238 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (edit_field, "edit-field"); 1328 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (edit_field, "edit-field");
1239 IIFORMAT_HAS_SHARED_METHOD (edit_field, validate, widget); 1329 IIFORMAT_HAS_SHARED_METHOD (edit_field, validate, widget);
1240 IIFORMAT_HAS_SHARED_METHOD (edit_field, possible_dest_types, widget); 1330 IIFORMAT_HAS_SHARED_METHOD (edit_field, possible_dest_types, widget);
1241 IIFORMAT_HAS_SHARED_METHOD (edit_field, instantiate, widget); 1331 IIFORMAT_HAS_SHARED_METHOD (edit_field, instantiate, widget);
1332 IIFORMAT_HAS_SHARED_METHOD (edit_field, post_instantiate, widget);
1333 IIFORMAT_HAS_SHARED_METHOD (edit_field, governing_domain, subwindow);
1242 VALID_WIDGET_KEYWORDS (edit_field); 1334 VALID_WIDGET_KEYWORDS (edit_field);
1243 VALID_GUI_KEYWORDS (edit_field); 1335 VALID_GUI_KEYWORDS (edit_field);
1244 } 1336 }
1245 1337
1246 static void image_instantiator_combo_box (void) 1338 static void image_instantiator_combo_box (void)
1247 { 1339 {
1248 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (combo_box, "combo-box"); 1340 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (combo_box, "combo-box");
1249 IIFORMAT_HAS_METHOD (combo_box, validate); 1341 IIFORMAT_HAS_METHOD (combo_box, validate);
1250 IIFORMAT_HAS_SHARED_METHOD (combo_box, possible_dest_types, widget); 1342 IIFORMAT_HAS_SHARED_METHOD (combo_box, possible_dest_types, widget);
1343 IIFORMAT_HAS_SHARED_METHOD (combo_box, governing_domain, subwindow);
1344
1251 VALID_GUI_KEYWORDS (combo_box); 1345 VALID_GUI_KEYWORDS (combo_box);
1252 1346
1253 IIFORMAT_VALID_KEYWORD (combo_box, Q_width, check_valid_int); 1347 IIFORMAT_VALID_KEYWORD (combo_box, Q_width, check_valid_int);
1254 IIFORMAT_VALID_KEYWORD (combo_box, Q_height, check_valid_int); 1348 IIFORMAT_VALID_KEYWORD (combo_box, Q_height, check_valid_int);
1255 IIFORMAT_VALID_KEYWORD (combo_box, Q_pixel_width, check_valid_int_or_function); 1349 IIFORMAT_VALID_KEYWORD (combo_box, Q_pixel_width, check_valid_int_or_function);
1261 { 1355 {
1262 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (scrollbar, "scrollbar"); 1356 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (scrollbar, "scrollbar");
1263 IIFORMAT_HAS_SHARED_METHOD (scrollbar, validate, widget); 1357 IIFORMAT_HAS_SHARED_METHOD (scrollbar, validate, widget);
1264 IIFORMAT_HAS_SHARED_METHOD (scrollbar, possible_dest_types, widget); 1358 IIFORMAT_HAS_SHARED_METHOD (scrollbar, possible_dest_types, widget);
1265 IIFORMAT_HAS_SHARED_METHOD (scrollbar, instantiate, widget); 1359 IIFORMAT_HAS_SHARED_METHOD (scrollbar, instantiate, widget);
1360 IIFORMAT_HAS_SHARED_METHOD (scrollbar, post_instantiate, widget);
1361 IIFORMAT_HAS_SHARED_METHOD (scrollbar, governing_domain, subwindow);
1266 VALID_GUI_KEYWORDS (scrollbar); 1362 VALID_GUI_KEYWORDS (scrollbar);
1267 1363
1268 IIFORMAT_VALID_KEYWORD (scrollbar, Q_pixel_width, check_valid_int_or_function); 1364 IIFORMAT_VALID_KEYWORD (scrollbar, Q_pixel_width, check_valid_int_or_function);
1269 IIFORMAT_VALID_KEYWORD (scrollbar, Q_pixel_height, check_valid_int_or_function); 1365 IIFORMAT_VALID_KEYWORD (scrollbar, Q_pixel_height, check_valid_int_or_function);
1270 IIFORMAT_VALID_KEYWORD (scrollbar, Q_face, check_valid_face); 1366 IIFORMAT_VALID_KEYWORD (scrollbar, Q_face, check_valid_face);
1274 { 1370 {
1275 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (progress_gauge, "progress-gauge"); 1371 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (progress_gauge, "progress-gauge");
1276 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, validate, widget); 1372 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, validate, widget);
1277 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, possible_dest_types, widget); 1373 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, possible_dest_types, widget);
1278 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, instantiate, widget); 1374 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, instantiate, widget);
1375 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, post_instantiate, widget);
1376 IIFORMAT_HAS_SHARED_METHOD (progress_gauge, governing_domain, subwindow);
1279 IIFORMAT_HAS_METHOD (progress_gauge, set_property); 1377 IIFORMAT_HAS_METHOD (progress_gauge, set_property);
1280 VALID_WIDGET_KEYWORDS (progress_gauge); 1378 VALID_WIDGET_KEYWORDS (progress_gauge);
1281 VALID_GUI_KEYWORDS (progress_gauge); 1379 VALID_GUI_KEYWORDS (progress_gauge);
1282 } 1380 }
1283 1381
1285 { 1383 {
1286 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (tree_view, "tree-view"); 1384 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (tree_view, "tree-view");
1287 IIFORMAT_HAS_SHARED_METHOD (tree_view, validate, combo_box); 1385 IIFORMAT_HAS_SHARED_METHOD (tree_view, validate, combo_box);
1288 IIFORMAT_HAS_SHARED_METHOD (tree_view, possible_dest_types, widget); 1386 IIFORMAT_HAS_SHARED_METHOD (tree_view, possible_dest_types, widget);
1289 IIFORMAT_HAS_SHARED_METHOD (tree_view, instantiate, widget); 1387 IIFORMAT_HAS_SHARED_METHOD (tree_view, instantiate, widget);
1388 IIFORMAT_HAS_SHARED_METHOD (tree_view, post_instantiate, widget);
1389 IIFORMAT_HAS_SHARED_METHOD (tree_view, governing_domain, subwindow);
1290 IIFORMAT_HAS_METHOD (tree_view, query_geometry); 1390 IIFORMAT_HAS_METHOD (tree_view, query_geometry);
1291 VALID_WIDGET_KEYWORDS (tree_view); 1391 VALID_WIDGET_KEYWORDS (tree_view);
1292 VALID_GUI_KEYWORDS (tree_view); 1392 VALID_GUI_KEYWORDS (tree_view);
1293 IIFORMAT_VALID_KEYWORD (tree_view, Q_properties, check_valid_item_list); 1393 IIFORMAT_VALID_KEYWORD (tree_view, Q_properties, check_valid_item_list);
1294 } 1394 }
1297 { 1397 {
1298 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (tab_control, "tab-control"); 1398 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (tab_control, "tab-control");
1299 IIFORMAT_HAS_SHARED_METHOD (tab_control, validate, combo_box); 1399 IIFORMAT_HAS_SHARED_METHOD (tab_control, validate, combo_box);
1300 IIFORMAT_HAS_SHARED_METHOD (tab_control, possible_dest_types, widget); 1400 IIFORMAT_HAS_SHARED_METHOD (tab_control, possible_dest_types, widget);
1301 IIFORMAT_HAS_SHARED_METHOD (tab_control, instantiate, widget); 1401 IIFORMAT_HAS_SHARED_METHOD (tab_control, instantiate, widget);
1402 IIFORMAT_HAS_SHARED_METHOD (tab_control, post_instantiate, widget);
1403 IIFORMAT_HAS_SHARED_METHOD (tab_control, governing_domain, subwindow);
1302 IIFORMAT_HAS_METHOD (tab_control, query_geometry); 1404 IIFORMAT_HAS_METHOD (tab_control, query_geometry);
1303 IIFORMAT_HAS_METHOD (tab_control, set_property); 1405 IIFORMAT_HAS_METHOD (tab_control, set_property);
1304 VALID_WIDGET_KEYWORDS (tab_control); 1406 VALID_WIDGET_KEYWORDS (tab_control);
1305 VALID_GUI_KEYWORDS (tab_control); 1407 VALID_GUI_KEYWORDS (tab_control);
1306 IIFORMAT_VALID_KEYWORD (tab_control, Q_orientation, check_valid_tab_orientation); 1408 IIFORMAT_VALID_KEYWORD (tab_control, Q_orientation, check_valid_tab_orientation);
1310 static void image_instantiator_labels (void) 1412 static void image_instantiator_labels (void)
1311 { 1413 {
1312 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (label, "label"); 1414 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (label, "label");
1313 IIFORMAT_HAS_SHARED_METHOD (label, possible_dest_types, widget); 1415 IIFORMAT_HAS_SHARED_METHOD (label, possible_dest_types, widget);
1314 IIFORMAT_HAS_SHARED_METHOD (label, instantiate, widget); 1416 IIFORMAT_HAS_SHARED_METHOD (label, instantiate, widget);
1417 IIFORMAT_HAS_SHARED_METHOD (label, post_instantiate, widget);
1418 IIFORMAT_HAS_SHARED_METHOD (label, governing_domain, subwindow);
1315 VALID_WIDGET_KEYWORDS (label); 1419 VALID_WIDGET_KEYWORDS (label);
1316 IIFORMAT_VALID_KEYWORD (label, Q_descriptor, check_valid_string); 1420 IIFORMAT_VALID_KEYWORD (label, Q_descriptor, check_valid_string);
1317 } 1421 }
1318 1422
1423 #define VALID_LAYOUT_KEYWORDS(layout) \
1424 VALID_WIDGET_KEYWORDS (layout); \
1425 IIFORMAT_VALID_KEYWORD (layout, Q_orientation, check_valid_orientation); \
1426 IIFORMAT_VALID_KEYWORD (layout, Q_justify, check_valid_justification); \
1427 IIFORMAT_VALID_KEYWORD (layout, Q_border, check_valid_border); \
1428 IIFORMAT_VALID_KEYWORD (layout, Q_margin_width, check_valid_int); \
1429 IIFORMAT_VALID_KEYWORD (layout, Q_items, \
1430 check_valid_glyph_or_instantiator_list)
1431
1319 static void image_instantiator_layout (void) 1432 static void image_instantiator_layout (void)
1320 { 1433 {
1321 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (layout, "layout"); 1434 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (layout, "layout");
1322 IIFORMAT_HAS_METHOD (layout, possible_dest_types); 1435 IIFORMAT_HAS_SHARED_METHOD (layout, possible_dest_types, widget);
1323 IIFORMAT_HAS_SHARED_METHOD (layout, instantiate, widget); 1436 IIFORMAT_HAS_METHOD (layout, instantiate);
1437 IIFORMAT_HAS_METHOD (layout, post_instantiate);
1438 IIFORMAT_HAS_SHARED_METHOD (layout, governing_domain, subwindow);
1324 IIFORMAT_HAS_METHOD (layout, normalize); 1439 IIFORMAT_HAS_METHOD (layout, normalize);
1325 IIFORMAT_HAS_METHOD (layout, query_geometry); 1440 IIFORMAT_HAS_METHOD (layout, query_geometry);
1326 IIFORMAT_HAS_METHOD (layout, layout); 1441 IIFORMAT_HAS_METHOD (layout, layout);
1327 VALID_WIDGET_KEYWORDS (layout); 1442
1328 IIFORMAT_VALID_KEYWORD (layout, Q_orientation, check_valid_orientation); 1443 VALID_GUI_KEYWORDS (layout);
1329 IIFORMAT_VALID_KEYWORD (layout, Q_justify, check_valid_justification); 1444 VALID_LAYOUT_KEYWORDS (layout);
1330 IIFORMAT_VALID_KEYWORD (layout, Q_border, check_valid_border); 1445 }
1331 IIFORMAT_VALID_KEYWORD (layout, Q_items, 1446
1332 check_valid_glyph_or_instantiator_list); 1447 static void image_instantiator_native_layout (void)
1448 {
1449 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT (native_layout, "native-layout");
1450 IIFORMAT_HAS_SHARED_METHOD (native_layout, possible_dest_types, widget);
1451 IIFORMAT_HAS_SHARED_METHOD (native_layout, instantiate, layout);
1452 IIFORMAT_HAS_SHARED_METHOD (native_layout, post_instantiate, layout);
1453 IIFORMAT_HAS_METHOD (native_layout, layout);
1454 IIFORMAT_HAS_SHARED_METHOD (native_layout, governing_domain, subwindow);
1455 IIFORMAT_HAS_SHARED_METHOD (native_layout, normalize, layout);
1456 IIFORMAT_HAS_SHARED_METHOD (native_layout, query_geometry, layout);
1457 IIFORMAT_HAS_SHARED_METHOD (native_layout, layout, layout);
1458
1459 VALID_GUI_KEYWORDS (native_layout);
1460 VALID_LAYOUT_KEYWORDS (native_layout);
1333 } 1461 }
1334 1462
1335 void 1463 void
1336 image_instantiator_format_create_glyphs_widget (void) 1464 image_instantiator_format_create_glyphs_widget (void)
1337 { 1465 {
1343 image_instantiator_progress_guage(); 1471 image_instantiator_progress_guage();
1344 image_instantiator_tree_view(); 1472 image_instantiator_tree_view();
1345 image_instantiator_tab_control(); 1473 image_instantiator_tab_control();
1346 image_instantiator_labels(); 1474 image_instantiator_labels();
1347 image_instantiator_layout(); 1475 image_instantiator_layout();
1476 image_instantiator_native_layout();
1348 } 1477 }
1349 1478
1350 void 1479 void
1351 reinit_vars_of_glyphs_widget (void) 1480 reinit_vars_of_glyphs_widget (void)
1352 { 1481 {
1357 1486
1358 void 1487 void
1359 vars_of_glyphs_widget (void) 1488 vars_of_glyphs_widget (void)
1360 { 1489 {
1361 reinit_vars_of_glyphs_widget (); 1490 reinit_vars_of_glyphs_widget ();
1362 1491 }
1363 DEFVAR_LISP ("widget-callback-current-channel", &Vwidget_callback_current_channel /*
1364 The domain that is current when a widget callback is invoked.
1365 This is invariably the frame that the widget is instantiated in.
1366 */);
1367 Vwidget_callback_current_channel = Qnil;
1368 }