WO1998042144A2 - Apparatus and method for monitoring event queue operations with pluggable event queues - Google Patents
Apparatus and method for monitoring event queue operations with pluggable event queues Download PDFInfo
- Publication number
- WO1998042144A2 WO1998042144A2 PCT/US1998/004100 US9804100W WO9842144A2 WO 1998042144 A2 WO1998042144 A2 WO 1998042144A2 US 9804100 W US9804100 W US 9804100W WO 9842144 A2 WO9842144 A2 WO 9842144A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- event queue
- instructions
- queue module
- messages
- customized
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/542—Event management; Broadcasting; Multicasting; Notifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/542—Intercept
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/543—Local
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/545—Gui
Definitions
- This invention relates generally to event queues used between graphical user interfaces and application programs. More particularly, this invention relates to pluggable event queues that software developers can use for monitoring the operations of event queues, while not affecting the operation of the event queues or otherwise modifying source code associated with the event queues.
- FIG. 1 illustrates a software event queue environment 20 in accordance with the prior art.
- the environment 20 includes a graphical user interface (GUI) 22 which supports a first application window 24 A and a second application window 24B.
- GUI graphical user interface
- the first application window 24A may be for a word processor application program
- the second application window 24B may be for a spread sheet application program.
- a user When a user performs an operation on an application window 24, such as clicking on an object or resizing a window, messages are generated that describe the operation that was performed.
- the messages are sent to an event queue 28, as constructed with event queue code 27.
- Fig. 1 illustrates that the first application window 24A sends a first set of messages to a first event queue 28A, while the second application window 24N sends a second set of messages to a second event queue 28N.
- Each event queue operates as a buffer between its corresponding application window 24 and application program 30.
- the event queue 28 A operates as a buffer between the application window 24A and the application program 30 A
- the event queue 28N operates as a buffer between the application window 24N and the application program 3 ON.
- the computer 40 includes a central processing unit (CPU) 42 that communicates with a set of input/output devices 44 over a system bus 46.
- the input/output devices 44 include a keyboard, mouse, computer monitor, printer, etc.
- the computer monitor is used to display the GUI 22.
- the system bus 46 is also connected to a memory 48.
- the memory 48 stores a number of programs and data associated with the system of Fig. 1.
- the memory 48 stores operating system code 50 and GUI code 32, which is used to generate the GUI 22.
- event queue code 27 Associated with the GUI code 32 is event queue code 27, which is used to generate the event queues 28A-28N.
- the memory 48 stores a number of application programs 30A-30N.
- the set of event queues 28A-28N constitutes a fixed and proprietary event queue implementation 26.
- the developer of the GUI 22 defines the event queue code 34 that is used to form the event queue implementation 26.
- This code is typically fixed and proprietary, meaning that its implementation is not modifiable so as to allow programmers to add code to extend the functionality of the event queue implementation 26 at runtime. Since it is impossible to change the operation of prior art event queue implementations, developers cannot create specialized event queues for debugging, tracing, and event recording operations.
- a method of monitoring event queue operations includes the step of responding to a set of run-time messages resulting from an operation performed with a graphical user interface.
- the set of messages is routed to a customized event queue module for processing.
- the information generated by the customized event queue module can be used for debugging, tracing, and event recording.
- the customized event queue module operates without altering the operation of the event queue.
- embodiments of the invention can be used without altering proprietary software defining the operation of the event queue.
- embodiments of the invention can be operated as pluggable add-ons to existing event queue environments.
- embodiments of the invention can be easily loaded by creating a text message in a properties file.
- FIG. 1 illustrates a software event queue environment in accordance with the prior art.
- FIG. 2 illustrates a computer apparatus used to implement the software event queue environment of Fig. 1.
- FIG. 3 illustrates a software event queue environment with pluggable event queues in accordance with an embodiment of the invention.
- FIG. 4 illustrates a computer apparatus used to implement the software event queue environment of Fig. 3.
- FIG. 3 illustrates a modular software event queue environment 60 in accordance with an embodiment of the invention.
- the environment 60 includes a GUI 62 supporting a first application window 64A and a second application window 64N.
- an operation performed with the GUI 62 e.g., pressing a button or resizing a window
- the set of messages is passed to an event queue 72, which operates as a buffer for its respective application program 30.
- the event queue 72A operates as a buffer between application window 64A and application program 30A
- event queue 72N operates as a buffer between application window 64N and application program 3 ON.
- customized or pluggable event queue code 70 is used to create the event queues 72A-72N or to supplement the operation of event queues operated in accordance with standard event queue code 27.
- the customized event queue code 70 is automatically executed at run time. When invoked, it may replace the standard event queue code 27.
- the pluggable event queue code 70 defines the operation of the event queues 72A-72N.
- the pluggable event queue code 70 may call the standard event queue code 27, allowing the standard event queue code 27 to operate in a standard prior art manner. In such a case, the event queues 72 A-72N are controlled by the event queue code 27.
- Fig. 3 illustrates the pluggable event queue code 70 controlling the event queues 72A-72N.
- the figure also shows that the pluggable event queue code 70 may call the event queue code 27, in which case the event queue code 27 controls the event queue elements 72A-72N.
- the customized event queue code 70 results in specialized event queues that may be used for reporting purposes, such as debugging, tracing, and event recording. As will be described below, the customized event queue code 70 is invoked and operated without affecting the operation of event queue code 27. Accordingly, the invention can be readily used as a pluggable addition to a proprietary or fixed event queue environment defined by event queue code 27.
- Fig. 4 illustrates a computer 80 constructed in accordance with an embodiment of the invention.
- the computer 80 includes a CPU 82 which communicates with a set of input/output devices 84 over a system bus 86.
- the CPU 82, input/output devices 84 and system bus 86 are consistent with prior art systems.
- the computer 80 also includes a memory 88 which stores a novel set of programs used to implement the present invention.
- the memory 88 stores an operating system 90 and GUI code 92.
- the GUI code 92 includes a Java® Virtual Machine of the type specified by Sun Microsystems®, Inc., Mountain View, California, the assignee of the present invention.
- the GUI code 92 also includes an Abstract Window Toolkit (AWT) 96, as specified by Sun Microsystems®, Inc., Mountain View, California.
- AKT Abstract Window Toolkit
- the AWT 96 provides a class for implementing a GUI 92.
- the AWT Abstract Window Toolkit
- AWT 96 provides classes for creating graphical user interface elements. By using these elements, the look and feel of a Java® Applet® can be controlled. Classes provided in the AWT 96 include methods for constructing windows, buttons, menus, fonts, images, scrollbars, etc. By way of example, Fig. 4 illustrates a drawRect method 98 and setForeground method 100 associated with the AWT 96. Many other additional methods are provided in a typical embodiment.
- the GUI code 92 also includes event queue code 27, which is used to construct a set of event queues 72A-72N.
- the event queue code 27 may be consistent with prior art implementations.
- the present invention is directed toward supplementing the operation of the event queue code 27 or substituting the event queue code 27 with pluggable event queue code 70.
- Fig. 4 also illustrates that the memory 88 includes a properties file 104.
- the properties file 104 is a text file.
- the pluggable event queue code of the invention maybe invoked by simply forming a text entry in the properties file
- Fig. 4 also illustrates that the memory 88 includes pluggable event queue code
- the pluggable event queue code 70 is used to generate event queues 72A-72N.
- pluggable event queue code 70 also referred to as customized event queue modules, can be used to generate customized queues that maybe used for debugging, tracing, event recording, or any other operation.
- the memory 88 of Fig. 4 includes a set of application programs 30A-
- the application programs 30 receive messages from the event queues 72A-72N.
- the event queues of the invention are created by event queue code which is loaded at the time of system initialization.
- event queue module class is loaded during system initialization. This operation has been performed using the following code:
- the instructions of lines (1) and (2) are used to load the "EventQueue" class from the standard AWT 96 library.
- the event queue code 27 to create the event queues 72A-72N is available in a standard AWT library 96.
- the instructions of lines (1) and (2) operate to initialize this class, so that the event queues can be created. This operation is consistent with prior art techniques for generating event queues.
- the present invention creates customized event queues (or pluggable event queues) by loading a pluggable event queue module (pluggable event queue code) 70 as a sub-class of the event queue class. This operation may be facilitated by reading from a properties file 104 a text message identifying the customized event queue module.
- This implementation of the invention is advantageous because the properties file, such as the "AWT.properties" file of the commercially available AWT code 96 from Sun Microsystems®, Inc., can be modified by an external developer.
- the properties file such as the "AWT.properties" file of the commercially available AWT code 96 from Sun Microsystems®, Inc.
- the new class is initialized at system start-up and is subsequently invoked.
- Line (4) of the code is an example of fetching a text message from a properties file.
- a "String” identified as “eqName” is fetched from an AWT.properties file.
- a text message is made in the properties file 104, which is read by the code of line (4).
- Line (5) and (6) is used to attempt to load the customized event queue module code identified in the properties file.
- Lines (7)-(9) are used for exception handling. Note at line (8) that an error message will print showing the failed loading and particularly specifying the module "eqName" that could not be loaded.
- Line (9) is the same as line (2) above; it is used to initialize the event queue class in the case that the pluggable event queue module cannot be loaded.
- a "TracedEventQueue" properties file 104 entry was described above.
- the customized event queue code 106 corresponding to this entry may be as follows:
- Lines (10)-(13) describe a sample sub-class customized event queue module 70 used to trace events before they are posted (sent) to an event queue 72.
- the term “extends” at line (10) indicates that the "TracedEventQueue” is a sub-class of the event queue code "EventQueue”.
- Line (11) specifies a type of event ("AWTEvent") and an instance of the event (“theEvent”).
- Line (12) causes the printing of the "theEvent” to the GUI 62.
- the foregoing code will effectively create a customized event queue 72 listing a set of messages resulting from an operation performed with the GUI 62.
- the event queue 72 may list a set of resize instructions, paint instructions, focus instructions, mouse activation instructions etc.
- Line (13) of the code invokes the event queue code 27 so that the event queue code can operate in a standard manner. This operation corresponds to the operation shown in Fig. 3 where the pluggable event queue code 70 calls event queue code 27. Note then that in this embodiment of the invention, the pluggable event queue code 70 intercepts the run-time messages sent to the event queue for processing which results in the run-time messages being displayed. This reporting operation is useful for debugging purposes.
- a "MyEventQueue" properties file 104 entry was also described above.
- the pluggable event queue code 70 corresponding to this entry may be as follows:
- Lines (15)-(29) describe a sample sub-class customized event queue module 70 used to trace events in response to a Ctrl-P keyboard combination.
- line (15) "extends” the class "EventQueue” to include a sub-class, the sub-class in this example is "MyEventQueue”.
- Lines (17) and (18) are used for initialization operations.
- the code in line (19) is used to identify the pressing down and releasing of a keyboard key and recording it as an event.
- Line (20) casts the event as a new type.
- Line (21) checks whether the new event is a Ctrl-P key sequence. If so, the lines (22)-(24) are executed.
- Line (22) causes the tracing of events to be printed.
- Line (23) is used to turn on a switch ("traceMethodCalls") in the Java® Virtual Machine which causes events to be traced.
- Line (24) sets the variable "tracing" to true.
- Line (25) invokes the event queue code 27. Thus, after line (25) is executed, standard event queue code 27 operations are performed.
- Line (26) tests whether a tracing operation occurred. If so, a message is printed at line (27).
- Line (28) is used to turn of the switch ("traceMethodCalls") in the Java® Virtual Machine. Finally, line (29) sets the tracing variable back to a false boolean value.
- the "TracedEventQueue” and “MyEventQueue” customized event queue module 70 examples demonstrate the operation of the invention. Naturally, any number of customized event queue modules may be constructed in accordance with the invention so that a variety of debugging, tracing, and event recording operations can be performed. It is important to observe that the customized event queue modules can operate without altering the operation of the event queue.
- pluggable event queue code 70 was executed, then standard event queue code 27 was called from the pluggable event queue code 70.
- the invention can be operated as a pluggable add-on to existing event queue environments. Observe also that the pluggable event queue code 70 need not call the event queue code 27. Instead, the pluggable event queue code 70 may itself be written to handle all event queue operations. In this case, the original event queue code 27 is not modified, it is simply not called, rather it is preempted by the pluggable event queue code 70.
Abstract
Description
Claims
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP54054598A JP2002503363A (en) | 1997-03-20 | 1998-03-03 | Apparatus and method for monitoring event queue operation with pluggable event queue |
EP98910132A EP0998706A4 (en) | 1997-03-20 | 1998-03-03 | Apparatus and method for monitoring event queue operations with pluggable event queues |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US08/821,686 | 1997-03-20 | ||
US08/821,686 US6189047B1 (en) | 1997-03-20 | 1997-03-20 | Apparatus and method for monitoring event queue operations with pluggable event queues |
Publications (2)
Publication Number | Publication Date |
---|---|
WO1998042144A2 true WO1998042144A2 (en) | 1998-09-24 |
WO1998042144A3 WO1998042144A3 (en) | 1999-06-17 |
Family
ID=25234047
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US1998/004100 WO1998042144A2 (en) | 1997-03-20 | 1998-03-03 | Apparatus and method for monitoring event queue operations with pluggable event queues |
Country Status (4)
Country | Link |
---|---|
US (1) | US6189047B1 (en) |
EP (1) | EP0998706A4 (en) |
JP (1) | JP2002503363A (en) |
WO (1) | WO1998042144A2 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2438743A (en) * | 2006-06-02 | 2007-12-05 | Vida Software S L | User Interfaces for Electronic Devices |
Families Citing this family (19)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6185514B1 (en) * | 1995-04-17 | 2001-02-06 | Ricos International, Inc. | Time and work tracker with hardware abstraction layer |
US6553403B1 (en) * | 1998-06-03 | 2003-04-22 | International Business Machines Corporation | System, method and computer program product for monitoring in a distributed computing environment |
US7102765B1 (en) * | 2000-02-01 | 2006-09-05 | Zoran Corporation | Apparatus and method for automated testing of print drivers in a computer system |
GB2380822B (en) * | 2001-10-11 | 2005-03-30 | At & T Lab Cambridge Ltd | Event queue managing system |
US20030126109A1 (en) * | 2002-01-02 | 2003-07-03 | Tanya Couch | Method and system for converting message data into relational table format |
US6915341B2 (en) * | 2002-01-08 | 2005-07-05 | International Business Machines Corporation | System for sending messages to all users in a web hosting environment |
US7437715B2 (en) * | 2002-04-09 | 2008-10-14 | Hewlett-Packard Development Company, L.P. | System and method for generating a set of robot commands based on user entry events in a user interface |
US7216349B2 (en) * | 2002-06-05 | 2007-05-08 | International Business Machines Corporation | System and method for triggering message queue applications |
US7019863B2 (en) * | 2002-06-10 | 2006-03-28 | Sharp Laboratories Of America, Inc. | Method to move queued data back to the network to make room in the device to complete other jobs |
US20040107179A1 (en) * | 2002-08-22 | 2004-06-03 | Mdt, Inc. | Method and system for controlling software execution in an event-driven operating system environment |
US20050080759A1 (en) * | 2003-10-08 | 2005-04-14 | International Business Machines Corporation | Transparent interface to a messaging system from a database engine |
US20050289264A1 (en) * | 2004-06-08 | 2005-12-29 | Daniel Illowsky | Device and method for interoperability instruction set |
US7653721B1 (en) | 2004-10-29 | 2010-01-26 | Sun Microsystems, Inc. | Mechanism for capturing high level events on user interface components |
US20070005728A1 (en) * | 2005-06-30 | 2007-01-04 | Ian Elbury | System and method of queued web services |
US8079037B2 (en) * | 2005-10-11 | 2011-12-13 | Knoa Software, Inc. | Generic, multi-instance method and GUI detection system for tracking and monitoring computer applications |
WO2013048986A1 (en) | 2011-09-26 | 2013-04-04 | Knoa Software, Inc. | Method, system and program product for allocation and/or prioritization of electronic resources |
US9961127B2 (en) * | 2013-03-15 | 2018-05-01 | Foresee Results, Inc. | System and method for capturing interaction data relating to a host application |
US9300647B2 (en) * | 2014-01-15 | 2016-03-29 | Sonos, Inc. | Software application and zones |
CN107844342B (en) * | 2017-11-21 | 2021-07-09 | Oppo广东移动通信有限公司 | Control method and device for keeping application program alive, storage medium and mobile terminal |
Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4896290A (en) * | 1987-08-24 | 1990-01-23 | Wang Laboratories, Inc. | Method for routing events from key strokes in a multi-processing computer systems |
US5600780A (en) * | 1990-03-30 | 1997-02-04 | International Business Machines Corporation | Programming environment system for customizing a program application based upon user input |
US5682328A (en) * | 1996-09-11 | 1997-10-28 | Bbn Corporation | Centralized computer event data logging system |
US5696702A (en) * | 1995-04-17 | 1997-12-09 | Skinner; Gary R. | Time and work tracker |
US5748499A (en) * | 1995-09-19 | 1998-05-05 | Sony Corporation | Computer graphics data recording and playback system with a VCR-based graphic user interface |
Family Cites Families (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5371891A (en) | 1992-04-09 | 1994-12-06 | Microsoft Corporation | Method for object construction in a compiler for an object-oriented programming language |
JPH06266813A (en) * | 1992-10-19 | 1994-09-22 | Internatl Business Mach Corp <Ibm> | Data collecting device and method for collecting and inputting data and requirement from plurality of user for constructing process-model and data-model |
US5838972A (en) * | 1996-02-09 | 1998-11-17 | Sun Microsystems, Inc. | Method and apparatus for dynamically loading an input run-time module and an output run-time module |
US5857190A (en) * | 1996-06-27 | 1999-01-05 | Microsoft Corporation | Event logging system and method for logging events in a network system |
US5768510A (en) * | 1996-07-01 | 1998-06-16 | Sun Microsystems, Inc. | Object-oriented system, method and article of manufacture for a client-server application enabler system |
US5996054A (en) * | 1996-09-12 | 1999-11-30 | Veritas Software Corp. | Efficient virtualized mapping space for log device data storage system |
-
1997
- 1997-03-20 US US08/821,686 patent/US6189047B1/en not_active Expired - Lifetime
-
1998
- 1998-03-03 WO PCT/US1998/004100 patent/WO1998042144A2/en not_active Application Discontinuation
- 1998-03-03 EP EP98910132A patent/EP0998706A4/en not_active Withdrawn
- 1998-03-03 JP JP54054598A patent/JP2002503363A/en not_active Ceased
Patent Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4896290A (en) * | 1987-08-24 | 1990-01-23 | Wang Laboratories, Inc. | Method for routing events from key strokes in a multi-processing computer systems |
US5600780A (en) * | 1990-03-30 | 1997-02-04 | International Business Machines Corporation | Programming environment system for customizing a program application based upon user input |
US5696702A (en) * | 1995-04-17 | 1997-12-09 | Skinner; Gary R. | Time and work tracker |
US5748499A (en) * | 1995-09-19 | 1998-05-05 | Sony Corporation | Computer graphics data recording and playback system with a VCR-based graphic user interface |
US5682328A (en) * | 1996-09-11 | 1997-10-28 | Bbn Corporation | Centralized computer event data logging system |
Non-Patent Citations (1)
Title |
---|
See also references of EP0998706A2 * |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2438743A (en) * | 2006-06-02 | 2007-12-05 | Vida Software S L | User Interfaces for Electronic Devices |
GB2438743B (en) * | 2006-06-02 | 2009-03-25 | Vida Software S L | User interfaces for electronic devices |
Also Published As
Publication number | Publication date |
---|---|
US6189047B1 (en) | 2001-02-13 |
WO1998042144A3 (en) | 1999-06-17 |
JP2002503363A (en) | 2002-01-29 |
EP0998706A2 (en) | 2000-05-10 |
EP0998706A4 (en) | 2004-12-15 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6189047B1 (en) | Apparatus and method for monitoring event queue operations with pluggable event queues | |
US6002867A (en) | Development system with methods providing visual form inheritance | |
US8943424B2 (en) | Dynamic interface component control support | |
EP1179777B1 (en) | Generation of runtime execution traces of applications and error detection | |
US8196096B2 (en) | .Net ribbon model for a ribbon user interface | |
US7039912B1 (en) | Integrated computer testing and task management systems | |
US5896532A (en) | Objects with run-time classes and methods of making them | |
US7451455B1 (en) | Apparatus and method for automatically manipulating software products | |
KR20030036736A (en) | Method and apparatus for producing functionality and user interfaces for devices having an embedded operating system | |
US6131185A (en) | Method and system for visually debugging on object in an object oriented system | |
EP2284698B1 (en) | Compositional modeling of integrated systems using event-based legacy applications | |
JPH07508116A (en) | Devices and systems for event recognition and notification | |
EP0727741A1 (en) | Method and system for managing events | |
WO2000020963A2 (en) | Method and system for associating parameters of containers and contained objects | |
US5818445A (en) | Method and system for creating computer-program-based applications with developer specified look and feel | |
EP0602845A2 (en) | Message dispatching in an event driven architecture | |
US5551040A (en) | Methods and apparatus for specifying the contexts of names in callback-style programming | |
US20030001892A1 (en) | Property editor graphical user interface apparatus, method and computer program product | |
US6185730B1 (en) | Method and apparatus for creating dippable beans in a java environment | |
Washizaki et al. | Dynamic hierarchical undo facility in a fine-grained component environment | |
US20030182596A1 (en) | Method and system for isolating exception related errors in java JVM | |
Mayer | Graphical user interfaces composed of plug-ins | |
EP1650629A2 (en) | System and method for preventing a copy of a protected window | |
Morris | Object-oriented programming under Windows | |
Pavlidis | Fundamentals of the X Window System |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): JP |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): AT BE CH DE DK ES FI FR GB GR IE IT LU MC NL PT SE |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
AK | Designated states |
Kind code of ref document: A3 Designated state(s): JP |
|
AL | Designated countries for regional patents |
Kind code of ref document: A3 Designated state(s): AT BE CH DE DK ES FI FR GB GR IE IT LU MC NL PT SE |
|
ENP | Entry into the national phase |
Ref country code: JP Ref document number: 1998 540545 Kind code of ref document: A Format of ref document f/p: F |
|
WWE | Wipo information: entry into national phase |
Ref document number: 1998910132 Country of ref document: EP |
|
WWP | Wipo information: published in national office |
Ref document number: 1998910132 Country of ref document: EP |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 1998910132 Country of ref document: EP |