cgit.sxemacs.org Git - packages/blob - xemacs-packages/jde/lisp/jde-widgets.el

   1 ;;; jde-widgets.el -- Custom-style widgets used by the JDE
   2 ;; $Revision: 1.26 $ $Date: 2004/06/03 02:21:13 $
   3
   4 ;; Author: Paul Kinnucan <paulk@mathworks.com>
   5 ;; Maintainer: Paul Kinnucan
   6 ;; Keywords: java, tools
   7
   8 ;; Copyright (C) 1997-2004 Paul Kinnucan.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Commentary:
  26
  27 ;; This is one of a set of packages that make up the
  28 ;; Java Development Environment (JDE) for Emacs. See the
  29 ;; JDE User's Guide for more information.
  30
  31 ;; The latest version of the JDE is available at
  32 ;; <URL:http://sunsite.auc.dk/jde/>
  33 ;; <URL:http://www.geocities.com/SiliconValley/Lakes/1506/>
  34
  35 ;; Please send any comments, bugs, or upgrade requests to
  36 ;; Paul Kinnucan at paulk@mathworks.com.
  37
  38 ;;; Code:
  39
  40 (require 'wid-edit)
  41 (require 'eieio)
  42 (require 'efc)
  43 (require 'jde-util)
  44 (jde-require 'tree-widget)
  45
  46
  47 ;; ----------------------------------------------------------------------
  48 ;; The Tree Widget Code:
  49
  50
  51 ;;; The `tree' Widget.
  52
  53 (define-widget 'jde-widget-tree-open-button 'item
  54   "Open node in `jde-tree' widget."
  55   :button-prefix "["
  56   :button-suffix "]"
  57   :tag "+"
  58   :action 'jde-widget-tree-open-button-callback
  59   :help-echo "Show subtree."
  60   :format "%[%t%]")
  61
  62 (defun jde-widget-tree-open-button-callback (widget &optional event)
  63   ;; Set parent state to open.
  64   (widget-value-set (widget-get widget :parent) t))
  65
  66 (define-widget 'jde-widget-tree-close-button 'item
  67   "Close node in `tree' widget."
  68   :button-prefix "["
  69   :button-suffix "]"
  70   :tag "-"
  71   :action 'jde-widget-tree-close-button-callback
  72   :help-echo "Hide subtree."
  73   :format "%[%t%]")
  74
  75 (defun jde-widget-tree-close-button-callback (widget &optional event)
  76   ;; Set parent state to closed.
  77   (let* ((parent (widget-get widget :parent))
  78         (entries (widget-get parent :args))
  79         (children (widget-get parent :children)))
  80     (while (and entries children)
  81       (widget-put (car entries) :value (widget-value (car children)))
  82       (setq entries (cdr entries)
  83             children (cdr children)))
  84     (widget-value-set parent nil)))
  85
  86 (define-widget 'jde-widget-tree 'default
  87   "A tree structure widget."
  88   :convert-widget 'widget-types-convert-widget
  89   :format "%v"
  90   :prefix ""
  91   :prefix-extra "   "
  92   :prefix-empty " |--- "
  93   :value-get 'widget-value-value-get
  94   :value-create 'jde-widget-tree-value-create-callback
  95   :value-delete 'widget-children-value-delete)
  96
  97 (defun jde-widget-tree-value-create-callback (widget)
  98   ;; Insert all values
  99   (let ((open (widget-value widget))
 100         (tag (widget-get widget :tag))
 101         (entries (widget-get widget :args))
 102         children buttons)
 103     (cond ((null entries)
 104            ;; Empty node.
 105            (insert (widget-get widget :prefix-empty) tag "\n"))
 106           (open
 107            ;; Open node.
 108            (push
 109             (widget-create-child-and-convert widget 'jde-widget-tree-close-button)
 110                 buttons)
 111            (insert "-\\ " tag "\n")
 112            (let ((prefix (concat (widget-get widget :prefix)
 113                                 (widget-get widget :prefix-extra)))
 114                 entry)
 115              (while entries
 116                (setq entry (car entries)
 117                      entries (cdr entries))
 118                (insert prefix)
 119                (push (if entries
 120                         (widget-create-child-and-convert widget entry
 121                                                           :prefix prefix
 122                                                           :prefix-extra " | ")
 123                        ;; Last entry uses a different prefix.
 124                        (widget-create-child-and-convert
 125                         widget entry
 126                         :prefix prefix
 127                         :prefix-empty " `--- "))
 128                      children))))
 129           (t
 130            ;; Closed node.
 131            (push (widget-create-child-and-convert widget 'jde-widget-tree-open-button)
 132                 buttons)
 133            (insert "-- " tag "\n")))
 134     (widget-put widget :children children)
 135     (widget-put widget :buttons buttons)))
 136
 137 ;;----------------------------------------------------------------------
 138 ;; Eval this to create a small tree.
 139
 140 (defun test-tree ()
 141   (interactive)
 142   (switch-to-buffer "*Tree Example*")
 143   (kill-all-local-variables)
 144   ;; (make-local-variable 'widget-example-repeat)
 145   (let ((inhibit-read-only t))
 146     (erase-buffer))
 147   (let ((all (overlay-lists)))
 148     (mapcar 'delete-overlay (car all))    (mapcar 'delete-overlay (cdr all)))
 149
 150   (widget-insert "Test tree widget. \n\n")
 151
 152 ;   (setq tree (widget-create 'tree
 153 ;                       :tag "Foo"
 154 ;                       '(tree :tag "First")
 155 ;                       '(tree :tag "Second"
 156 ;                              :value nil
 157 ;                              (tree :tag "Nested"))
 158 ;                       '(tree :tag "Third")))
 159
 160   (setq tree (widget-create 'jde-widget-tree
 161                   :tag "<test.Foo:139>"
 162                   '(jde-widget-tree :tag "n  int  0")
 163                   ;; '(jde-widget-tree :tag '(jde-widget-tree :tag "n  int  0"))
 164                   '(jde-widget-tree :tag "a  double 5.5")
 165                   '(jde-widget-tree :tag "s  S      <test.S:145>"
 166                          (jde-widget-tree :tag "b   boolean  true"))))
 167
 168 ;   (let*  ((threads
 169 ;         (list
 170 ;          (list "ThreadGroup" 189 "system"
 171 ;                (list
 172 ;                 (list "Thread" 190 "Signal dispatcher" "runnable" "suspended by debugger")
 173 ;                 (list "Thread" 191 "Reference Handler" "waiting" "suspended by debugger")
 174 ;                 (list "Thread" 192 "Finalizer" "waiting" "suspended by debugger")))
 175 ;          (list "ThreadGroup" 193 "main"
 176 ;                (list
 177 ;                 (list "Thread" 1 "main" "runnable" "suspended at breakpoint"))
 178 ;                nil)))
 179 ;        (tree (jde-dbs-map-threads-to-tree threads)))
 180
 181
 182 ;  (apply 'widget-create tree))
 183
 184   (use-local-map widget-keymap)
 185   (widget-setup))
 186
 187
 188
 189 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 190 ;;                                                                            ;;
 191 ;; Dynamic tree widget                                                        ;;
 192 ;;                                                                            ;;
 193 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 194
 195 (define-widget 'jde-widget-dtree 'default
 196   "A widget whose nodes are generated on demand.
 197 The first time the user expands the tree, the tree invokes a function that
 198 generates the nodes. The tree then caches the nodes.
 199 Thereafter, the node uses the cached nodes when the
 200 user closes and then reopens the tree. Use the syntax
 201 (widget-create 'jde-widget-dtree :tag NAME :node-fcn NODE-FUNCTION)
 202 to create the widget where NAME is the tree name and NODE-FUNCTION
 203 is a function that takes one argument, the tree itself, and
 204 returns a list of widgets that are the nodes of the expanded
 205 tree."
 206   :format "%v"
 207   :prefix-extra "    "
 208   :value-get 'widget-value-value-get
 209   :value-create 'jde-widget-dtree-create-callback
 210   :value-delete 'widget-children-value-delete
 211   :has-nodes t)
 212
 213 (defun jde-widget-dtree-create-callback (widget)
 214   (let ((open (widget-value widget))
 215         (tag (widget-get widget :tag))
 216         children buttons)
 217     (cond
 218      (open
 219       (push (widget-create-child-and-convert widget 'jde-widget-tree-close-button)
 220                 buttons)
 221       (insert "-\\ " tag "\n")
 222       (let ((prefix (concat (widget-get widget :prefix)
 223                                 (widget-get widget :prefix-extra)))
 224             (nodes (widget-get widget :nodes))
 225             node)
 226
 227         (when (and (widget-get widget :has-nodes)
 228                    (not nodes))
 229           (setq nodes
 230                 (funcall (widget-get widget :node-fcn) widget))
 231           (if nodes
 232               (widget-put widget :nodes nodes)
 233             (widget-put widget :has-nodes nil)))
 234
 235         (while nodes
 236           (setq node (car nodes)
 237                 nodes (cdr nodes))
 238           (insert prefix)
 239           (push
 240            (if nodes
 241                (widget-create-child-and-convert widget node
 242                                                 :prefix prefix
 243                                                 :prefix-extra " | ")
 244              (widget-create-child-and-convert
 245               widget node
 246               :prefix prefix
 247               :prefix-empty " `--- "))
 248            children))))
 249      (t
 250       ;; Closed node.
 251       (push (widget-create-child-and-convert widget 'jde-widget-tree-open-button)
 252             buttons)
 253       (insert "-- " tag "\n")))
 254     (widget-put widget :children children)
 255     (widget-put widget :buttons buttons)))
 256
 257
 258 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 259 ;;                                                                            ;;
 260 ;; Java object widget                                                         ;;
 261 ;;                                                                            ;;
 262 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 263
 264 (defun jde-test-get-fields (process object-id)
 265   (list
 266    (cons (list "sum" "double") (list "double" 0.0))
 267    (cons (list "r" "int") (list "int" 1))
 268    (cons (list "z" "java.lang.String") (list "java.lang.String" 229 nil))
 269    (cons (list "B" "double[]") (list "double[]" 228 nil))
 270    (cons (list "A" "double[][]") (list "double[][]" 227 nil))
 271    (cons (list "args" "java.lang.String[]") (list "java.lang.String[]" 226 nil))))
 272
 273 (defun jde-widget-java-var-to-tree (process var)
 274   (let* ((var-name (oref var name))
 275          (var-type (oref var jtype))
 276          (var-value (oref var value))
 277          (var-tag (format "%s %s" var-type var-name)))
 278     (cond
 279      ((typep var-value 'jde-dbs-java-udci)
 280       (setq var-tag (format "%s [id: %d]" var-tag (oref var-value :id)))
 281       (if (string= (oref var-value :jtype) "java.lang.String")
 282           (let* ((cmd (jde-dbs-get-string
 283                        "get string"
 284                        :process process
 285                        :object-id (oref var-value id)))
 286                  (str-val (jde-dbs-cmd-exec cmd)))
 287             (list 'tree-widget
 288                   :tag var-tag
 289                   :node-name var-tag
 290                   :open (jde-dbo-locals-open-p var-tag)
 291                   :value t
 292                   (list 'tree-widget :tag str-val)))
 293         (list 'jde-widget-java-obj
 294               :tag var-tag
 295               :node-name var-tag
 296               :open (jde-dbo-locals-open-p var-tag)
 297               :process process
 298               :object-id (oref var-value :id))))
 299      ((typep var-value 'jde-dbs-java-array)
 300       (setq var-tag (format "%s [id: %d]" var-tag (oref var-value :id)))
 301       (list 'jde-widget-java-array
 302             :tag var-tag
 303             :node-name var-tag
 304             :open (jde-dbo-locals-open-p var-tag)
 305             :process process :object var-value))
 306      ((typep var-value 'jde-dbs-java-primitive)
 307       (list 'tree-widget
 308             :tag var-tag
 309             :node-name var-tag
 310             :open (jde-dbo-locals-open-p var-tag)
 311             :value t
 312             (list 'tree-widget
 313                   :tag (format "%s" (oref var-value value)))))
 314      ((typep var-value 'jde-dbs-java-null)
 315       (list 'tree-widget
 316             :tag var-tag
 317             :node-name var-tag
 318             :open (jde-dbo-locals-open-p var-tag)
 319             :value t
 320             (list 'tree-widget :tag "null")))
 321      (t
 322       (error "Unidentified type of local variable: %s" var-tag)))))
 323
 324 (defun jde-widget-java-obj-get-fields (obj-widget)
 325   (if (widget-get obj-widget :args)
 326       (widget-get obj-widget :args)
 327     (let* ((process (widget-get obj-widget :process))
 328            (object-id (widget-get obj-widget :object-id))
 329            (cmd
 330             (jde-dbs-get-object
 331              (format "get_object %d" object-id)
 332              :process process
 333              :object-id object-id))
 334            (object
 335             (jde-dbs-cmd-exec cmd))
 336            (fields (oref object fields))
 337            field
 338            nodes)
 339       (while fields
 340         (setq field (car fields) fields (cdr fields))
 341         (setq field (cdr field))
 342         (push
 343          (jde-widget-java-var-to-tree process field)
 344          nodes))
 345       nodes)))
 346
 347 (define-widget 'jde-widget-java-obj 'tree-widget
 348   "A widget that represents a Java object.
 349 This widget is essentially a tree node whose entries are the fields
 350 of the corresponding object. The first time the user expands the node,
 351 the node retrieves the fields of the object from the debugger and
 352 caches them. Thereafter, the node uses the cached values when the
 353 user closes and then reopens the node. Use the syntax
 354 (widget-create 'jde-widget-java-obj
 355 :tag NAME :process PROCESS :object-id OBJ-ID) to create the widget where
 356 NAME is the object's name, PROCESS is the process in which
 357 the object exists, and  ID is the debugger id for the object."
 358   :dynargs 'jde-widget-java-obj-get-fields
 359   :has-children t)
 360
 361
 362 (defun jde-widget-java-array-element-to-tree (process element index)
 363   (cond
 364      ((typep element 'jde-dbs-java-udci)
 365       (if (string= (oref element :jtype) "java.lang.String")
 366           (let* ((cmd (jde-dbs-get-string
 367                        "get string"
 368                        :process process
 369                        :object-id (oref element id)))
 370                  (str-val (jde-dbs-cmd-exec cmd)))
 371             (list 'tree-widget
 372                   :tag (format "[%d] %s" index str-val)
 373                   :node-name (format "[%d] %s" index str-val)
 374                   :open (jde-dbo-locals-open-p (format "[%d] %s" index str-val))
 375                   ))
 376         (list 'jde-widget-java-obj
 377               :tag (format "[%d] %s" index (oref element jtype))
 378               :node-name (format "[%d] %s" index (oref element jtype))
 379               :open (jde-dbo-locals-open-p (format "[%d] %s" index (oref element jtype)))
 380               :process process
 381               :object-id (oref element id))))
 382      ((typep element 'jde-dbs-java-array)
 383       (list 'jde-widget-java-array
 384             :tag (format "[%d] %s" index (oref element jtype))
 385             :node-name (format "[%d] %s" index (oref element jtype))
 386             :open (jde-dbo-locals-open-p (format "[%d] %s" index (oref element jtype)))
 387             :process process
 388             :object element))
 389      ((typep element 'jde-dbs-java-primitive)
 390       (list 'tree-widget :tag (format "[%d] %s"  index (oref element value))))
 391      ((typep element 'jde-dbs-java-null)
 392       (list 'tree-widget :tag (format "[%d] null" index)))
 393      (t
 394       (error "Unidentified type of object: <%s|%s>" (oref element jtype)
 395              (oref element id)))))
 396
 397 (defun jde-widget-java-array-get-elements (array-widget)
 398   (if (widget-get array-widget :args)
 399       (widget-get array-widget :args)
 400     (let* ((process (widget-get array-widget :process))
 401            (array (widget-get array-widget :object))
 402            cmd array-length)
 403
 404       (setq cmd
 405             (jde-dbs-get-array
 406              (format "get_array_length %d" (oref array id))
 407              :process process
 408              :array array))
 409       (jde-dbs-cmd-exec cmd)
 410
 411       (setq array-length
 412             (if (slot-boundp array 'length)
 413                 (oref array length)
 414               0))
 415
 416       (when (> array-length 0)
 417         (setq cmd
 418               (jde-dbs-get-array
 419                (format "get_array_elements %d" (oref array id))
 420                :process process
 421                :array array
 422                :index 0
 423                :length array-length))
 424         (jde-dbs-cmd-exec cmd)
 425         (let ((elements (oref array elements))
 426               element
 427               nodes
 428               (index 0))
 429           (while elements
 430             (setq element (car elements) elements (cdr elements))
 431             (setq nodes
 432                   (append nodes
 433                           (list (jde-widget-java-array-element-to-tree process element index))))
 434             (setq index (1+ index)))
 435           nodes)))))
 436
 437 (define-widget 'jde-widget-java-array 'tree-widget
 438   "A widget that represents a Java array. Clicking on the widget's
 439 expand button causes the widget to display the values of the array."
 440   :dynargs 'jde-widget-java-array-get-elements
 441   :has-children t)
 442
 443 (defun test-obj ()
 444   (interactive)
 445   (switch-to-buffer "*Java Object Example*")
 446   (kill-all-local-variables)
 447   ;; (make-local-variable 'widget-example-repeat)
 448   (let ((inhibit-read-only t))
 449     (erase-buffer))
 450   (let ((all (overlay-lists)))
 451     (mapcar 'delete-overlay (car all))    (mapcar 'delete-overlay (cdr all)))
 452
 453   (widget-insert "Test object tree. \n\n")
 454
 455   (widget-create 'jde-widget-java-obj :tag "jmath.System s"   :process "process" :object-id 1)
 456   (widget-create 'jde-widget-java-obj :tag "java.awt.Frame frame1" :process "process" :object-id 1)
 457
 458   (use-local-map widget-keymap)
 459   (widget-setup))
 460
 461
 462
 463 ;; ----------------------------------------------------------------------
 464 ;; Option Tree Widget
 465
 466 (defun jde-widget-option-tree-open-button-callback (widget &optional event)
 467   ;; Set parent state to open.
 468   (widget-value-set (widget-get widget :parent) t)
 469   (widget-setup))
 470
 471 (define-widget 'jde-widget-option-tree-open-button 'item
 472   "Button to open an option tree."
 473   :button-prefix "["
 474   :button-suffix "]"
 475   :tag "+"
 476   :action 'jde-widget-option-tree-open-button-callback
 477   :help-echo "Show option tree."
 478   :format "%[%t%]")
 479
 480 (define-widget 'jde-widget-option-tree-close-button 'item
 481   "Close node in `jde-widget-option-tree' widget."
 482   :button-prefix "["
 483   :button-suffix "]"
 484   :tag "-"
 485   :action 'jde-widget-option-tree-close-button-callback
 486   :help-echo "Hide panel."
 487   :format "%[%t%]")
 488
 489 (defun jde-widget-option-tree-close-button-callback (widget &optional event)
 490   ;; Set parent state to closed.
 491   (let* ((parent (widget-get widget :parent))
 492         (entries (widget-get parent :args))
 493         (group (car (widget-get parent :children)))
 494         (children (widget-get group :children)))
 495     ;; Get values entered by user from children and
 496     ;; insert them in the corresponding widget definitions
 497     ;; so that they appear the next time the user expands
 498     ;; the tree.
 499     (while (and entries children)
 500       (widget-put (car entries) :value (widget-value (car children)))
 501       (setq entries (cdr entries)
 502             children (cdr children)))
 503     (widget-value-set parent nil)))
 504
 505 (defun jde-widget-option-tree-value-create-callback (widget)
 506   (let ((open-widget-p (widget-value widget))
 507         (tag (widget-get widget :tag))
 508         (entries (widget-get widget :args))
 509         entry children buttons)
 510     (cond (open-widget-p
 511            ;; Wrap widgets in this tree in a group widget
 512            ;; to ensure proper formatting.
 513            (let ((group-type
 514                   (list 'group :args entries))
 515                  group-widget)
 516            (push
 517             (widget-create-child-and-convert
 518              widget
 519              'jde-widget-option-tree-close-button)
 520                 buttons)
 521            (insert "-\\ " tag "\n")
 522            (push (widget-create-child-and-convert widget group-type) children)))
 523           (t
 524            (push (widget-create 'jde-widget-option-tree-open-button
 525                           :parent widget)
 526                  buttons)
 527            (insert "-- " tag "\n")))
 528     (widget-put widget :children children)
 529     (widget-put widget :buttons buttons)))
 530
 531
 532 (define-widget 'jde-widget-option-tree 'default
 533   "A panel containing widgets."
 534   :convert-widget 'widget-types-convert-widget
 535   :format "%v"
 536   :value-get 'widget-value-value-get
 537   :value-create 'jde-widget-option-tree-value-create-callback
 538   :value-delete 'widget-children-value-delete)
 539
 540
 541 (defun test-option-tree ()
 542   (interactive)
 543   (switch-to-buffer "*Panel Example*")
 544   (kill-all-local-variables)
 545   (let ((inhibit-read-only t))
 546     (erase-buffer))
 547   (let ((all (overlay-lists)))
 548     (mapcar 'delete-overlay (car all))
 549     (mapcar 'delete-overlay (cdr all)))
 550
 551   (widget-insert "Test panel widget. \n\n")
 552
 553   (let ((panel (widget-create
 554                 'jde-widget-option-tree
 555                 :tag "Compile Options"
 556                 '(cons :tag "Debugger Options"
 557                    (radio-button-choice :format "%t \n%v"
 558                                         :tag "Debugger "
 559                                         (const "JDEbug")
 560                                         (const "jdb")
 561                                         (const "oldjdb")
 562                                         (const "Other"))
 563                    (cons :tag "Other Debugger Info"
 564                          (string :tag "Path")
 565                          (radio-button-choice :format "%t \n%v"
 566                                               :tag "Type "
 567                                               (const "Executable")
 568                                               (const "Class"))))
 569                   '(repeat (string :tag "Path"))
 570                   '(editable-field :tag "classpath"
 571                                   :format "  %t:  %v\n  %h \n\n"
 572                                   :size 40
 573                                   :doc "Name of project.")
 574                   '(editable-field :tag "compiler"
 575                                   :format "  %t:  %v\n  %h \n\n"
 576                                   :size 40
 577                                   :doc "Name of project.")
 578                   '(jde-widget-option-tree :tag "Debugger Options"
 579                                            (repeat (string :tag "Path"))))))
 580     (use-local-map widget-keymap)
 581     (widget-setup)))
 582
 583
 584
 585 (provide 'jde-widgets)
 586
 587 ;; $Log: jde-widgets.el,v $
 588 ;; Revision 1.26  2004/06/03 02:21:13  paulk
 589 ;; jde-require tree-widget.
 590 ;;
 591 ;; Revision 1.25  2003/01/12 23:34:51  jslopez
 592 ;; Small, patch to reduce the amount of cases that cause infinite recursion.
 593 ;;
 594 ;; Revision 1.24  2001/12/04 05:27:26  paulk
 595 ;; Moved dialog classes to the efc (Emacs Foundation Classes) package.
 596 ;;
 597 ;; Revision 1.23  2001/11/29 11:41:18  paulk
 598 ;; Option dialog now positions cursor over OK button.
 599 ;;
 600 ;; Revision 1.22  2001/11/28 16:50:28  jslopez
 601 ;; Fixes bug, that would not keep the state
 602 ;; of nodes created by jde-widget-java-array-element-to-tree.
 603 ;;
 604 ;; Revision 1.21  2001/11/28 08:38:02  paulk
 605 ;; Added note about fix for Emacs 21.1 bug.
 606 ;;
 607 ;; Revision 1.20  2001/11/27 21:04:05  jslopez
 608 ;; Modifies jde-widget-java-var-to-tree to keep nodes the states of nodes.(open/close)
 609 ;;
 610 ;; Revision 1.19  2001/11/24 15:23:11  paulk
 611 ;; The jde-option-dialog versions of jde-dialog-ok and jde-dialog-cancel
 612 ;; now delete the other window ony if the current version of Emacs is not
 613 ;; XEmacs and is less than major version 21.
 614 ;;
 615 ;; Revision 1.18  2001/11/24 07:31:56  paulk
 616 ;; The jde-option-dialog version of jde-dialog-ok now deletes the other windows,
 617 ;; if the current version of Emacs is not 21.1.
 618 ;;
 619 ;; Revision 1.17  2001/11/24 07:23:54  paulk
 620 ;; Changed the jde-dialog-ok method of jde-option-dialog to not delete
 621 ;; other windows. This is necessary to avoid a bug in the Emacs 21.1.1
 622 ;; version of exit-recursive-edit. This line should be restored when
 623 ;; the bug is fixed.
 624 ;;
 625 ;; Revision 1.16  2001/10/26 06:36:07  paulk
 626 ;; Changed jde-option-dialog to use recursive-edit mode to emulate a
 627 ;; modal dialog. Now the show dialog method enters recursive edit mode
 628 ;; thereby suspending the currently executing command until the user
 629 ;; selects the OK or Cancel button on the dialog. Selecting the OK button
 630 ;; on the dialog causes the dialog to update its :selection field to the
 631 ;; option chosen by the user. Selecting the Cancel button sets the
 632 ;; :selection field to nil.
 633 ;;
 634 ;; Revision 1.15  2001/08/09 03:37:11  paulk
 635 ;; Fixed error caused by missing :documentatation keyword in jde-option-dialog. Thanks to David Ponce.
 636 ;;
 637 ;; Revision 1.14  2001/08/07 05:31:26  paulk
 638 ;; Added ok-action-args field to jde-option-dialog.
 639 ;;
 640 ;; Revision 1.13  2001/07/31 05:11:52  paulk
 641 ;; ReleaseNotes.txt
 642 ;;
 643 ;; Revision 1.12  2001/05/21 06:44:29  paulk
 644 ;; Added jde-option-dialog class.
 645 ;;
 646 ;; Revision 1.11  2001/04/19 04:37:14  paulk
 647 ;; Converted array and object trees to derive from David Ponce's tree widget.
 648 ;;
 649 ;; Revision 1.10  2001/02/16 04:38:52  paulk
 650 ;; Added (require 'cl) to enable batch compile.
 651 ;;
 652 ;; Revision 1.9  2000/12/18 05:22:46  paulk
 653 ;; *** empty log message ***
 654 ;;
 655 ;; Revision 1.8  2000/11/27 06:15:02  paulk
 656 ;; Added an experimental jde-widget-option-tree widget.
 657 ;;
 658 ;; Revision 1.7  2000/08/31 05:22:17  paulk
 659 ;; Fixed bug on XEmacs where the Cancel button overwrote the OK button in the standard dialog class.
 660 ;;
 661 ;; Revision 1.6  2000/02/01 04:11:57  paulk
 662 ;; ReleaseNotes.txt
 663 ;;
 664 ;; Revision 1.5  2000/01/17 09:36:41  paulk
 665 ;; Implemented array and object inspectors.
 666 ;;
 667 ;; Revision 1.4  2000/01/15 08:05:10  paulk
 668 ;; Implemented dynamic tree widget.
 669 ;;
 670 ;; Revision 1.3  1999/11/16 05:58:18  paulk
 671 ;; Added trace method commands and skeletons for trace class and cancel
 672 ;; trace commands.
 673 ;;
 674 ;; Revision 1.2  1999/10/13 06:19:57  paulk
 675 ;; Add JDEBug->Threads->Show Threads command
 676 ;;
 677 ;; Revision 1.1  1999/09/28 04:39:42  paulk
 678 ;; Initial revision.
 679 ;;
 680
 681 ;; End of jde-widgets.el