Patent Publication Number: US-8127240-B2

Title: Seamless drag and drop operation with multiple event handlers

Description:
FIELD OF THE INVENTION 
     The embodiments of the present invention relate to drag and drop operations and, more particularly, to a method of selecting event handlers through the use of drag and drop operations. 
     BACKGROUND OF THE INVENTION 
     Open application programming interfaces (APIs) allow third parties to design application plugins which interact with a host application though a standard interface. An application plugin is a computer program that functions within an environment provided by the host application to provide new features to the host application or to expand an existing feature. Plugins can create capabilities that extend the host application or support unforeseen future capabilities. For example, the plugin can allow a host Web browsing application to display a form of digital media not otherwise viewable with the host Web browsing application. 
     As plugin architectures continue to proliferate, situations can arise in which more than one plugin available within the host application is able to handle a same processing function. In instances where multiple plugins may implement the same function, it may be necessary for the host application to designate which plugin will carry out the function. 
     When multiple plugins are available to operate on an object, the host application may automatically select the plugin to operate on the object. This can lead to a less than optimal choice of plugin. In another approach, the host application may present a list of plugins and request the user to select a preferred plugin to operate on the object. This approach can result in multiple user actions that interrupt user workflow and disturb the continuous flow of the host application. 
     BRIEF SUMMARY OF THE INVENTION 
     The embodiments disclosed herein relate to seamlessly selecting an event handler for processing an object within a host application. One embodiment of the present invention can include a computer-implemented method of selecting an event handler. The method can include initiating a drag and drop operation for a source object and, responsive to detecting contact between the source object and a window of a graphical user interface (GUI), displaying a plurality of icons, wherein each icon represents an event handler for a drop target within the window. The method further can include detecting contact between the source object and at least one of the plurality of icons while dragging the object, designating each event handler associated with a contacted icon to process the source object, and responsive to dropping the source object onto the drop target, invoking each designated event handler to process the source object for the drop target. Each designated event handler can output a process result. 
     Another embodiment of the present invention can include a computer-implemented method of selecting an event handler including initiating a drag and drop operation by dragging a source object and contacting a window of a GUI including a parent node that is not a drop target. The method can include, responsive to selecting the parent node in the window as part of the drag and drop operation, expanding the parent node to reveal at least one child node that is a drop target, identifying a plurality of event handlers associated with each child node that process objects of a same type as the source object, and presenting icons associated with each identified event handler. Responsive to detecting contact between the source object and at least one of the plurality of icons, each event handler associated with a contacted icon can be designated to process the source object. Responsive to dropping the source object onto the child node, each designated event handler can be invoked to process the source object for the child node. Each designated event handler can output a process result. 
     Yet another embodiment of the present invention can include a computer program product including a computer-usable medium having computer-usable program code that, when executed, causes a machine to perform the various steps and/or functions described herein. 
    
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
         FIG. 1  is a first pictorial view illustrating a technique for selecting an event handler in accordance with one embodiment of the present invention. 
         FIG. 2  is a second pictorial view illustrating a technique for selecting a plurality of event handlers in accordance with another embodiment of the present invention. 
         FIG. 3  is a third pictorial view illustrating a technique for selecting an event handler in accordance with another embodiment of the present invention. 
         FIG. 4  is a fourth pictorial view illustrating a technique for selecting an event handler in accordance with another embodiment of the present invention. 
         FIG. 5  is a flow chart illustrating a method of selecting an event handler in accordance with another embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     As will be appreciated by one skilled in the art, the present invention may be embodied as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment, including firmware, resident software, micro-code, etc., or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module,” or “system.” 
     Furthermore, the invention may take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by, or in connection with, a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer-readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by, or in connection with, the instruction execution system, apparatus, or device. 
     Any suitable computer-usable or computer-readable medium may be utilized. For example, the medium can include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device), or a propagation medium. A non-exhaustive list of exemplary computer-readable media can include an electrical connection having one or more wires, an optical fiber, magnetic storage devices such as magnetic tape, a removable computer diskette, a portable computer diskette, a hard disk, a rigid magnetic disk, a magneto-optical disk, an optical storage medium, such as an optical disk including a compact disk-read only memory (CD-ROM), a compact disk-read/write (CD-R/W), or a DVD, or a semiconductor or solid state memory including, but not limited to, a random access memory (RAM), a read-only memory (ROM), or an erasable programmable read-only memory (EPROM or Flash memory). 
     A computer-usable or computer-readable medium further can include a transmission media such as those supporting the Internet or an intranet. Further, the computer-usable medium may include a propagated data signal with the computer-usable program code embodied therewith, either in baseband or as part of a carrier wave. The computer-usable program code may be transmitted using any appropriate medium, including but not limited to the Internet, wireline, optical fiber, cable, RF, etc. 
     In another aspect, the computer-usable or computer-readable medium can be paper or another suitable medium upon which the program is printed, as the program can be electronically captured, via, for instance, optical scanning of the paper or other medium, then compiled, interpreted, or otherwise processed in a suitable manner, if necessary, and then stored in a computer memory. 
     Computer program code for carrying out operations of the present invention may be written in an object oriented programming language such as Java, Smalltalk, C++ or the like. However, the computer program code for carrying out operations of the present invention may also be written in conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer, or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). 
     A data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution. 
     Input/output (I/O) devices such as, for example, keyboards, displays, pointing devices, etc. can be coupled to the system either directly or through intervening I/O controllers. Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modems, and Ethernet cards are just a few of the currently available types of network adapters. 
     The present invention is described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. 
     These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function/act specified in the flowchart and/or block diagram block or blocks. 
     The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. 
     In accordance with the embodiments disclosed herein, a user can select an object upon which to initiate a drag and drop operation. As used herein, the term “object” can refer to any type of programmatic material such as a folder, a file, a section of a file, a container, a program, a section of code, or the like that can be selected and dragged within the context of the drag and drop operation, or otherwise manipulated by a pointing device. For example, the object can be any item that can be individually selected and manipulated. This can include shapes and pictures that appear on a display screen and represent programmatic material stored in a data processing system. An object can include data or procedures or both. In object-oriented programming, for example, an object can be a self-contained entity that can include both data and procedures to manipulate the data. 
     The selected object can be dragged over a window of a graphical user interface (GUI) of a host application. Upon detecting contact between the object and the window, icons representing each of a plurality of event handlers can be presented. Each of the event handlers can be capable of processing an object of a same type as the dragged object. Continuing the drag and drop operation, the user can contact at least one of the presented icons with the object, designating each event handler associated with a contacted icon as an event handler to process the dragged object. The user can drop the dragged object on a selected drop target in the window, invoking the event handler to process the dropped object, and outputting a process result. 
       FIG. 1  is a first pictorial view illustrating a technique for selecting an event handler in accordance with one embodiment of the present invention. As shown,  FIG. 1  depicts a GUI  105  for a host application  100 . The phrase “host application,” as used herein, can refer to any form of computer program capable of “hosting” or enabling the operation of one or more event handlers. The host application  100  can provide an architecture and/or execution environment within which the event handler can be registered and execute. Accordingly, the host application  100  can communicate with, and invoke, the event handler. Examples of host applications can include, but are not limited to, Web browsers, electronic mail clients, media players, software development tools, instant messaging (IM) clients, data processing tools, and the like. 
     GUI  105  can present a plurality of drop targets  110 ,  115 , and  120 . As used herein, a “drop target” can refer to an object upon which another object may be dropped. For example, a drop target can be an object that can receive another object, e.g., a folder or a function that takes a dropped object as input. In addition, GUI  105  can dynamically display a window  125 , responsive to detecting a particular type of event. Window  125  can contain a plurality of icons  130 ,  135 , and  140 . As demonstrated by the dotted connecting lines, each of the icons  130 ,  135 ,  140  can correspond to a respective event handler  145 ,  150 , and  155 . Each of the event handlers  145 - 155  can require a host application, such as host application  100 , for a framework within which to execute. For example, a media player can be an event handler that operates within a host Web browser application. Responsive to the Web browser downloading a file type processed by the media player, the media player can be invoked to process the file. 
     As used herein, the term “icon” can refer to a targetable area or defined spatial area of a GUI. The various objects described herein, e.g., source object or drop targets, may be represented by icons. Each icon, defining a targetable area of the GUI, typically is formed using a graphic, text, or a combination of both a graphic and text. As an icon representing a parent node in a hierarchy is expanded, for example, the space corresponding to the parent node, or icon representing the node, can be expanded to reveal further defined spaces represented as child icons. 
     In operation, a source object  160  can be selected with a pointing device  165  and dragged over GUI  105 . The phrase “source object” will be used within this specification to refer to the object that is being dragged. Source object  160  can be a portion of programming code, a data file, an image file, a universal resource locator (URL), a video file, or other item that can be represented as an icon and selected for a drag and drop operation. During the drag operation, source object  160  can contact GUI  105 . Responsive to detecting contact between source object  160  and GUI  105 , the host application  100  can dynamically display window  125  containing icons  130 - 140 . 
     Throughout this specification, contact will be described in terms of contact between the source object  160  and the contacted object. It should be appreciated, however, that the term “contact” can also refer to contact between the pointer  165  and the contacted object when pointer  165  is dragging a source object. In any case, contact can refer to the case when two objects overlap one another, when an edge of each object touches the other, or when an edge of one object crosses an edge or boundary of another object. In another aspect, contact can refer to one object entering a geographical area surrounding GUI  105 , e.g., an area extending outward from each border or edge of GUI  105  in one or more or all directions for a predetermined distance. Contact between GUI  105 , or a window within GUI  105 , and source object  160  can be the event that causes window  125  to be displayed. 
     In one embodiment, upon detecting contact between source object  160  and GUI  105 , the host application  100 , e.g., the GUI  105 , can execute a query to determine which event handlers, of a plurality of event handlers of the host application  100  are capable of processing source object  160 . The query can determine a type of source object  160  and the event handlers available to the host application  100  that process objects of the same type as the source object  160 . In doing so, the host application  100  further can determine that more than one event handler is available for processing objects of the type of source object  160 . The type of an object can be indicated by the particular file extension of the source object  160 . Upon identifying event handlers capable of processing the source object  160 , the host application  100  can display only icons corresponding to the identified event handlers, in this case icons  130 - 140  corresponding to event handlers  145 - 155 . 
     Within GUI  105 , event handlers  145 - 155  are represented as icons  130 - 140  within window  125 . It should be appreciated, however, that icons  130 - 140  may be presented in any number of ways. In one embodiment, the icons can be displayed floating over GUI  105 . For example, icons  130 - 140  can be displayed as a semi-transparent overlay with the underlying GUI  105  still being viewable beneath icons  130 - 140 . In another embodiment, the icons  130 - 140  can be presented in a menu form, spaced so as to allow a pointer dragging source object  160  to traverse a path to select one or more event handlers during the drag and drop operation to be described herein. The particular manner in which icons  130 - 140  are displayed is not intended to limit the embodiments disclosed herein of the invention so long as icons  130 - 140  are dynamically displayed responsive to an event as described. 
     Once icons  130 - 140  are displayed, the user can continue the drag operation, dragging source object  160  along a path  170 . Traversing path  170 , source object  160  can contact or pass over icon  130 , designating event handler  145  associated with icon  130  to process source object  160 . Completing path  170 , source object  160  can be moved over drop target  115  and released. Upon releasing source object  160 , which terminates the drag and drop operation, the host application  100  can invoke event handler  145  to process source object  160 . 
     In this manner, the user can select source object  160  and drag source object  160  to GUI  105  of the host application  100 . Icons  130 - 140 , which are associated with event handlers  145 - 155  for processing objects of the same type as source object  160 , can be dynamically displayed responsive to the contact. An event handler to process source object  160  can be designated. Source object  160  can be dropped on drop target  115 . These steps can be performed in one continuous and uninterrupted drag and drop operation, resulting in the invocation of event handler  145 . 
       FIG. 2  is a second pictorial view illustrating a technique for selecting a plurality of event handlers in accordance with another embodiment of the present invention.  FIG. 2  illustrates another example of a continuous drag and drop operation selecting a plurality of event handlers using the GUI  105  of host application  100 .  FIG. 2  demonstrates how multiple event handlers can be selected to process a single source object. 
     As shown, source object  160  has been selected and is being dragged via pointer  165 . Path  175  represents the route along which source object  160  is dragged during the drag and drop operation. Responsive to contact between GUI  105  and source object  160 , window  125  can be displayed. Using pointing device  165 , source object  160  can be dragged to contact both icon  130  and icon  135  before being released over drop target  115 . Responsive to contact between source object  160  and icons  130  and  135 , event handler  145 , associated with icon  130 , and event handler  150 , associated with icon  135 , can be designated to process source object  160 . In response to source object  160  being released over drop target  115 , the two designated event handlers  145  and  150  can be invoked to process source object  160 . As source object  160  made no contact with icon  140 , event handler  155  is not selected or invoked. 
     The ability to designate multiple event handlers to process source object  160  can be helpful when multiple features are available to the host application  100  to process a single object type. For example, the user may select and drag a URL specifying a unique media type and drop the URL into a browser type of host application. The browser may have multiple event handlers available to process URL type objects. Upon dragging the URL over the browser GUI, all available event handlers for processing URL type objects can be displayed as icons. 
     The user can drag the URL over any icons representing available event handlers to select the event handlers the user wishes to invoke. One event handler, for example, can perform bookmark management, while another event handler may display the media file indicated by the URL. The user can drop the URL in the browser, e.g., over the drop target. If the user contacts the source object  160  with the icon for the bookmark management event handler and the icon for the URL display event handler, responsive to the drop, the bookmark management event handler can be invoked and the display event handler can be invoked. In one embodiment, each event handler can be invoked in the order that the corresponding icons were contacted. The bookmark management event handler can store the bookmark in a particular location, e.g., a folder indicated by or associated with the drop target. The display event handler can render the media file indicated by the URL. In this way, multiple event handlers can be invoked to process the URL in a single drag and drop operation. 
       FIG. 3  is a third pictorial view illustrating a technique for selecting an event handler in accordance with another embodiment of the present invention.  FIG. 3  shows a GUI  305  for an instant messaging (IM) client type of host application. The IM client can include several event handlers. The GUI  305  can include a window  310 , which presents a contact list, e.g., a buddy list. The contact list can be hierarchical in nature as indicated by expandable nodes  325 ,  330 , and  335 , each functioning as a parent node. For purposes of illustration, contacts of the host application as may be presented within window  310  can serve as drop targets for the source object  340  being dragged. 
     In operation, the user can select a source object  340 , which in this example can be a URL, with a pointer  345 . As source object  340  contacts window  310 , window  310 , for example a container within GUI  305 , can initiate a query to determine whether any drop targets for source object  340  exist or are shown within window  310 . For example, window  310 , as is known in the art, can be a container object including the logic necessary for identifying, querying, and otherwise interacting with any objects presented within window  310 . 
     In this case, the query can determine that window  310  includes nodes  325 ,  330 , and  335 . Each of nodes  325 - 330 , as noted, is a parent node which may have zero or child nodes. In this example, each of nodes  325 - 330  can serve as a class or category that includes other objects, e.g., contacts. As such, nodes  325 - 330  are not considered drop targets. In this example, since no drop targets are displayed within window  310 , no event handlers, or icons representing event handlers, will be displayed. 
       FIG. 4  is a fourth pictorial view illustrating a technique for selecting an event handler in accordance with another embodiment of the present invention.  FIG. 4  represents a continuation of the drag and drop operation started in  FIG. 3  with pointer  345  having dragged source object  340  into window  310 . In this example, the user can traverse the hierarchical contact list by hovering over a particular node which can cause that node to expand or collapse. In this sense, hovering over a node for a minimum and predetermined amount of time can select that node. Here, pointer  345 , while dragging source object  340 , can hover over node  330  for a predetermined amount of time, thereby causing node  330  to expand. Expansion of node  330  reveals four child nodes  360 ,  365 ,  370 , and  375 . In this example, since a contact is a drop target, child nodes  360 - 370  are drop targets whereas nodes  325 - 330  are not. 
     While event handlers can be associated with particular file types, another classification of event handlers can be according to drop target type. For example, while contacts are described as being drop targets, other types of objects, e.g., a user&#39;s calendar, etc., also may be drop targets. In this respect, each different type of drop target can be associated with a particular set of event handlers. The set of event handlers for contacts may differ from those available for other types of drop targets. Further, each drop target may be associated with one or more event handlers by virtue of the type of each respective drop target. In another aspect, each drop target can be associated with one or more event handlers on an individual basis. Accordingly, when determining whether a drop target exists, the GUI  305  can query for several types of information such as the type of the source object and the type of the drop target that is available, selected, or displayed within a contacted window. Such information can be used to identify particular event handlers from those available within the host application and present icons for the identified event handlers. 
     Accordingly, GUI  305 , with child nodes  360 - 375  being revealed, can determine that one or more drop targets do exist. GUI  305  can identify the type of the source object  340 , e.g., a URL, and can identify the particular type of drop targets that are available. In this case, each drop target is a contact, e.g., nodes  360 - 375 . Accordingly, the GUI  305  can identify event handlers of the host application that are available for contact type drop targets that also are capable of processing URL type source objects. 
     For purposes of illustration, it can be assumed that such a query has determined that two event handlers have been identified, e.g., a bookmark manager event handler and an RSS reader event handler. Accordingly, icons  350  and  355 , corresponding to each respective identified event handler, can be dynamically displayed. A user can select one or both event handlers by dragging the source object  340  over one or both of icons  350  and/or  355  as may be desired before dropping the source object  340  onto one of nodes  360 - 375 . 
     It should be appreciated that the selection of event handlers and the manner in which event handlers can be represented can be implemented in any of a variety of ways. In the preceding example, event handlers can be displayed when drop targets are revealed. In another example, when drop targets that are available within a window are of the same type, whether displayed or not, icons for the event handlers associated with those drop targets can be dynamically displayed without waiting to reveal the drop targets or selecting a particular drop target or parent node of a drop target. This may or may not be the case when revealed, or available, drop targets are not the same type and do not share a common set of event handlers. 
     In one embodiment, only event handlers that are common to each drop target can be displayed, while those event handlers that are not available to each drop target are not. In another embodiment, no event handlers can be displayed until the user selects a particular drop target, e.g., by hovering over the selected node during the drag and drop operation. For example, the identification of any event handlers can be delayed until a particular child node is selected during the drag and drop operation. In still another embodiment, each available event handler for any revealed drop targets, or for a selected parent node whether or not the child nodes are displayed, may be presented. In that case, the host application can notify the user in the event that an event handler is selected and the user subsequently drops the source object over a drop target for which the selected event handler is unavailable. It should be appreciated that in each case, the event handler(s) selected still are able to process the type of object being dragged. 
     In another embodiment, responsive to the source object  340  hovering over a parent node, such as node  330 , only the child nodes that are drop targets can be displayed. Such an embodiment encompasses cases where not all child nodes of a parent node are drop targets. The GUI  305  can query for several types of information such as the type of the source object  340 , the child nodes that are available, whether each child node is a drop target, the type of each child node, and the type of object each drop target can receive. Based upon the information determined from the query, the GUI  305  can differentiate between child nodes that are drop targets and those that are not. The GUI  305  can display only those child nodes, in this case nodes  360 ,  365 ,  370 , and  375 , of node  330  that are drop targets. Accordingly, nodes  360 ,  365 ,  370 , and  375  are a subset of the total child nodes of node  330 . 
     In another example, based on the information determined from the query, GUI  305  can determine which nodes that are drop targets can receive objects of the same type as the source object. Accordingly, the GUI  305  further can restrict the child nodes displayed to only those that are drop targets and that can receive objects of the same type as source object  340 . For example, if source object  340  is an audio file and nodes  360 - 375  are displayed, nodes  360 - 375  can be assumed to be drop targets that can receive an audio file type object. Other child nodes of node  330  that are drop targets but which cannot receive an audio file are not displayed. 
     In another aspect, the particular icons that are displayed can change dynamically as the user selects, e.g., hovers over, different drop targets. As the user selects different drop targets, icons for event handlers can be presented for the selected drop target. For example, if a plurality of different types of drop targets are displayed, and each is associated with one or more event handlers that are not available to other drop targets, as the source object is moved to hover over a different drop target, the event handlers associated with that drop target, considering the type of the source object, can be presented. 
       FIG. 5  is a flow chart illustrating a method  500  of selecting event handlers in accordance with another embodiment of the present invention. The method  500  implements a seamless drag and drop operation for selecting one or more event handlers to process a source object. The ability to incorporate the selection process within a drag and drop operation can be advantageous in applications where multiple event handlers available to act on a particular object type. 
     Accordingly, in step  505 , a drag and drop operation can be initiated. A source object can be selected and dragged using a pointer. The source object can be dragged toward a GUI of a host application that includes a plurality of event handlers for processing objects of the same type as the source object. In step  510 , contact between the source object a window within the GUI can be detected. 
     In step  515 , any drop targets within the window can be identified. As noted, the type of the drop targets also can be determined. In step  520 , the event handlers associated with the identified drop targets that are able to process objects of the same type as the source object can be identified. As noted, if no drop targets are displayed, the user can navigate a hierarchical list to reveal drop targets, e.g., using a hover-type of selection mechanism, as described herein. 
     In step  525 , an icon for each event handler identified in step  520  can be dynamically displayed. In step  530 , contact between the source object and one or more of the displayed icons representing event handlers can be detected. In one embodiment, once contact is detected between the source object and an icon, the appearance of the contacted icon can be changed to indicate the contact and the designation of the event handler associated with the contacted icon to process the source object. In another embodiment, the appearance of the source object can be changed to indicate the designation of one or more event handlers for processing the source object. The appearance of the source object can be altered also to indicate a number of event handlers that have been designated or that more than one event handler has been designated. It should be appreciated that the appearance of the source object, a contacted icon, or both may be altered to indicate the designation of an event handler. 
     In step  535 , responsive to dropping the source object on the drop target, each event handler selected, or designated via the contact detected in step  530 , can be invoked to process the source object for the drop target. In step  540 , a process result for each event handler can be output. As used herein, “output” or “outputting” can include, but is not limited to, storing data in memory, e.g., writing to a file, writing to a user display or other output device, e.g., playing audible notifications, sending or transmitting to another system, exporting, or the like. 
     For example, the user may wish to alert a co-worker to a deadline of a project that both users share. The user can select a source object indicating the deadline, e.g., a task or calendar object, drag the source object over an icon for a calendar management event handler and an icon for a task management event handler, and drop the source object on a node representing the co-worker in the contact list of an IM application GUI. Upon dropping the source object, an entry can be added to the calendar of the co-worker and a task can be added to a task list of the co-worker. Accordingly, the function that is performed by each event handler is performed with reference to both the source object and the drop target. 
     The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical functions. It should also be noted that, in some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions. 
     The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. 
     The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiments were chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated. 
     Having thus described the invention of the present application in detail and by reference to the embodiments thereof, it will be apparent that modifications and variations are possible without departing from the scope of the invention defined in the appended claims.