64790 2011-07-19 03:51:42 -0700 [GTK][WK2] Handle doneWithKeyEvent in GTK port 2011-07-28 10:25:06 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Other Linux RESOLVED FIXED P2 Normal --- 0 ravi.kasibhatla webkit-unassigned alex amruthraj cgarcia mrobinson webkit.review.bot xan.lopez oldest_to_newest 439082 0 ravi.kasibhatla 2011-07-19 03:51:42 -0700 WebKitWebViewBase widget should forward key_press event to parent widget only if it is not handled by Web Process. Currently all key_press events are passed to parent widget. For ex: Press tab key in www.gmail.com username field. Instead of focusing password field, focus moves to toolbar. 439213 1 cgarcia 2011-07-19 09:48:28 -0700 Renaming, since didNotHandleKeyEvent was renamed to doneWithKeyEvent in r77694. It seems we added the new method but we didn't remove the old one. 439216 2 cgarcia 2011-07-19 09:50:13 -0700 I guess we should always return TRUE from key_press_event and key_release_event, and propagate the event again in doneWithKeyEvent() when not handled by the web process. 439222 3 101337 ravi.kasibhatla 2011-07-19 09:59:32 -0700 Created attachment 101337 Fix the tab switch issue 439226 4 101337 mrobinson 2011-07-19 10:09:56 -0700 Comment on attachment 101337 Fix the tab switch issue View in context: https://bugs.webkit.org/attachment.cgi?id=101337&action=review Looks good, but I have a few nits. > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:216 > + reinterpret_cast<const GdkEventKey*>(event.nativeEvent())); The indentation is off here and you should just do: &event.nativeEvent()->key or similar. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:330 > + GTK_WIDGET(webViewBase), > + const_cast<GdkEventKey*>(keyEvent)); No need to break this line. It isn't right to simply cast away the constness here. The NativeWebKeyboardEvent is not expecting the GdkEventKey to change. Probably it's better to make a copy of the event and send that. 439638 5 101429 ravi.kasibhatla 2011-07-19 23:17:40 -0700 Created attachment 101429 Implementation for doneWithKeyEvent for WK2 GTK port Addressing review comments of mrobinson & cgarcia. 439639 6 ravi.kasibhatla 2011-07-19 23:19:38 -0700 (In reply to comment #4) > (From update of attachment 101337 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101337&action=review > > Looks good, but I have a few nits. > > > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:216 > > + reinterpret_cast<const GdkEventKey*>(event.nativeEvent())); > > The indentation is off here and you should just do: &event.nativeEvent()->key or similar. Done. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:330 > > + GTK_WIDGET(webViewBase), > > + const_cast<GdkEventKey*>(keyEvent)); > > No need to break this line. It isn't right to simply cast away the constness here. The NativeWebKeyboardEvent is not expecting the GdkEventKey to change. Probably it's better to make a copy of the event and send that. When invoking GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event, we need to do const_cast<GdkEventKey*> since the API expects a non-const GdkEventKey* and we have a const GdkEventKey*. Addressed the other points in the comment. 439654 7 101429 cgarcia 2011-07-20 00:10:51 -0700 Comment on attachment 101429 Implementation for doneWithKeyEvent for WK2 GTK port View in context: https://bugs.webkit.org/attachment.cgi?id=101429&action=review With the patch the focus never moves to the toolbar, I'm not sure what the right behaviour is, but with GtkLauncher the toolbar is focused at some point after pressing tab several times. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:329 > +void webkitWebViewBaseDidNotHandleKeyEvent(WebKitWebViewBase* webViewBase, const GdkEventKey* keyEvent) > +{ > + GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(GTK_WIDGET(webViewBase), const_cast<GdkEventKey*>(keyEvent)); > +} > + I'm not sure about this, maybe it would be better to use gtk_main_do_event() so that the event is properly handled again by GTK and added to the stack. Event callbacks expect functions gtk_get_current_event* to work. We would need to add a boolean flag to tell the view we are forwarding an event not handled by the web process and simply call gtk_main_do_event(). In key_press and key_release, we check that flag and if set, we simply unset it and call key_press_event on parent widget. 439843 8 101478 ravi.kasibhatla 2011-07-20 09:43:00 -0700 Created attachment 101478 Implementation for doneWithKeyEvent for WK2 GTK port Addresses the comments given by Carlos for using gtk_main_do_event() 439846 9 ravi.kasibhatla 2011-07-20 09:43:15 -0700 (In reply to comment #7) > (From update of attachment 101429 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101429&action=review > > With the patch the focus never moves to the toolbar, I'm not sure what the right behaviour is, but with GtkLauncher the toolbar is focused at some point after pressing tab several times. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:329 > > +void webkitWebViewBaseDidNotHandleKeyEvent(WebKitWebViewBase* webViewBase, const GdkEventKey* keyEvent) > > +{ > > + GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(GTK_WIDGET(webViewBase), const_cast<GdkEventKey*>(keyEvent)); > > +} > > + > > I'm not sure about this, maybe it would be better to use gtk_main_do_event() so that the event is properly handled again by GTK and added to the stack. Event callbacks expect functions gtk_get_current_event* to work. We would need to add a boolean flag to tell the view we are forwarding an event not handled by the web process and simply call gtk_main_do_event(). In key_press and key_release, we check that flag and if set, we simply unset it and call key_press_event on parent widget. Done. 439854 10 101478 cgarcia 2011-07-20 09:54:15 -0700 Comment on attachment 101478 Implementation for doneWithKeyEvent for WK2 GTK port View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:213 > + webkitWebViewBaseDidNotHandleKeyEvent(webkitWebViewBase, event.nativeEvent()); We don't need this method, we can just call gtk_main_do_event here. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:339 > + WebKitWebViewBasePrivate* priv = webkitWebViewBase->priv; > + priv->shouldForwardEvent = TRUE; This could be a single line webkitWebViewBase->priv->shouldForwardEvent = TRUE; 441351 11 101478 mrobinson 2011-07-22 23:41:02 -0700 Comment on attachment 101478 Implementation for doneWithKeyEvent for WK2 GTK port View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review I have a few concerns below. Please also take into account Carlos's suggestions. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:56 > + gboolean shouldForwardEvent; I think that shouldForwardKeyboardEvent would be a better name here. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:208 > + // Since WebProcess key event handling is not synchronous, make it 2-pass handling. > + // First, always return TRUE in event handler. > + // Second, PageClientImpl::doneWithKeyEvent return status of event handling in WebProcess. > + // Third, using status, determine whether to pass the event to parent or not using gtk_main_do_event(). I think this would be easier to read as a paragraph. Something like: // Since WebProcess key event handling is not synchronous, we must handle this event in two passes. When // the WebProcess is done handling the event it will call PageClientImpl::doneWithKeyEvent, where we will // be able to determine whether to pass the event to our parent or not using gtk_main_do_event(). > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:212 > + if (priv->shouldForwardEvent) { > + priv->shouldForwardEvent = FALSE; > + return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > + } I'm not sure how I understand how priv->shouldForwardEvent can be true before you call PageProxy::handleKeyboardEvent below. 441353 12 101478 mrobinson 2011-07-22 23:42:45 -0700 Comment on attachment 101478 Implementation for doneWithKeyEvent for WK2 GTK port View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:345 > + gtk_main_do_event(const_cast<GdkEvent*>(event)); I still believe that it is incorrect to simply cast away the constness of this GdkEvent. It's probably more correct to make a copy of the event and send that. 441579 13 101854 ravi.kasibhatla 2011-07-25 00:58:31 -0700 Created attachment 101854 Implementation for doneWithKeyEvent for WK2 GTK port 441580 14 ravi.kasibhatla 2011-07-25 00:58:57 -0700 (In reply to comment #10) > (From update of attachment 101478 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review > > > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:213 > > + webkitWebViewBaseDidNotHandleKeyEvent(webkitWebViewBase, event.nativeEvent()); > > We don't need this method, we can just call gtk_main_do_event here. Done. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:339 > > + WebKitWebViewBasePrivate* priv = webkitWebViewBase->priv; > > + priv->shouldForwardEvent = TRUE; > > This could be a single line webkitWebViewBase->priv->shouldForwardEvent = TRUE; Done. 441581 15 ravi.kasibhatla 2011-07-25 01:03:24 -0700 (In reply to comment #11) > (From update of attachment 101478 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review > > I have a few concerns below. Please also take into account Carlos's suggestions. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:56 > > + gboolean shouldForwardEvent; > > I think that shouldForwardKeyboardEvent would be a better name here. Done. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:208 > > + // Since WebProcess key event handling is not synchronous, make it 2-pass handling. > > + // First, always return TRUE in event handler. > > + // Second, PageClientImpl::doneWithKeyEvent return status of event handling in WebProcess. > > + // Third, using status, determine whether to pass the event to parent or not using gtk_main_do_event(). > > I think this would be easier to read as a paragraph. Something like: > > // Since WebProcess key event handling is not synchronous, we must handle this event in two passes. When > // the WebProcess is done handling the event it will call PageClientImpl::doneWithKeyEvent, where we will > // be able to determine whether to pass the event to our parent or not using gtk_main_do_event(). Done. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:212 > > + if (priv->shouldForwardEvent) { > > + priv->shouldForwardEvent = FALSE; > > + return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > > + } > > I'm not sure how I understand how priv->shouldForwardEvent can be true before you call PageProxy::handleKeyboardEvent below. shouldForwardKeyboardEvent will not be true when we are calling PageProxy::handleKeyboardEvent. It would be FALSE and hence event would be sent to PageProxy for handling. On handling the input event, when we get the call back to PageClientImpl::doneWithKeyEvent, we check for handled status. If it is false, then we call webkitWebViewBaseSetForwardEvent which set shouldForwardKeyboardEvent to TRUE. Then we call gtk_main_do_event which triggers key_press_event where we pass the event to parent widget. 441582 16 ravi.kasibhatla 2011-07-25 01:03:42 -0700 (In reply to comment #12) > (From update of attachment 101478 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:345 > > + gtk_main_do_event(const_cast<GdkEvent*>(event)); > > I still believe that it is incorrect to simply cast away the constness of this GdkEvent. It's probably more correct to make a copy of the event and send that. Done. 441760 17 101854 mrobinson 2011-07-25 11:37:05 -0700 Comment on attachment 101854 Implementation for doneWithKeyEvent for WK2 GTK port View in context: https://bugs.webkit.org/attachment.cgi?id=101854&action=review I'm a bit concerned about the interaction of key release and following key press events. > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:210 > + if (!wasEventHandled) { Please just use an early return here. > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:212 > + webkitWebViewBaseSetForwardEvent(webkitWebViewBase); With the way the code is written now, what happens when this is called on a key release event? Won't this setting then effect the behavior of the next key press? > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:213 > + GdkEvent inputEvent = *event.nativeEvent(); It's probably better to use: GOwnPtr<GdkEvent> inputEvent(gdk_event_copy(event.nativeEvent())); here. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:214 > + // Since WebProcess key event handling is not synchronous, handle the event in two passes. > + // When WebProcess processes the input event, it will call PageClientImpl::doneWithKeyEvent > + // with event handled status which determines whether to pass the input event to parent or not > + // using gtk_main_do_event(). > + if (priv->shouldForwardKeyboardEvent) { > + priv->shouldForwardKeyboardEvent = FALSE; > + return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > + } > priv->pageProxy->handleKeyboardEvent(NativeWebKeyboardEvent(reinterpret_cast<GdkEvent*>(event))); > - > - return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > + return TRUE; I should clarify my confusion here. I do not understand how priv->shouldForwardKeyboardEvent can be true when webkitWebViewBaseKeyPressEvent is called. The only way I can see this happening is if during a previous key release event, priv->shouldForwardKeyboardEvent was set to true. I do not think previous key release events should affect future key press events (see my comment above). > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:339 > +void webkitWebViewBaseSetForwardEvent(WebKitWebViewBase* webkitWebViewBase) > +{ > + webkitWebViewBase->priv->shouldForwardKeyboardEvent = TRUE; > +} I think you can just eliminate this method entirely and do this directly in PageClientImpl::doneWithKeyEvent. 442129 18 cgarcia 2011-07-25 23:36:35 -0700 (In reply to comment #12) > (From update of attachment 101478 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101478&action=review > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:345 > > + gtk_main_do_event(const_cast<GdkEvent*>(event)); > > I still believe that it is incorrect to simply cast away the constness of this GdkEvent. It's probably more correct to make a copy of the event and send that. We don't need to copy the event, gtk_main_do_event() doesn't modify the event at all. 442130 19 cgarcia 2011-07-25 23:43:35 -0700 (In reply to comment #17) > (From update of attachment 101854 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101854&action=review > > I'm a bit concerned about the interaction of key release and following key press events. > > > With the way the code is written now, what happens when this is called on a key release event? Won't this setting then effect the behavior of the next key press? shouldForwardKeyboardEvent is set to false in both key press and release event handlers, so it won't affect any other events. > > - > > - return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > > + return TRUE; > > I should clarify my confusion here. I do not understand how priv->shouldForwardKeyboardEvent can be true when webkitWebViewBaseKeyPressEvent is called. The only way I can see this happening is if during a previous key release event, priv->shouldForwardKeyboardEvent was set to true. I do not think previous key release events should affect future key press events (see my comment above). shouldForwardKeyboardEvent is only true when a key press/release event is not handled by the web process, in this case we simply take the same event and send it to gtk to be processed again. Then key_press or key_release will be called, and shouldForwardKeyboardEvent will be true, so the handler will send the event to the parent widget and will set shouldForwardKeyboardEvent to false again so it won't affect future events. It's not a previous event, we are processing the same event again, so other key events are not affected. 442224 20 101997 ravi.kasibhatla 2011-07-26 07:10:21 -0700 Created attachment 101997 Implementation for doneWithKeyEvent for WK2 GTK port - revision 4 Revision 4 - based on latest comments from Martin. 442225 21 101854 ravi.kasibhatla 2011-07-26 07:11:09 -0700 Comment on attachment 101854 Implementation for doneWithKeyEvent for WK2 GTK port Updated with revision 4 patch. 442228 22 ravi.kasibhatla 2011-07-26 07:20:56 -0700 (In reply to comment #17) > (From update of attachment 101854 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101854&action=review > > I'm a bit concerned about the interaction of key release and following key press events. > > > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:210 > > + if (!wasEventHandled) { > > Please just use an early return here. Done. > > > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:212 > > + webkitWebViewBaseSetForwardEvent(webkitWebViewBase); > > With the way the code is written now, what happens when this is called on a key release event? Won't this setting then effect the behavior of the next key press? Will be addressed in new enum type implementation. > > > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:213 > > + GdkEvent inputEvent = *event.nativeEvent(); > > It's probably better to use: GOwnPtr<GdkEvent> inputEvent(gdk_event_copy(event.nativeEvent())); here. Done. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:214 > > + // Since WebProcess key event handling is not synchronous, handle the event in two passes. > > + // When WebProcess processes the input event, it will call PageClientImpl::doneWithKeyEvent > > + // with event handled status which determines whether to pass the input event to parent or not > > + // using gtk_main_do_event(). > > + if (priv->shouldForwardKeyboardEvent) { > > + priv->shouldForwardKeyboardEvent = FALSE; > > + return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > > + } > > priv->pageProxy->handleKeyboardEvent(NativeWebKeyboardEvent(reinterpret_cast<GdkEvent*>(event))); > > - > > - return GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->key_press_event(widget, event); > > + return TRUE; > > I should clarify my confusion here. I do not understand how priv->shouldForwardKeyboardEvent can be true when webkitWebViewBaseKeyPressEvent is called. The only way I can see this happening is if during a previous key release event, priv->shouldForwardKeyboardEvent was set to true. I do not think previous key release events should affect future key press events (see my comment above). Carlos has explained in the below comment about the this design. We reset the flag in each key_press_event or key_release_event handler to prevent any effect on future events. Like we discussed, I have made it an enum rather than bool, to pass on specifically the event not handled to parent. I still though have one concern in calling gtk_main_do_event(). Consider a usecase, where key_press gets handled by web process but not key_release. Since we are calling gtk_main_do_event(), we again get key_press & key_release callbacks to WebKitWebViewBase widget. With our flag for handled status, we will pass key_release to parent widget, but key_press gets propagated again to web process. Wouldn't that be an issue? > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:339 > > +void webkitWebViewBaseSetForwardEvent(WebKitWebViewBase* webkitWebViewBase) > > +{ > > + webkitWebViewBase->priv->shouldForwardKeyboardEvent = TRUE; > > +} > > I think you can just eliminate this method entirely and do this directly in PageClientImpl::doneWithKeyEvent. Done. 442235 23 mrobinson 2011-07-26 07:29:53 -0700 (In reply to comment #22) > I still though have one concern in calling gtk_main_do_event(). Consider a usecase, where key_press gets handled by web process but not key_release. Since we are calling gtk_main_do_event(), we again get key_press & key_release callbacks to WebKitWebViewBase widget. With our flag for handled status, we will pass key_release to parent widget, but key_press gets propagated again to web process. Wouldn't that be an issue? Yes, that's an issue. We need to throw the event away in that case. 442268 24 101997 cgarcia 2011-07-26 08:14:24 -0700 Comment on attachment 101997 Implementation for doneWithKeyEvent for WK2 GTK port - revision 4 View in context: https://bugs.webkit.org/attachment.cgi?id=101997&action=review > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:220 > + GOwnPtr<GdkEvent> inputEvent(gdk_event_copy(event.nativeEvent())); > + gtk_main_do_event(inputEvent.get()); I think we shouldn't copy the event, gtk_main_do_event() doesn't modify the event. > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:-60 > -struct _WebKitWebViewBasePrivate { > - OwnPtr<PageClientImpl> pageClient; > - RefPtr<WebPageProxy> pageProxy; > - gboolean isPageActive; > - GtkIMContext* imContext; > - GtkClickCounter clickCounter; > - CString tooltipText; > -}; > - I prefer to keep private structures as private and add specific private API when needed, it makes easier to know who and why is using the private members outside the object. 442271 25 mrobinson 2011-07-26 08:15:51 -0700 (In reply to comment #24) > I prefer to keep private structures as private and add specific private API when needed, it makes easier to know who and why is using the private members outside the object. I suggested this because it's a pattern we commonly use in WebKit1. 442276 26 cgarcia 2011-07-26 08:24:12 -0700 (In reply to comment #22) > I still though have one concern in calling gtk_main_do_event(). Consider a usecase, where key_press gets handled by web process but not key_release. Since we are calling gtk_main_do_event(), we again get key_press & key_release callbacks to WebKitWebViewBase widget. With our flag for handled status, we will pass key_release to parent widget, but key_press gets propagated again to web process. Wouldn't that be an issue? No, with gtk_main_do_event() we only process the event that was not handled by the we process, if key press is handled by not key release, doneWithKeyEvent will be called with handled=true only for the key press event, so we will call gtk_main_do_event() only for the key release. I don't think we need the enum, since doneWithKeyEvent will be called for every key press/release event, the boolean is enough, events are handled synchronously by gtk+. 443494 27 102258 ravi.kasibhatla 2011-07-28 07:49:09 -0700 Created attachment 102258 Implementation for doneWithKeyEvent for WK2 GTK port - revision 5 Addressed the concerns & comments of carlos & martin. As per explanation given by Carlos, since gtk_main_do_event is sync & gets invoked only for event which is being passed gtk_main_do_event, reverting to boolean flag. As per understanding with Martin & Carlos now keeping the WebKitWebViewPrivate in .cpp only and exposing a new API to set the flag from PageClientImpl. As per discussion with Carlos & Martin, NativeWebKeyboardEvent::nativeEvent now returns a non-const GdkEvent. Removing the casting & event copy from PageClientImpl. 443544 28 102258 webkit.review.bot 2011-07-28 10:25:00 -0700 Comment on attachment 102258 Implementation for doneWithKeyEvent for WK2 GTK port - revision 5 Clearing flags on attachment: 102258 Committed r91937: <http://trac.webkit.org/changeset/91937> 443545 29 webkit.review.bot 2011-07-28 10:25:06 -0700 All reviewed patches have been landed. Closing bug. 101337 2011-07-19 09:59:32 -0700 2011-07-19 23:17:40 -0700 Fix the tab switch issue tab_issue_fix.diff text/plain 4437 ravi.kasibhatla ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA3NjM2M2E4Li5mNDkxODRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEg QEAKKzIwMTEtMDctMTkgIFJhdmkgUGhhbmVlbmRyYSBLYXNpYmhhdGxhICA8cmF2aS5rYXNpYmhh dGxhQG1vdG9yb2xhLmNvbT4KKworICAgICAgICBBZGQgaW1wbGVtZW50YXRpb24gb2YgUGFnZUNs aWVudEltcGw6OmRpZE5vdEhhbmRsZUtleUV2ZW50IGZvciBXZWJLaXQyIEdUSyBwb3J0LgorICAg ICAgICBSZXF1aXJlZCBmb3IgZW5zdXJpbmcgdGhhdCBrZXlfcHJlc3MgZXZlbnRzIGFyZSBwYXNz ZWQgdG8gcGFyZW50IHdpZGdldCBieSAKKyAgICAgICAgV2ViS2l0V2ViVmlld0Jhc2Ugd2lkZ2V0 IG9ubHkgaWYgaXQgaXMgbm90IGhhbmRsZWQgYnkgV2ViIFByb2Nlc3MuCisgICAgICAgIChodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ3OTApCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9Q YWdlQ2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsOjpkaWRO b3RIYW5kbGVLZXlFdmVudCk6IEhhbmRsZSB3aGVuIFdlYiBQcm9jZXNzIGludGltYXRlcyB0aGF0 IGtleUV2ZW50IGhhcyBub3QgYmVlbiBoYW5kbGVkCisgICAgICAgIGluIFdlYlByb2Nlc3MuCisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwOgorICAgICAg ICAod2Via2l0V2ViVmlld0Jhc2VLZXlQcmVzc0V2ZW50KTogQWx3YXlzIHJldHVybiBUUlVFIGlu IGtleV9wcmVzc19ldmVudCBoYW5kbGVyLiBJZiBldmVudCBpcyBub3QgaGFuZGxlZCwgaGFuZGxl IGl0IGluCisgICAgICAgIHdlYmtpdFdlYlZpZXdCYXNlRGlkTm90SGFuZGxlS2V5RXZlbnQuCisg ICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZURpZE5vdEhhbmRsZUtleUV2ZW50KTogUGFzcyB0aGUg a2V5X3ByZXNzX2V2ZW50IHRvIHBhcmVudCB3aWRnZXQgaWYgV2ViIFByb2Nlc3MgaGFzbid0IGhh bmRsZWQgaXQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2VQ cml2YXRlLmg6IEFkZGVkIHRoZSBzaWduYXR1cmUgb2Ygd2Via2l0V2ViVmlld0Jhc2VEaWROb3RI YW5kbGVLZXlFdmVudC4KKwogMjAxMS0wNy0xNyAgQW1ydXRoIFJhaiAgPGFtcnV0aHJhakBtb3Rv cm9sYS5jb20+CiAKICAgICAgICAgW0dUS10gRml4IHNlbGVjdGlvbiBvZiBlbGVtZW50cyBpbiBh IG11bHRpIHNlbGVjdCBsaXN0IGFuZCByZW1vdmUgYW4gdW5uZWNlc3NhcnkgaW5jbHVkZSBpbiBX b3JrUXVldWUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1Bh Z2VDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VD bGllbnRJbXBsLmNwcAppbmRleCBlMGNlMzc0Li40MDg5OGE5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCkBAIC0yMTIsNyAr MjEyLDggQEAgdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRp dmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCB3YXNFdmUKIAogdm9pZCBQYWdlQ2xpZW50SW1wbDo6 ZGlkTm90SGFuZGxlS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgZXZlbnQp CiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICB3ZWJraXRXZWJWaWV3QmFzZURpZE5vdEhh bmRsZUtleUV2ZW50KFdFQktJVF9XRUJfVklFV19CQVNFKG1fdmlld1dpZGdldCksIAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVpbnRlcnByZXRfY2FzdDxj b25zdCBHZGtFdmVudEtleSo+KGV2ZW50Lm5hdGl2ZUV2ZW50KCkpKTsKIH0KIAogdm9pZCBQYWdl Q2xpZW50SW1wbDo6ZGlkTm90SGFuZGxlV2hlZWxFdmVudChjb25zdCBOYXRpdmVXZWJXaGVlbEV2 ZW50JikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYlZpZXdCYXNlLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYlZpZXdCYXNlLmNwcAppbmRleCA3ZmFmODQyLi42OTBiODc2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCkBA IC0yMDEsOCArMjAxLDEwIEBAIHN0YXRpYyBnYm9vbGVhbiB3ZWJraXRXZWJWaWV3QmFzZUtleVBy ZXNzRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBlCiAgICAgV2ViS2l0V2Vi Vmlld0Jhc2VQcml2YXRlKiBwcml2ID0gd2ViVmlld0Jhc2UtPnByaXY7CiAKICAgICBwcml2LT5w YWdlUHJveHktPmhhbmRsZUtleWJvYXJkRXZlbnQoTmF0aXZlV2ViS2V5Ym9hcmRFdmVudChyZWlu dGVycHJldF9jYXN0PEdka0V2ZW50Kj4oZXZlbnQpKSk7Ci0KLSAgICByZXR1cm4gR1RLX1dJREdF VF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJlbnRfY2xhc3MpLT5rZXlfcHJlc3NfZXZl bnQod2lkZ2V0LCBldmVudCk7CisgICAgLy8gU2luY2UgV2ViUHJvY2VzcyBldmVudCBoYW5kbGlu ZyBpcyBub3Qgc3luYywgd2UgYWx3YXlzIGJ5IGRlZmF1bHQgcmV0dXJuIFRSVUUgaGVyZS4KKyAg ICAvLyBJZiB0aGUgZXZlbnQgaXMgYWN0dWFsbHkgbm90IGhhbmRsZWQgYnkgV2ViS2l0LCB0aGVu IHdlIGdldCB0aGUgY2FsbGJhY2sgZGlkTm90SGFuZGxlS2V5RXZlbnQuCisgICAgLy8gV2Ugc2Vu ZCB0aGF0IHVwd2FyZHMgdG8gcGFyZW50IGNsYXNzIGZvciBoYW5kbGluZyByYXRoZXIgdGhhbiBo ZXJlLgorICAgIHJldHVybiBUUlVFOwogfQogCiBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2ViVmll d0Jhc2VLZXlSZWxlYXNlRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBldmVu dCkKQEAgLTMyMSw2ICszMjMsMTMgQEAgV2ViUGFnZVByb3h5KiB3ZWJraXRXZWJWaWV3QmFzZUdl dFBhZ2UoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlKQogICAgIHJldHVybiB3 ZWJraXRXZWJWaWV3QmFzZS0+cHJpdi0+cGFnZVByb3h5LmdldCgpOwogfQogCit2b2lkIHdlYmtp dFdlYlZpZXdCYXNlRGlkTm90SGFuZGxlS2V5RXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYlZp ZXdCYXNlLCBjb25zdCBHZGtFdmVudEtleSoga2V5RXZlbnQpCit7CisgICAgR1RLX1dJREdFVF9D TEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJlbnRfY2xhc3MpLT5rZXlfcHJlc3NfZXZlbnQo CisgICAgICAgICAgICAgICAgR1RLX1dJREdFVCh3ZWJWaWV3QmFzZSksCisgICAgICAgICAgICAg ICAgY29uc3RfY2FzdDxHZGtFdmVudEtleSo+KGtleUV2ZW50KSk7Cit9CisKIHZvaWQgd2Via2l0 V2ViVmlld0Jhc2VDcmVhdGVXZWJQYWdlKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJraXRXZWJWaWV3 QmFzZSwgV0tDb250ZXh0UmVmIGNvbnRleHQsIFdLUGFnZUdyb3VwUmVmIHBhZ2VHcm91cCkKIHsK ICAgICBXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUqIHByaXYgPSB3ZWJraXRXZWJWaWV3QmFzZS0+ cHJpdjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYlZpZXdCYXNlUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlLmgKaW5kZXggNjk5NjczOC4uNWQzYjI1NCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2VQ cml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Vmlld0Jhc2VQcml2YXRlLmgKQEAgLTQ2LDYgKzQ2LDggQEAgdm9pZCB3ZWJraXRXZWJWaWV3QmFz ZUNyZWF0ZVdlYlBhZ2UoV2ViS2l0V2ViVmlld0Jhc2UqLCBXS0NvbnRleHRSZWYsIFdLUGFnZUdy b3UKIAogdm9pZCB3ZWJraXRXZWJWaWV3QmFzZVNldFRvb2x0aXBUZXh0KFdlYktpdFdlYlZpZXdC YXNlKiwgY29uc3QgY2hhciopOwogCit2b2lkIHdlYmtpdFdlYlZpZXdCYXNlRGlkTm90SGFuZGxl S2V5RXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqLCBjb25zdCBHZGtFdmVudEtleSopOworCiBHX0VO RF9ERUNMUwogCiAjZW5kaWYgLy8gV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlX2gK 101429 2011-07-19 23:17:40 -0700 2011-07-20 09:43:00 -0700 Implementation for doneWithKeyEvent for WK2 GTK port tab_issue_fix.diff text/plain 5488 ravi.kasibhatla ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA3NjM2M2E4Li42NzQ2NjRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEg QEAKKzIwMTEtMDctMTkgIFJhdmkgUGhhbmVlbmRyYSBLYXNpYmhhdGxhICA8cmF2aS5rYXNpYmhh dGxhQG1vdG9yb2xhLmNvbT4KKworICAgICAgICBSZXR1cm4gVFJVRSBhbHdheXMgaW4gV2ViS2l0 V2ViVmlld0Jhc2Ugd2lkZ2V0IGtleV9wcmVzc19ldmVudCBjYWxsYmFjay4KKyAgICAgICAgUGFz cyB0aGUga2V5X3ByZXNzX2V2ZW50IHRvIHBhcmVudCB3aWRnZXQgb25seSB3aGVuIGl0IGlzIG5v dCBoYW5kbGVkIGJ5IFdlYiBQcm9jZXNzLgorICAgICAgICAoaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTY0NzkwKQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3Bw OgorICAgICAgICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCk6IElt cGxlbWVudGVkIGZvciBHVEsgcG9ydCB0byBkZXRlcm1pbmUgd2hldGhlciB0bworICAgICAgICBw YXNzIGtleV9wcmVzc19ldmVudCB0byBwYXJlbnQgd2lkZ2V0IG9yIG5vdC4KKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oOiBEZWxldGVkIG9ic29sZXRlIGZ1bmN0 aW9ucyBkaWROb3RIYW5kbGVLZXlFdmVudCBhbmQKKyAgICAgICAgZGlkTm90SGFuZGxlV2hlZWxF dmVudC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHA6 CisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZUtleVByZXNzRXZlbnQpOiBBbHdheXMgcmV0dXJu IFRSVUUuCisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZURpZE5vdEhhbmRsZUtleUV2ZW50KTog UGFzcyBrZXlfcHJlc3NfZXZlbnQgdG8gcGFyZW50IHdpZGdldC4KKyAgICAgICAgKiBVSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaDogU2lnbmF0dXJlIGZvciB3ZWJr aXRXZWJWaWV3QmFzZURpZE5vdEhhbmRsZUtleUV2ZW50LgorCiAyMDExLTA3LTE3ICBBbXJ1dGgg UmFqICA8YW1ydXRocmFqQG1vdG9yb2xhLmNvbT4KIAogICAgICAgICBbR1RLXSBGaXggc2VsZWN0 aW9uIG9mIGVsZW1lbnRzIGluIGEgbXVsdGkgc2VsZWN0IGxpc3QgYW5kIHJlbW92ZSBhbiB1bm5l Y2Vzc2FyeSBpbmNsdWRlIGluIFdvcmtRdWV1ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCmluZGV4IGUwY2UzNzQuLjAxNjlmNmUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJ bXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50 SW1wbC5jcHAKQEAgLTIwNSwxOSArMjA1LDEwIEBAIEludFJlY3QgUGFnZUNsaWVudEltcGw6Ondp bmRvd1RvU2NyZWVuKGNvbnN0IEludFJlY3QmIHJlY3QpCiAgICAgcmV0dXJuIEludFJlY3QoY29u dmVydFdpZGdldFBvaW50VG9TY3JlZW5Qb2ludChtX3ZpZXdXaWRnZXQsIHJlY3QubG9jYXRpb24o KSksIHJlY3Quc2l6ZSgpKTsKIH0KIAotdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlF dmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCB3YXNFdmVudEhhbmRsZWQp Cit2b2lkIFBhZ2VDbGllbnRJbXBsOjpkb25lV2l0aEtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktl eWJvYXJkRXZlbnQmIGV2ZW50LCBib29sIHdhc0V2ZW50SGFuZGxlZCkKIHsKLSAgICBub3RJbXBs ZW1lbnRlZCgpOwotfQotCi12b2lkIFBhZ2VDbGllbnRJbXBsOjpkaWROb3RIYW5kbGVLZXlFdmVu dChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiBldmVudCkKLXsKLSAgICBub3RJbXBsZW1l bnRlZCgpOwotfQotCi12b2lkIFBhZ2VDbGllbnRJbXBsOjpkaWROb3RIYW5kbGVXaGVlbEV2ZW50 KGNvbnN0IE5hdGl2ZVdlYldoZWVsRXZlbnQmKQotewotICAgIG5vdEltcGxlbWVudGVkKCk7Cisg ICAgaWYgKCF3YXNFdmVudEhhbmRsZWQpCisgICAgICAgIHdlYmtpdFdlYlZpZXdCYXNlRGlkTm90 SGFuZGxlS2V5RXZlbnQoV0VCS0lUX1dFQl9WSUVXX0JBU0UobV92aWV3V2lkZ2V0KSwgJmV2ZW50 Lm5hdGl2ZUV2ZW50KCktPmtleSk7CiB9CiAKIFBhc3NSZWZQdHI8V2ViUG9wdXBNZW51UHJveHk+ IFBhZ2VDbGllbnRJbXBsOjpjcmVhdGVQb3B1cE1lbnVQcm94eShXZWJQYWdlUHJveHkqIHBhZ2Up CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50 SW1wbC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu aAppbmRleCA2YTViNWQ1Li42MWJhYjRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmgKQEAgLTc5LDggKzc5LDYgQEAgcHJpdmF0ZToK ICAgICB2aXJ0dWFsIFdlYkNvcmU6OkludFBvaW50IHNjcmVlblRvV2luZG93KGNvbnN0IFdlYkNv cmU6OkludFBvaW50Jik7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpJbnRSZWN0IHdpbmRvd1RvU2Ny ZWVuKGNvbnN0IFdlYkNvcmU6OkludFJlY3QmKTsKICAgICB2aXJ0dWFsIHZvaWQgZG9uZVdpdGhL ZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCB3YXNFdmVudEhhbmRs ZWQpOwotICAgIHZpcnR1YWwgdm9pZCBkaWROb3RIYW5kbGVLZXlFdmVudChjb25zdCBOYXRpdmVX ZWJLZXlib2FyZEV2ZW50Jik7Ci0gICAgdmlydHVhbCB2b2lkIGRpZE5vdEhhbmRsZVdoZWVsRXZl bnQoY29uc3QgTmF0aXZlV2ViV2hlZWxFdmVudCYpOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxX ZWJQb3B1cE1lbnVQcm94eT4gY3JlYXRlUG9wdXBNZW51UHJveHkoV2ViUGFnZVByb3h5Kik7CiAg ICAgdmlydHVhbCBQYXNzUmVmUHRyPFdlYkNvbnRleHRNZW51UHJveHk+IGNyZWF0ZUNvbnRleHRN ZW51UHJveHkoV2ViUGFnZVByb3h5Kik7CiAgICAgdmlydHVhbCB2b2lkIHNldEZpbmRJbmRpY2F0 b3IoUGFzc1JlZlB0cjxGaW5kSW5kaWNhdG9yPiwgYm9vbCBmYWRlT3V0KTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcCBi L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcApp bmRleCA3ZmFmODQyLi45MzZjNzk1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCkBAIC0yMDEsOCArMjAxLDkgQEAg c3RhdGljIGdib29sZWFuIHdlYmtpdFdlYlZpZXdCYXNlS2V5UHJlc3NFdmVudChHdGtXaWRnZXQq IHdpZGdldCwgR2RrRXZlbnRLZXkqIGUKICAgICBXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUqIHBy aXYgPSB3ZWJWaWV3QmFzZS0+cHJpdjsKIAogICAgIHByaXYtPnBhZ2VQcm94eS0+aGFuZGxlS2V5 Ym9hcmRFdmVudChOYXRpdmVXZWJLZXlib2FyZEV2ZW50KHJlaW50ZXJwcmV0X2Nhc3Q8R2RrRXZl bnQqPihldmVudCkpKTsKLQotICAgIHJldHVybiBHVEtfV0lER0VUX0NMQVNTKHdlYmtpdF93ZWJf dmlld19iYXNlX3BhcmVudF9jbGFzcyktPmtleV9wcmVzc19ldmVudCh3aWRnZXQsIGV2ZW50KTsK KyAgICAvLyBTaW5jZSBXZWJQcm9jZXNzIGV2ZW50IGhhbmRsaW5nIGlzIG5vdCBzeW5jaHJvbm91 cywgcmV0dXJuIFRSVUUgaGVyZS4KKyAgICAvLyBJZiBXZWIgUHJvY2VzcyBkb2Vzbid0IGhhbmRs ZSB0aGUga2V5IGV2ZW50LCBoYW5kbGUgaXQgaW4gUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoS2V5 RXZlbnQuIAorICAgIHJldHVybiBUUlVFOwogfQogCiBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2Vi Vmlld0Jhc2VLZXlSZWxlYXNlRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBl dmVudCkKQEAgLTMyMSw2ICszMjIsMTEgQEAgV2ViUGFnZVByb3h5KiB3ZWJraXRXZWJWaWV3QmFz ZUdldFBhZ2UoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlKQogICAgIHJldHVy biB3ZWJraXRXZWJWaWV3QmFzZS0+cHJpdi0+cGFnZVByb3h5LmdldCgpOwogfQogCit2b2lkIHdl YmtpdFdlYlZpZXdCYXNlRGlkTm90SGFuZGxlS2V5RXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqIHdl YlZpZXdCYXNlLCBjb25zdCBHZGtFdmVudEtleSoga2V5RXZlbnQpCit7CisgICAgR1RLX1dJREdF VF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJlbnRfY2xhc3MpLT5rZXlfcHJlc3NfZXZl bnQoR1RLX1dJREdFVCh3ZWJWaWV3QmFzZSksIGNvbnN0X2Nhc3Q8R2RrRXZlbnRLZXkqPihrZXlF dmVudCkpOworfQorCiB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlQ3JlYXRlV2ViUGFnZShXZWJLaXRX ZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UsIFdLQ29udGV4dFJlZiBjb250ZXh0LCBXS1Bh Z2VHcm91cFJlZiBwYWdlR3JvdXApCiB7CiAgICAgV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlKiBw cml2ID0gd2Via2l0V2ViVmlld0Jhc2UtPnByaXY7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaCBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCmluZGV4 IDY5OTY3MzguLjVkM2IyNTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCkBAIC00Niw2ICs0Niw4 IEBAIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VDcmVhdGVXZWJQYWdlKFdlYktpdFdlYlZpZXdCYXNl KiwgV0tDb250ZXh0UmVmLCBXS1BhZ2VHcm91CiAKIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VTZXRU b29sdGlwVGV4dChXZWJLaXRXZWJWaWV3QmFzZSosIGNvbnN0IGNoYXIqKTsKIAordm9pZCB3ZWJr aXRXZWJWaWV3QmFzZURpZE5vdEhhbmRsZUtleUV2ZW50KFdlYktpdFdlYlZpZXdCYXNlKiwgY29u c3QgR2RrRXZlbnRLZXkqKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmIC8vIFdlYktpdFdlYlZp ZXdCYXNlUHJpdmF0ZV9oCg== 101478 2011-07-20 09:43:00 -0700 2011-07-25 00:58:31 -0700 Implementation for doneWithKeyEvent for WK2 GTK port tab_issue_fix.diff text/plain 7897 ravi.kasibhatla ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA3NjM2M2E4Li4yMTE4YjAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQg QEAKKzIwMTEtMDctMjAgIFJhdmkgUGhhbmVlbmRyYSBLYXNpYmhhdGxhICA8cmF2aS5rYXNpYmhh dGxhQG1vdG9yb2xhLmNvbT4KKworICAgICAgICBSZXR1cm4gVFJVRSBhbHdheXMgaW4gV2ViS2l0 V2ViVmlld0Jhc2Ugd2lkZ2V0IGtleV9wcmVzc19ldmVudCBjYWxsYmFjay4KKyAgICAgICAgUGFz cyB0aGUga2V5X3ByZXNzX2V2ZW50IHRvIHBhcmVudCB3aWRnZXQgb25seSB3aGVuIGl0IGlzIG5v dCBoYW5kbGVkIGJ5IFdlYiBQcm9jZXNzLgorICAgICAgICAoaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTY0NzkwKQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3Bw OgorICAgICAgICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCk6IElt cGxlbWVudGVkIGZvciBHVEsgcG9ydCB0byBkZXRlcm1pbmUgd2hldGhlciB0bworICAgICAgICBw YXNzIGtleV9wcmVzc19ldmVudCB0byBwYXJlbnQgd2lkZ2V0IG9yIG5vdC4KKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oOiBEZWxldGVkIG9ic29sZXRlIGZ1bmN0 aW9ucyBkaWROb3RIYW5kbGVLZXlFdmVudCBhbmQKKyAgICAgICAgZGlkTm90SGFuZGxlV2hlZWxF dmVudC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHA6 CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9pbml0KToKKyAgICAgICAgKHdlYmtpdFdl YlZpZXdCYXNlS2V5UHJlc3NFdmVudCk6IFBhc3MgZXZlbnQgdG8gcGFyZW50IHdpZGdldCBkZXBl bmRpbmcgb24gc3RhdHVzIGZyb20gZG9uZVdpdGhLZXlFdmVudC4gCisgICAgICAgICh3ZWJraXRX ZWJWaWV3QmFzZUtleVJlbGVhc2VFdmVudCk6IFBhc3MgZXZlbnQgdG8gcGFyZW50IHdpZGdldCBk ZXBlbmRpbmcgb24gc3RhdHVzIGZyb20gZG9uZVdpdGhLZXlFdmVudC4KKyAgICAgICAgKHdlYmtp dFdlYlZpZXdCYXNlU2V0Rm9yd2FyZEV2ZW50KTogU2V0IGZsYWcgaW5kaWNhdGluZyB0aGF0IGV2 ZW50IG5lZWRzIHRvIGJlIGZvcndhcmRlZCB0byBwYXJlbnQuCisgICAgICAgICh3ZWJraXRXZWJW aWV3QmFzZURpZE5vdEhhbmRsZUtleUV2ZW50KTogUnVuIGd0a19tYWluX2RvX2V2ZW50KCkuCisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlLmg6IFNp Z25hdHVyZXMgZm9yIG5ld2x5IGFkZGVkIGZ1bmN0aW9ucy4KKwogMjAxMS0wNy0xNyAgQW1ydXRo IFJhaiAgPGFtcnV0aHJhakBtb3Rvcm9sYS5jb20+CiAKICAgICAgICAgW0dUS10gRml4IHNlbGVj dGlvbiBvZiBlbGVtZW50cyBpbiBhIG11bHRpIHNlbGVjdCBsaXN0IGFuZCByZW1vdmUgYW4gdW5u ZWNlc3NhcnkgaW5jbHVkZSBpbiBXb3JrUXVldWUKICAgICAgICAgcmV0dXJuIGZhbHNlOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu Y3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3Bw CmluZGV4IGUwY2UzNzQuLjllN2M1MjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTIwNSwxOSArMjA1LDEzIEBAIElu dFJlY3QgUGFnZUNsaWVudEltcGw6OndpbmRvd1RvU2NyZWVuKGNvbnN0IEludFJlY3QmIHJlY3Qp CiAgICAgcmV0dXJuIEludFJlY3QoY29udmVydFdpZGdldFBvaW50VG9TY3JlZW5Qb2ludChtX3Zp ZXdXaWRnZXQsIHJlY3QubG9jYXRpb24oKSksIHJlY3Quc2l6ZSgpKTsKIH0KIAotdm9pZCBQYWdl Q2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50 JiwgYm9vbCB3YXNFdmVudEhhbmRsZWQpCit2b2lkIFBhZ2VDbGllbnRJbXBsOjpkb25lV2l0aEtl eUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50LCBib29sIHdhc0V2ZW50 SGFuZGxlZCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotfQotCi12b2lkIFBhZ2VDbGllbnRJ bXBsOjpkaWROb3RIYW5kbGVLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiBl dmVudCkKLXsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotfQotCi12b2lkIFBhZ2VDbGllbnRJbXBs OjpkaWROb3RIYW5kbGVXaGVlbEV2ZW50KGNvbnN0IE5hdGl2ZVdlYldoZWVsRXZlbnQmKQotewot ICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgaWYgKCF3YXNFdmVudEhhbmRsZWQpIHsKKyAgICAg ICAgV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlID0gV0VCS0lUX1dFQl9WSUVX X0JBU0UobV92aWV3V2lkZ2V0KTsKKyAgICAgICAgd2Via2l0V2ViVmlld0Jhc2VTZXRGb3J3YXJk RXZlbnQod2Via2l0V2ViVmlld0Jhc2UpOyAKKyAgICAgICAgd2Via2l0V2ViVmlld0Jhc2VEaWRO b3RIYW5kbGVLZXlFdmVudCh3ZWJraXRXZWJWaWV3QmFzZSwgZXZlbnQubmF0aXZlRXZlbnQoKSk7 CisgICAgfQogfQogCiBQYXNzUmVmUHRyPFdlYlBvcHVwTWVudVByb3h5PiBQYWdlQ2xpZW50SW1w bDo6Y3JlYXRlUG9wdXBNZW51UHJveHkoV2ViUGFnZVByb3h5KiBwYWdlKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmgKaW5kZXggNmE1YjVk NS4uNjFiYWI0ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv UGFnZUNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9Q YWdlQ2xpZW50SW1wbC5oCkBAIC03OSw4ICs3OSw2IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBX ZWJDb3JlOjpJbnRQb2ludCBzY3JlZW5Ub1dpbmRvdyhjb25zdCBXZWJDb3JlOjpJbnRQb2ludCYp OwogICAgIHZpcnR1YWwgV2ViQ29yZTo6SW50UmVjdCB3aW5kb3dUb1NjcmVlbihjb25zdCBXZWJD b3JlOjpJbnRSZWN0Jik7CiAgICAgdmlydHVhbCB2b2lkIGRvbmVXaXRoS2V5RXZlbnQoY29uc3Qg TmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJvb2wgd2FzRXZlbnRIYW5kbGVkKTsKLSAgICB2aXJ0 dWFsIHZvaWQgZGlkTm90SGFuZGxlS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVu dCYpOwotICAgIHZpcnR1YWwgdm9pZCBkaWROb3RIYW5kbGVXaGVlbEV2ZW50KGNvbnN0IE5hdGl2 ZVdlYldoZWVsRXZlbnQmKTsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8V2ViUG9wdXBNZW51UHJv eHk+IGNyZWF0ZVBvcHVwTWVudVByb3h5KFdlYlBhZ2VQcm94eSopOwogICAgIHZpcnR1YWwgUGFz c1JlZlB0cjxXZWJDb250ZXh0TWVudVByb3h5PiBjcmVhdGVDb250ZXh0TWVudVByb3h5KFdlYlBh Z2VQcm94eSopOwogICAgIHZpcnR1YWwgdm9pZCBzZXRGaW5kSW5kaWNhdG9yKFBhc3NSZWZQdHI8 RmluZEluZGljYXRvcj4sIGJvb2wgZmFkZU91dCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKaW5kZXggN2ZhZjg0Mi4u ODVjNTA2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViVmlld0Jhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdCYXNlLmNwcApAQCAtNTMsNiArNTMsNyBAQCBzdHJ1Y3QgX1dlYktpdFdl YlZpZXdCYXNlUHJpdmF0ZSB7CiAgICAgT3duUHRyPFBhZ2VDbGllbnRJbXBsPiBwYWdlQ2xpZW50 OwogICAgIFJlZlB0cjxXZWJQYWdlUHJveHk+IHBhZ2VQcm94eTsKICAgICBnYm9vbGVhbiBpc1Bh Z2VBY3RpdmU7CisgICAgZ2Jvb2xlYW4gc2hvdWxkRm9yd2FyZEV2ZW50OwogICAgIEd0a0lNQ29u dGV4dCogaW1Db250ZXh0OwogICAgIEd0a0NsaWNrQ291bnRlciBjbGlja0NvdW50ZXI7CiAgICAg Q1N0cmluZyB0b29sdGlwVGV4dDsKQEAgLTEyOSw2ICsxMzAsNyBAQCBzdGF0aWMgdm9pZCB3ZWJr aXRfd2ViX3ZpZXdfYmFzZV9pbml0KFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJraXRXZWJWaWV3QmFz ZSkKICAgICB3ZWJraXRXZWJWaWV3QmFzZS0+cHJpdiA9IHByaXY7CiAKICAgICBwcml2LT5pc1Bh Z2VBY3RpdmUgPSBUUlVFOworICAgIHByaXYtPnNob3VsZEZvcndhcmRFdmVudCA9IEZBTFNFOwog CiAgICAgZ3RrX3dpZGdldF9zZXRfZG91YmxlX2J1ZmZlcmVkKEdUS19XSURHRVQod2Via2l0V2Vi Vmlld0Jhc2UpLCBGQUxTRSk7CiAgICAgZ3RrX3dpZGdldF9zZXRfY2FuX2ZvY3VzKEdUS19XSURH RVQod2Via2l0V2ViVmlld0Jhc2UpLCBUUlVFKTsKQEAgLTIwMCw5ICsyMDIsMTYgQEAgc3RhdGlj IGdib29sZWFuIHdlYmtpdFdlYlZpZXdCYXNlS2V5UHJlc3NFdmVudChHdGtXaWRnZXQqIHdpZGdl dCwgR2RrRXZlbnRLZXkqIGUKICAgICBXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UgPSBX RUJLSVRfV0VCX1ZJRVdfQkFTRSh3aWRnZXQpOwogICAgIFdlYktpdFdlYlZpZXdCYXNlUHJpdmF0 ZSogcHJpdiA9IHdlYlZpZXdCYXNlLT5wcml2OwogCisgICAgLy8gU2luY2UgV2ViUHJvY2VzcyBr ZXkgZXZlbnQgaGFuZGxpbmcgaXMgbm90IHN5bmNocm9ub3VzLCBtYWtlIGl0IDItcGFzcyBoYW5k bGluZy4KKyAgICAvLyBGaXJzdCwgYWx3YXlzIHJldHVybiBUUlVFIGluIGV2ZW50IGhhbmRsZXIu CisgICAgLy8gU2Vjb25kLCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCByZXR1cm4g c3RhdHVzIG9mIGV2ZW50IGhhbmRsaW5nIGluIFdlYlByb2Nlc3MuCisgICAgLy8gVGhpcmQsIHVz aW5nIHN0YXR1cywgZGV0ZXJtaW5lIHdoZXRoZXIgdG8gcGFzcyB0aGUgZXZlbnQgdG8gcGFyZW50 IG9yIG5vdCB1c2luZyBndGtfbWFpbl9kb19ldmVudCgpLgorICAgIGlmIChwcml2LT5zaG91bGRG b3J3YXJkRXZlbnQpIHsKKyAgICAgICAgcHJpdi0+c2hvdWxkRm9yd2FyZEV2ZW50ID0gRkFMU0U7 CisgICAgICAgIHJldHVybiBHVEtfV0lER0VUX0NMQVNTKHdlYmtpdF93ZWJfdmlld19iYXNlX3Bh cmVudF9jbGFzcyktPmtleV9wcmVzc19ldmVudCh3aWRnZXQsIGV2ZW50KTsKKyAgICB9CiAgICAg cHJpdi0+cGFnZVByb3h5LT5oYW5kbGVLZXlib2FyZEV2ZW50KE5hdGl2ZVdlYktleWJvYXJkRXZl bnQocmVpbnRlcnByZXRfY2FzdDxHZGtFdmVudCo+KGV2ZW50KSkpOwotCi0gICAgcmV0dXJuIEdU S19XSURHRVRfQ0xBU1Mod2Via2l0X3dlYl92aWV3X2Jhc2VfcGFyZW50X2NsYXNzKS0+a2V5X3By ZXNzX2V2ZW50KHdpZGdldCwgZXZlbnQpOworICAgIHJldHVybiBUUlVFOwogfQogCiBzdGF0aWMg Z2Jvb2xlYW4gd2Via2l0V2ViVmlld0Jhc2VLZXlSZWxlYXNlRXZlbnQoR3RrV2lkZ2V0KiB3aWRn ZXQsIEdka0V2ZW50S2V5KiBldmVudCkKQEAgLTIxMyw5ICsyMjIsMTIgQEAgc3RhdGljIGdib29s ZWFuIHdlYmtpdFdlYlZpZXdCYXNlS2V5UmVsZWFzZUV2ZW50KEd0a1dpZGdldCogd2lkZ2V0LCBH ZGtFdmVudEtleSoKICAgICBpZiAoZ3RrX2ltX2NvbnRleHRfZmlsdGVyX2tleXByZXNzKHByaXYt PmltQ29udGV4dCwgZXZlbnQpKQogICAgICAgICByZXR1cm4gVFJVRTsKIAorICAgIGlmIChwcml2 LT5zaG91bGRGb3J3YXJkRXZlbnQpIHsKKyAgICAgICAgcHJpdi0+c2hvdWxkRm9yd2FyZEV2ZW50 ID0gRkFMU0U7CisgICAgICAgIHJldHVybiBHVEtfV0lER0VUX0NMQVNTKHdlYmtpdF93ZWJfdmll d19iYXNlX3BhcmVudF9jbGFzcyktPmtleV9yZWxlYXNlX2V2ZW50KHdpZGdldCwgZXZlbnQpOwor ICAgIH0KICAgICBwcml2LT5wYWdlUHJveHktPmhhbmRsZUtleWJvYXJkRXZlbnQoTmF0aXZlV2Vi S2V5Ym9hcmRFdmVudChyZWludGVycHJldF9jYXN0PEdka0V2ZW50Kj4oZXZlbnQpKSk7Ci0KLSAg ICByZXR1cm4gR1RLX1dJREdFVF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJlbnRfY2xh c3MpLT5rZXlfcmVsZWFzZV9ldmVudCh3aWRnZXQsIGV2ZW50KTsKKyAgICByZXR1cm4gVFJVRTsK IH0KIAogc3RhdGljIGdib29sZWFuIHdlYmtpdFdlYlZpZXdCYXNlQnV0dG9uUHJlc3NFdmVudChH dGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRCdXR0b24qIGJ1dHRvbkV2ZW50KQpAQCAtMzIxLDYg KzMzMywxOCBAQCBXZWJQYWdlUHJveHkqIHdlYmtpdFdlYlZpZXdCYXNlR2V0UGFnZShXZWJLaXRX ZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UpCiAgICAgcmV0dXJuIHdlYmtpdFdlYlZpZXdC YXNlLT5wcml2LT5wYWdlUHJveHkuZ2V0KCk7CiB9CiAKK3ZvaWQgd2Via2l0V2ViVmlld0Jhc2VT ZXRGb3J3YXJkRXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlKQorewor ICAgIFdlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZSogcHJpdiA9IHdlYmtpdFdlYlZpZXdCYXNlLT5w cml2OworICAgIHByaXYtPnNob3VsZEZvcndhcmRFdmVudCA9IFRSVUU7Cit9CisKK3ZvaWQgd2Vi a2l0V2ViVmlld0Jhc2VEaWROb3RIYW5kbGVLZXlFdmVudChXZWJLaXRXZWJWaWV3QmFzZSogd2Vi Vmlld0Jhc2UsIGNvbnN0IEdka0V2ZW50KiBldmVudCkKK3sKKyAgICAvLyBQcm9wYWdlIGtleSBl dmVudCB0byBwYXJlbnQgd2lkZ2V0LgorICAgIGd0a19tYWluX2RvX2V2ZW50KGNvbnN0X2Nhc3Q8 R2RrRXZlbnQqPihldmVudCkpOworfQorCiB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlQ3JlYXRlV2Vi UGFnZShXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UsIFdLQ29udGV4dFJlZiBj b250ZXh0LCBXS1BhZ2VHcm91cFJlZiBwYWdlR3JvdXApCiB7CiAgICAgV2ViS2l0V2ViVmlld0Jh c2VQcml2YXRlKiBwcml2ID0gd2Via2l0V2ViVmlld0Jhc2UtPnByaXY7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUu aCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJp dmF0ZS5oCmluZGV4IDY5OTY3MzguLmNjZThjYWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCkBA IC00Niw2ICs0NiwxMCBAQCB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlQ3JlYXRlV2ViUGFnZShXZWJL aXRXZWJWaWV3QmFzZSosIFdLQ29udGV4dFJlZiwgV0tQYWdlR3JvdQogCiB2b2lkIHdlYmtpdFdl YlZpZXdCYXNlU2V0VG9vbHRpcFRleHQoV2ViS2l0V2ViVmlld0Jhc2UqLCBjb25zdCBjaGFyKik7 CiAKK3ZvaWQgd2Via2l0V2ViVmlld0Jhc2VEaWROb3RIYW5kbGVLZXlFdmVudChXZWJLaXRXZWJW aWV3QmFzZSosIGNvbnN0IEdka0V2ZW50Kik7CisKK3ZvaWQgd2Via2l0V2ViVmlld0Jhc2VTZXRG b3J3YXJkRXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlm IC8vIFdlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZV9oCg== 101854 2011-07-25 00:58:31 -0700 2011-07-26 07:11:09 -0700 Implementation for doneWithKeyEvent for WK2 GTK port tab_issue_fix.diff text/plain 7588 ravi.kasibhatla ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA3NjM2M2E4Li4zYTZhNzljIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQg QEAKKzIwMTEtMDctMjUgIFJhdmkgUGhhbmVlbmRyYSBLYXNpYmhhdGxhICA8cmF2aS5rYXNpYmhh dGxhQG1vdG9yb2xhLmNvbT4KKworICAgICAgICBSZXR1cm4gVFJVRSBhbHdheXMgaW4gV2ViS2l0 V2ViVmlld0Jhc2Ugd2lkZ2V0IGtleV9wcmVzc19ldmVudCBjYWxsYmFjay4KKyAgICAgICAgUGFz cyB0aGUga2V5X3ByZXNzX2V2ZW50IHRvIHBhcmVudCB3aWRnZXQgb25seSB3aGVuIGl0IGlzIG5v dCBoYW5kbGVkIGJ5IFdlYiBQcm9jZXNzLgorICAgICAgICAoaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTY0NzkwKQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3Bw OgorICAgICAgICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCk6IElt cGxlbWVudGVkIGZvciBHVEsgcG9ydCB0byBkZXRlcm1pbmUgd2hldGhlciB0bworICAgICAgICBw YXNzIGtleV9wcmVzc19ldmVudCB0byBwYXJlbnQgd2lkZ2V0IG9yIG5vdC4KKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oOiBEZWxldGVkIG9ic29sZXRlIGZ1bmN0 aW9ucyBkaWROb3RIYW5kbGVLZXlFdmVudCBhbmQKKyAgICAgICAgZGlkTm90SGFuZGxlV2hlZWxF dmVudC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHA6 CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9pbml0KToKKyAgICAgICAgKHdlYmtpdFdl YlZpZXdCYXNlS2V5UHJlc3NFdmVudCk6IFBhc3MgZXZlbnQgdG8gcGFyZW50IHdpZGdldCBkZXBl bmRpbmcgb24gc3RhdHVzIGZyb20gZG9uZVdpdGhLZXlFdmVudC4gCisgICAgICAgICh3ZWJraXRX ZWJWaWV3QmFzZUtleVJlbGVhc2VFdmVudCk6IFBhc3MgZXZlbnQgdG8gcGFyZW50IHdpZGdldCBk ZXBlbmRpbmcgb24gc3RhdHVzIGZyb20gZG9uZVdpdGhLZXlFdmVudC4KKyAgICAgICAgKHdlYmtp dFdlYlZpZXdCYXNlU2V0Rm9yd2FyZEV2ZW50KTogU2V0IGZsYWcgaW5kaWNhdGluZyB0aGF0IGV2 ZW50IG5lZWRzIHRvIGJlIGZvcndhcmRlZCB0byBwYXJlbnQuCisgICAgICAgICh3ZWJraXRXZWJW aWV3QmFzZURpZE5vdEhhbmRsZUtleUV2ZW50KTogUnVuIGd0a19tYWluX2RvX2V2ZW50KCkuCisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlLmg6IFNp Z25hdHVyZXMgZm9yIG5ld2x5IGFkZGVkIGZ1bmN0aW9ucy4KKwogMjAxMS0wNy0xNyAgQW1ydXRo IFJhaiAgPGFtcnV0aHJhakBtb3Rvcm9sYS5jb20+CiAKICAgICAgICAgW0dUS10gRml4IHNlbGVj dGlvbiBvZiBlbGVtZW50cyBpbiBhIG11bHRpIHNlbGVjdCBsaXN0IGFuZCByZW1vdmUgYW4gdW5u ZWNlc3NhcnkgaW5jbHVkZSBpbiBXb3JrUXVldWUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAppbmRleCBlMGNlMzc0Li5kOTM1OWY3 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50 SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVu dEltcGwuY3BwCkBAIC0yMDUsMTkgKzIwNSwxNCBAQCBJbnRSZWN0IFBhZ2VDbGllbnRJbXBsOjp3 aW5kb3dUb1NjcmVlbihjb25zdCBJbnRSZWN0JiByZWN0KQogICAgIHJldHVybiBJbnRSZWN0KGNv bnZlcnRXaWRnZXRQb2ludFRvU2NyZWVuUG9pbnQobV92aWV3V2lkZ2V0LCByZWN0LmxvY2F0aW9u KCkpLCByZWN0LnNpemUoKSk7CiB9CiAKLXZvaWQgUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoS2V5 RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJvb2wgd2FzRXZlbnRIYW5kbGVk KQotewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLXZvaWQgUGFnZUNsaWVudEltcGw6OmRp ZE5vdEhhbmRsZUtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50KQot ewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci19Ci0KLXZvaWQgUGFnZUNsaWVudEltcGw6OmRpZE5v dEhhbmRsZVdoZWVsRXZlbnQoY29uc3QgTmF0aXZlV2ViV2hlZWxFdmVudCYpCi17Ci0gICAgbm90 SW1wbGVtZW50ZWQoKTsKK3ZvaWQgUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoS2V5RXZlbnQoY29u c3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgZXZlbnQsIGJvb2wgd2FzRXZlbnRIYW5kbGVkKQor eworICAgIGlmICghd2FzRXZlbnRIYW5kbGVkKSB7CisgICAgICAgIFdlYktpdFdlYlZpZXdCYXNl KiB3ZWJraXRXZWJWaWV3QmFzZSA9IFdFQktJVF9XRUJfVklFV19CQVNFKG1fdmlld1dpZGdldCk7 CisgICAgICAgIHdlYmtpdFdlYlZpZXdCYXNlU2V0Rm9yd2FyZEV2ZW50KHdlYmtpdFdlYlZpZXdC YXNlKTsKKyAgICAgICAgR2RrRXZlbnQgaW5wdXRFdmVudCA9ICpldmVudC5uYXRpdmVFdmVudCgp OworICAgICAgICBndGtfbWFpbl9kb19ldmVudCgmaW5wdXRFdmVudCk7CisgICAgfQogfQogCiBQ YXNzUmVmUHRyPFdlYlBvcHVwTWVudVByb3h5PiBQYWdlQ2xpZW50SW1wbDo6Y3JlYXRlUG9wdXBN ZW51UHJveHkoV2ViUGFnZVByb3h5KiBwYWdlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmgKaW5kZXggNmE1YjVkNS4uNjFiYWI0ZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu aAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5o CkBAIC03OSw4ICs3OSw2IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCBXZWJDb3JlOjpJbnRQb2lu dCBzY3JlZW5Ub1dpbmRvdyhjb25zdCBXZWJDb3JlOjpJbnRQb2ludCYpOwogICAgIHZpcnR1YWwg V2ViQ29yZTo6SW50UmVjdCB3aW5kb3dUb1NjcmVlbihjb25zdCBXZWJDb3JlOjpJbnRSZWN0Jik7 CiAgICAgdmlydHVhbCB2b2lkIGRvbmVXaXRoS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9h cmRFdmVudCYsIGJvb2wgd2FzRXZlbnRIYW5kbGVkKTsKLSAgICB2aXJ0dWFsIHZvaWQgZGlkTm90 SGFuZGxlS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYpOwotICAgIHZpcnR1 YWwgdm9pZCBkaWROb3RIYW5kbGVXaGVlbEV2ZW50KGNvbnN0IE5hdGl2ZVdlYldoZWVsRXZlbnQm KTsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8V2ViUG9wdXBNZW51UHJveHk+IGNyZWF0ZVBvcHVw TWVudVByb3h5KFdlYlBhZ2VQcm94eSopOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxXZWJDb250 ZXh0TWVudVByb3h5PiBjcmVhdGVDb250ZXh0TWVudVByb3h5KFdlYlBhZ2VQcm94eSopOwogICAg IHZpcnR1YWwgdm9pZCBzZXRGaW5kSW5kaWNhdG9yKFBhc3NSZWZQdHI8RmluZEluZGljYXRvcj4s IGJvb2wgZmFkZU91dCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKaW5kZXggN2ZhZjg0Mi4uMjA5ZWE3MyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2Uu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdC YXNlLmNwcApAQCAtNTMsNiArNTMsNyBAQCBzdHJ1Y3QgX1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0 ZSB7CiAgICAgT3duUHRyPFBhZ2VDbGllbnRJbXBsPiBwYWdlQ2xpZW50OwogICAgIFJlZlB0cjxX ZWJQYWdlUHJveHk+IHBhZ2VQcm94eTsKICAgICBnYm9vbGVhbiBpc1BhZ2VBY3RpdmU7CisgICAg Z2Jvb2xlYW4gc2hvdWxkRm9yd2FyZEtleWJvYXJkRXZlbnQ7CiAgICAgR3RrSU1Db250ZXh0KiBp bUNvbnRleHQ7CiAgICAgR3RrQ2xpY2tDb3VudGVyIGNsaWNrQ291bnRlcjsKICAgICBDU3RyaW5n IHRvb2x0aXBUZXh0OwpAQCAtMTI5LDYgKzEzMCw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJf dmlld19iYXNlX2luaXQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlKQogICAg IHdlYmtpdFdlYlZpZXdCYXNlLT5wcml2ID0gcHJpdjsKIAogICAgIHByaXYtPmlzUGFnZUFjdGl2 ZSA9IFRSVUU7CisgICAgcHJpdi0+c2hvdWxkRm9yd2FyZEtleWJvYXJkRXZlbnQgPSBGQUxTRTsK IAogICAgIGd0a193aWRnZXRfc2V0X2RvdWJsZV9idWZmZXJlZChHVEtfV0lER0VUKHdlYmtpdFdl YlZpZXdCYXNlKSwgRkFMU0UpOwogICAgIGd0a193aWRnZXRfc2V0X2Nhbl9mb2N1cyhHVEtfV0lE R0VUKHdlYmtpdFdlYlZpZXdCYXNlKSwgVFJVRSk7CkBAIC0yMDAsOSArMjAyLDE2IEBAIHN0YXRp YyBnYm9vbGVhbiB3ZWJraXRXZWJWaWV3QmFzZUtleVByZXNzRXZlbnQoR3RrV2lkZ2V0KiB3aWRn ZXQsIEdka0V2ZW50S2V5KiBlCiAgICAgV2ViS2l0V2ViVmlld0Jhc2UqIHdlYlZpZXdCYXNlID0g V0VCS0lUX1dFQl9WSUVXX0JBU0Uod2lkZ2V0KTsKICAgICBXZWJLaXRXZWJWaWV3QmFzZVByaXZh dGUqIHByaXYgPSB3ZWJWaWV3QmFzZS0+cHJpdjsKIAorICAgIC8vIFNpbmNlIFdlYlByb2Nlc3Mg a2V5IGV2ZW50IGhhbmRsaW5nIGlzIG5vdCBzeW5jaHJvbm91cywgaGFuZGxlIHRoZSBldmVudCBp biB0d28gcGFzc2VzLgorICAgIC8vIFdoZW4gV2ViUHJvY2VzcyBwcm9jZXNzZXMgdGhlIGlucHV0 IGV2ZW50LCBpdCB3aWxsIGNhbGwgUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoS2V5RXZlbnQgCisg ICAgLy8gd2l0aCBldmVudCBoYW5kbGVkIHN0YXR1cyB3aGljaCBkZXRlcm1pbmVzIHdoZXRoZXIg dG8gcGFzcyB0aGUgaW5wdXQgZXZlbnQgdG8gcGFyZW50IG9yIG5vdCAKKyAgICAvLyB1c2luZyBn dGtfbWFpbl9kb19ldmVudCgpLgorICAgIGlmIChwcml2LT5zaG91bGRGb3J3YXJkS2V5Ym9hcmRF dmVudCkgeworICAgICAgICBwcml2LT5zaG91bGRGb3J3YXJkS2V5Ym9hcmRFdmVudCA9IEZBTFNF OworICAgICAgICByZXR1cm4gR1RLX1dJREdFVF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9w YXJlbnRfY2xhc3MpLT5rZXlfcHJlc3NfZXZlbnQod2lkZ2V0LCBldmVudCk7CisgICAgfQogICAg IHByaXYtPnBhZ2VQcm94eS0+aGFuZGxlS2V5Ym9hcmRFdmVudChOYXRpdmVXZWJLZXlib2FyZEV2 ZW50KHJlaW50ZXJwcmV0X2Nhc3Q8R2RrRXZlbnQqPihldmVudCkpKTsKLQotICAgIHJldHVybiBH VEtfV0lER0VUX0NMQVNTKHdlYmtpdF93ZWJfdmlld19iYXNlX3BhcmVudF9jbGFzcyktPmtleV9w cmVzc19ldmVudCh3aWRnZXQsIGV2ZW50KTsKKyAgICByZXR1cm4gVFJVRTsKIH0KIAogc3RhdGlj IGdib29sZWFuIHdlYmtpdFdlYlZpZXdCYXNlS2V5UmVsZWFzZUV2ZW50KEd0a1dpZGdldCogd2lk Z2V0LCBHZGtFdmVudEtleSogZXZlbnQpCkBAIC0yMTMsOSArMjIyLDEyIEBAIHN0YXRpYyBnYm9v bGVhbiB3ZWJraXRXZWJWaWV3QmFzZUtleVJlbGVhc2VFdmVudChHdGtXaWRnZXQqIHdpZGdldCwg R2RrRXZlbnRLZXkqCiAgICAgaWYgKGd0a19pbV9jb250ZXh0X2ZpbHRlcl9rZXlwcmVzcyhwcml2 LT5pbUNvbnRleHQsIGV2ZW50KSkKICAgICAgICAgcmV0dXJuIFRSVUU7CiAKKyAgICBpZiAocHJp di0+c2hvdWxkRm9yd2FyZEtleWJvYXJkRXZlbnQpIHsKKyAgICAgICAgcHJpdi0+c2hvdWxkRm9y d2FyZEtleWJvYXJkRXZlbnQgPSBGQUxTRTsKKyAgICAgICAgcmV0dXJuIEdUS19XSURHRVRfQ0xB U1Mod2Via2l0X3dlYl92aWV3X2Jhc2VfcGFyZW50X2NsYXNzKS0+a2V5X3JlbGVhc2VfZXZlbnQo d2lkZ2V0LCBldmVudCk7CisgICAgfQogICAgIHByaXYtPnBhZ2VQcm94eS0+aGFuZGxlS2V5Ym9h cmRFdmVudChOYXRpdmVXZWJLZXlib2FyZEV2ZW50KHJlaW50ZXJwcmV0X2Nhc3Q8R2RrRXZlbnQq PihldmVudCkpKTsKLQotICAgIHJldHVybiBHVEtfV0lER0VUX0NMQVNTKHdlYmtpdF93ZWJfdmll d19iYXNlX3BhcmVudF9jbGFzcyktPmtleV9yZWxlYXNlX2V2ZW50KHdpZGdldCwgZXZlbnQpOwor ICAgIHJldHVybiBUUlVFOwogfQogCiBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2ViVmlld0Jhc2VC dXR0b25QcmVzc0V2ZW50KEd0a1dpZGdldCogd2lkZ2V0LCBHZGtFdmVudEJ1dHRvbiogYnV0dG9u RXZlbnQpCkBAIC0zMjEsNiArMzMzLDExIEBAIFdlYlBhZ2VQcm94eSogd2Via2l0V2ViVmlld0Jh c2VHZXRQYWdlKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJraXRXZWJWaWV3QmFzZSkKICAgICByZXR1 cm4gd2Via2l0V2ViVmlld0Jhc2UtPnByaXYtPnBhZ2VQcm94eS5nZXQoKTsKIH0KIAordm9pZCB3 ZWJraXRXZWJWaWV3QmFzZVNldEZvcndhcmRFdmVudChXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0 V2ViVmlld0Jhc2UpCit7CisgICAgd2Via2l0V2ViVmlld0Jhc2UtPnByaXYtPnNob3VsZEZvcndh cmRLZXlib2FyZEV2ZW50ID0gVFJVRTsKK30KKwogdm9pZCB3ZWJraXRXZWJWaWV3QmFzZUNyZWF0 ZVdlYlBhZ2UoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlLCBXS0NvbnRleHRS ZWYgY29udGV4dCwgV0tQYWdlR3JvdXBSZWYgcGFnZUdyb3VwKQogewogICAgIFdlYktpdFdlYlZp ZXdCYXNlUHJpdmF0ZSogcHJpdiA9IHdlYmtpdFdlYlZpZXdCYXNlLT5wcml2OwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2VQcml2 YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFz ZVByaXZhdGUuaAppbmRleCA2OTk2NzM4Li5lZDEwZTkxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaAorKysgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUu aApAQCAtNDYsNiArNDYsOCBAQCB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlQ3JlYXRlV2ViUGFnZShX ZWJLaXRXZWJWaWV3QmFzZSosIFdLQ29udGV4dFJlZiwgV0tQYWdlR3JvdQogCiB2b2lkIHdlYmtp dFdlYlZpZXdCYXNlU2V0VG9vbHRpcFRleHQoV2ViS2l0V2ViVmlld0Jhc2UqLCBjb25zdCBjaGFy Kik7CiAKK3ZvaWQgd2Via2l0V2ViVmlld0Jhc2VTZXRGb3J3YXJkRXZlbnQoV2ViS2l0V2ViVmll d0Jhc2UqKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmIC8vIFdlYktpdFdlYlZpZXdCYXNlUHJp dmF0ZV9oCg== 101997 2011-07-26 07:10:21 -0700 2011-07-28 07:49:09 -0700 Implementation for doneWithKeyEvent for WK2 GTK port - revision 4 tab_issue_fix.diff text/plain 8521 ravi.kasibhatla ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA3NjM2M2E4Li5jYjNmMWFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEg QEAKKzIwMTEtMDctMjYgIFJhdmkgUGhhbmVlbmRyYSBLYXNpYmhhdGxhICA8cmF2aS5rYXNpYmhh dGxhQG1vdG9yb2xhLmNvbT4KKworICAgICAgICBQYXNzIHRoZSBrZXlfcHJlc3NfZXZlbnQgb3Ig a2V5X3JlbGVhc2VfZXZlbnQgdG8gcGFyZW50IHdpZGdldCB3aGVuIGl0IGlzIG5vdCBoYW5kbGVk IGJ5IFdlYiBQcm9jZXNzLgorICAgICAgICAoaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTY0NzkwKQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwOgorICAgICAg ICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCk6IEltcGxlbWVudGVk IGZvciBHVEsgcG9ydC4gU2V0cyBmbGFnIGlmIHRoZSBrZXlib2FyZCBldmVudCAKKyAgICAgICAg bmVlZHMgdG8gYmUgcGFzc2VkIHRvIHRoZSBwYXJlbnQgd2lkZ2V0LiBJbnZva2UgZ3RrX21haW5f ZG9fZXZlbnQoKSBpZiBldmVudCBuZWVkcyB0byBiZSBwYXNzZWQgdG8gcGFyZW50LgorICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmg6IERlbGV0ZWQgb2Jzb2xldGUg ZnVuY3Rpb25zIGRpZE5vdEhhbmRsZUtleUV2ZW50IGFuZAorICAgICAgICBkaWROb3RIYW5kbGVX aGVlbEV2ZW50LgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNl LmNwcDoKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19iYXNlX2luaXQpOgorICAgICAgICAod2Vi a2l0V2ViVmlld0Jhc2VLZXlQcmVzc0V2ZW50KTogUGFzcyBldmVudCB0byBwYXJlbnQgd2lkZ2V0 IGRlcGVuZGluZyBvbiBzdGF0dXMgZnJvbSBkb25lV2l0aEtleUV2ZW50LiAKKyAgICAgICAgKHdl YmtpdFdlYlZpZXdCYXNlS2V5UmVsZWFzZUV2ZW50KTogUGFzcyBldmVudCB0byBwYXJlbnQgd2lk Z2V0IGRlcGVuZGluZyBvbiBzdGF0dXMgZnJvbSBkb25lV2l0aEtleUV2ZW50LgorICAgICAgICAq IFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oOiBNb3ZlZCB0aGUg ZGVmaW5pdGlvbiBvZiBzdHJ1Y3R1cmUgV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlLgorCiAyMDEx LTA3LTE3ICBBbXJ1dGggUmFqICA8YW1ydXRocmFqQG1vdG9yb2xhLmNvbT4KIAogICAgICAgICBb R1RLXSBGaXggc2VsZWN0aW9uIG9mIGVsZW1lbnRzIGluIGEgbXVsdGkgc2VsZWN0IGxpc3QgYW5k IHJlbW92ZSBhbiB1bm5lY2Vzc2FyeSBpbmNsdWRlIGluIFdvcmtRdWV1ZQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCmluZGV4IGUw Y2UzNzQuLjEwZTllNWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL1BhZ2VDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTIwNSwxOSArMjA1LDE5IEBAIEludFJlY3QgUGFn ZUNsaWVudEltcGw6OndpbmRvd1RvU2NyZWVuKGNvbnN0IEludFJlY3QmIHJlY3QpCiAgICAgcmV0 dXJuIEludFJlY3QoY29udmVydFdpZGdldFBvaW50VG9TY3JlZW5Qb2ludChtX3ZpZXdXaWRnZXQs IHJlY3QubG9jYXRpb24oKSksIHJlY3Quc2l6ZSgpKTsKIH0KIAotdm9pZCBQYWdlQ2xpZW50SW1w bDo6ZG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCB3 YXNFdmVudEhhbmRsZWQpCit2b2lkIFBhZ2VDbGllbnRJbXBsOjpkb25lV2l0aEtleUV2ZW50KGNv bnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50LCBib29sIHdhc0V2ZW50SGFuZGxlZCkK IHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotfQorICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCisg ICAgICAgIHJldHVybjsKIAotdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZGlkTm90SGFuZGxlS2V5RXZl bnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgZXZlbnQpCi17Ci0gICAgbm90SW1wbGVt ZW50ZWQoKTsKLX0KKyAgICBXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UgPSBX RUJLSVRfV0VCX1ZJRVdfQkFTRShtX3ZpZXdXaWRnZXQpOworICAgIGlmIChldmVudC50eXBlKCkg PT0gV2ViS2l0OjpXZWJFdmVudDo6S2V5RG93bikKKyAgICAgICAgd2Via2l0V2ViVmlld0Jhc2Ut PnByaXYtPnNob3VsZEZvcndhcmROZXh0S2V5Ym9hcmRFdmVudCA9IENoYWluS2V5UHJlc3M7Cisg ICAgZWxzZSBpZiAoZXZlbnQudHlwZSgpID09IFdlYktpdDo6V2ViRXZlbnQ6OktleVVwKQorICAg ICAgICB3ZWJraXRXZWJWaWV3QmFzZS0+cHJpdi0+c2hvdWxkRm9yd2FyZE5leHRLZXlib2FyZEV2 ZW50ID0gQ2hhaW5LZXlSZWxlYXNlOwogCi12b2lkIFBhZ2VDbGllbnRJbXBsOjpkaWROb3RIYW5k bGVXaGVlbEV2ZW50KGNvbnN0IE5hdGl2ZVdlYldoZWVsRXZlbnQmKQotewotICAgIG5vdEltcGxl bWVudGVkKCk7CisgICAgR093blB0cjxHZGtFdmVudD4gaW5wdXRFdmVudChnZGtfZXZlbnRfY29w eShldmVudC5uYXRpdmVFdmVudCgpKSk7CisgICAgZ3RrX21haW5fZG9fZXZlbnQoaW5wdXRFdmVu dC5nZXQoKSk7CiB9CiAKIFBhc3NSZWZQdHI8V2ViUG9wdXBNZW51UHJveHk+IFBhZ2VDbGllbnRJ bXBsOjpjcmVhdGVQb3B1cE1lbnVQcm94eShXZWJQYWdlUHJveHkqIHBhZ2UpCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaAppbmRleCA2YTVi NWQ1Li42MWJhYjRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9QYWdlQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1BhZ2VDbGllbnRJbXBsLmgKQEAgLTc5LDggKzc5LDYgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFs IFdlYkNvcmU6OkludFBvaW50IHNjcmVlblRvV2luZG93KGNvbnN0IFdlYkNvcmU6OkludFBvaW50 Jik7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpJbnRSZWN0IHdpbmRvd1RvU2NyZWVuKGNvbnN0IFdl YkNvcmU6OkludFJlY3QmKTsKICAgICB2aXJ0dWFsIHZvaWQgZG9uZVdpdGhLZXlFdmVudChjb25z dCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCB3YXNFdmVudEhhbmRsZWQpOwotICAgIHZp cnR1YWwgdm9pZCBkaWROb3RIYW5kbGVLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2 ZW50Jik7Ci0gICAgdmlydHVhbCB2b2lkIGRpZE5vdEhhbmRsZVdoZWVsRXZlbnQoY29uc3QgTmF0 aXZlV2ViV2hlZWxFdmVudCYpOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxXZWJQb3B1cE1lbnVQ cm94eT4gY3JlYXRlUG9wdXBNZW51UHJveHkoV2ViUGFnZVByb3h5Kik7CiAgICAgdmlydHVhbCBQ YXNzUmVmUHRyPFdlYkNvbnRleHRNZW51UHJveHk+IGNyZWF0ZUNvbnRleHRNZW51UHJveHkoV2Vi UGFnZVByb3h5Kik7CiAgICAgdmlydHVhbCB2b2lkIHNldEZpbmRJbmRpY2F0b3IoUGFzc1JlZlB0 cjxGaW5kSW5kaWNhdG9yPiwgYm9vbCBmYWRlT3V0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcAppbmRleCA3ZmFmODQy Li5jNzE4M2E5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJWaWV3QmFzZS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCkBAIC0zMCwxMyArMzAsMTEgQEAKIAogI2luY2x1ZGUg IkRyYXdpbmdBcmVhUHJveHlJbXBsLmgiCiAjaW5jbHVkZSAiR093blB0ckd0ay5oIgotI2luY2x1 ZGUgIkd0a0NsaWNrQ291bnRlci5oIgogI2luY2x1ZGUgIkd0a1ZlcnNpb25pbmcuaCIKICNpbmNs dWRlICJOYXRpdmVXZWJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiTmF0aXZlV2ViTW91c2VF dmVudC5oIgogI2luY2x1ZGUgIk5hdGl2ZVdlYldoZWVsRXZlbnQuaCIKICNpbmNsdWRlICJOb3RJ bXBsZW1lbnRlZC5oIgotI2luY2x1ZGUgIlBhZ2VDbGllbnRJbXBsLmgiCiAjaW5jbHVkZSAiUmVm UHRyQ2Fpcm8uaCIKICNpbmNsdWRlICJSZWdpb24uaCIKICNpbmNsdWRlICJXZWJDb250ZXh0Lmgi CkBAIC00NCwyMCArNDIsMTAgQEAKICNpbmNsdWRlICJXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUu aCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHkuaCIKICNpbmNsdWRlIDxXZWJLaXQyL1dLQ29udGV4 dC5oPgotI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KIAogdXNpbmcgbmFtZXNwYWNlIFdl YktpdDsKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCi1zdHJ1Y3QgX1dlYktpdFdlYlZpZXdC YXNlUHJpdmF0ZSB7Ci0gICAgT3duUHRyPFBhZ2VDbGllbnRJbXBsPiBwYWdlQ2xpZW50OwotICAg IFJlZlB0cjxXZWJQYWdlUHJveHk+IHBhZ2VQcm94eTsKLSAgICBnYm9vbGVhbiBpc1BhZ2VBY3Rp dmU7Ci0gICAgR3RrSU1Db250ZXh0KiBpbUNvbnRleHQ7Ci0gICAgR3RrQ2xpY2tDb3VudGVyIGNs aWNrQ291bnRlcjsKLSAgICBDU3RyaW5nIHRvb2x0aXBUZXh0OwotfTsKLQogR19ERUZJTkVfVFlQ RShXZWJLaXRXZWJWaWV3QmFzZSwgd2Via2l0X3dlYl92aWV3X2Jhc2UsIEdUS19UWVBFX0NPTlRB SU5FUikKIAogc3RhdGljIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VSZWFsaXplKEd0a1dpZGdldCog d2lkZ2V0KQpAQCAtMTI5LDYgKzExNyw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19i YXNlX2luaXQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlKQogICAgIHdlYmtp dFdlYlZpZXdCYXNlLT5wcml2ID0gcHJpdjsKIAogICAgIHByaXYtPmlzUGFnZUFjdGl2ZSA9IFRS VUU7CisgICAgcHJpdi0+c2hvdWxkRm9yd2FyZE5leHRLZXlib2FyZEV2ZW50ID0gQ2hhaW5Ob25l OwogCiAgICAgZ3RrX3dpZGdldF9zZXRfZG91YmxlX2J1ZmZlcmVkKEdUS19XSURHRVQod2Via2l0 V2ViVmlld0Jhc2UpLCBGQUxTRSk7CiAgICAgZ3RrX3dpZGdldF9zZXRfY2FuX2ZvY3VzKEdUS19X SURHRVQod2Via2l0V2ViVmlld0Jhc2UpLCBUUlVFKTsKQEAgLTIwMCw5ICsxODksMTYgQEAgc3Rh dGljIGdib29sZWFuIHdlYmtpdFdlYlZpZXdCYXNlS2V5UHJlc3NFdmVudChHdGtXaWRnZXQqIHdp ZGdldCwgR2RrRXZlbnRLZXkqIGUKICAgICBXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2Ug PSBXRUJLSVRfV0VCX1ZJRVdfQkFTRSh3aWRnZXQpOwogICAgIFdlYktpdFdlYlZpZXdCYXNlUHJp dmF0ZSogcHJpdiA9IHdlYlZpZXdCYXNlLT5wcml2OwogCisgICAgLy8gU2luY2UgV2ViUHJvY2Vz cyBrZXkgZXZlbnQgaGFuZGxpbmcgaXMgbm90IHN5bmNocm9ub3VzLCBoYW5kbGUgdGhlIGV2ZW50 IGluIHR3byBwYXNzZXMuCisgICAgLy8gV2hlbiBXZWJQcm9jZXNzIHByb2Nlc3NlcyB0aGUgaW5w dXQgZXZlbnQsIGl0IHdpbGwgY2FsbCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCAK KyAgICAvLyB3aXRoIGV2ZW50IGhhbmRsZWQgc3RhdHVzIHdoaWNoIGRldGVybWluZXMgd2hldGhl ciB0byBwYXNzIHRoZSBpbnB1dCBldmVudCB0byBwYXJlbnQgb3Igbm90IAorICAgIC8vIHVzaW5n IGd0a19tYWluX2RvX2V2ZW50KCkuCisgICAgaWYgKHByaXYtPnNob3VsZEZvcndhcmROZXh0S2V5 Ym9hcmRFdmVudCA9PSBDaGFpbktleVByZXNzKSB7CisgICAgICAgIHByaXYtPnNob3VsZEZvcndh cmROZXh0S2V5Ym9hcmRFdmVudCA9IENoYWluTm9uZTsKKyAgICAgICAgcmV0dXJuIEdUS19XSURH RVRfQ0xBU1Mod2Via2l0X3dlYl92aWV3X2Jhc2VfcGFyZW50X2NsYXNzKS0+a2V5X3ByZXNzX2V2 ZW50KHdpZGdldCwgZXZlbnQpOworICAgIH0KICAgICBwcml2LT5wYWdlUHJveHktPmhhbmRsZUtl eWJvYXJkRXZlbnQoTmF0aXZlV2ViS2V5Ym9hcmRFdmVudChyZWludGVycHJldF9jYXN0PEdka0V2 ZW50Kj4oZXZlbnQpKSk7Ci0KLSAgICByZXR1cm4gR1RLX1dJREdFVF9DTEFTUyh3ZWJraXRfd2Vi X3ZpZXdfYmFzZV9wYXJlbnRfY2xhc3MpLT5rZXlfcHJlc3NfZXZlbnQod2lkZ2V0LCBldmVudCk7 CisgICAgcmV0dXJuIFRSVUU7CiB9CiAKIHN0YXRpYyBnYm9vbGVhbiB3ZWJraXRXZWJWaWV3QmFz ZUtleVJlbGVhc2VFdmVudChHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRLZXkqIGV2ZW50KQpA QCAtMjEzLDkgKzIwOSwxMiBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2ViVmlld0Jhc2VLZXlS ZWxlYXNlRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KgogICAgIGlmIChndGtf aW1fY29udGV4dF9maWx0ZXJfa2V5cHJlc3MocHJpdi0+aW1Db250ZXh0LCBldmVudCkpCiAgICAg ICAgIHJldHVybiBUUlVFOwogCisgICAgaWYgKHByaXYtPnNob3VsZEZvcndhcmROZXh0S2V5Ym9h cmRFdmVudCA9PSBDaGFpbktleVJlbGVhc2UpIHsKKyAgICAgICAgcHJpdi0+c2hvdWxkRm9yd2Fy ZE5leHRLZXlib2FyZEV2ZW50ID0gQ2hhaW5Ob25lOworICAgICAgICByZXR1cm4gR1RLX1dJREdF VF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJlbnRfY2xhc3MpLT5rZXlfcmVsZWFzZV9l dmVudCh3aWRnZXQsIGV2ZW50KTsKKyAgICB9CiAgICAgcHJpdi0+cGFnZVByb3h5LT5oYW5kbGVL ZXlib2FyZEV2ZW50KE5hdGl2ZVdlYktleWJvYXJkRXZlbnQocmVpbnRlcnByZXRfY2FzdDxHZGtF dmVudCo+KGV2ZW50KSkpOwotCi0gICAgcmV0dXJuIEdUS19XSURHRVRfQ0xBU1Mod2Via2l0X3dl Yl92aWV3X2Jhc2VfcGFyZW50X2NsYXNzKS0+a2V5X3JlbGVhc2VfZXZlbnQod2lkZ2V0LCBldmVu dCk7CisgICAgcmV0dXJuIFRSVUU7CiB9CiAKIHN0YXRpYyBnYm9vbGVhbiB3ZWJraXRXZWJWaWV3 QmFzZUJ1dHRvblByZXNzRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50QnV0dG9uKiBi dXR0b25FdmVudCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlLmgKaW5kZXggNjk5NjczOC4uNmNlMmVlOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmll d0Jhc2VQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViVmlld0Jhc2VQcml2YXRlLmgKQEAgLTI4LDE0ICsyOCwzNiBAQAogI2lmbmRlZiBXZWJL aXRXZWJWaWV3QmFzZVByaXZhdGVfaAogI2RlZmluZSBXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGVf aAogCisjaW5jbHVkZSAiR3RrQ2xpY2tDb3VudGVyLmgiCisjaW5jbHVkZSAiUGFnZUNsaWVudElt cGwuaCIKICNpbmNsdWRlICJXZWJLaXRXZWJWaWV3QmFzZS5oIgogI2luY2x1ZGUgIldlYlBhZ2VQ cm94eS5oIgogI2luY2x1ZGUgPFdlYktpdDIvV2ViS2l0Mi5oPgorI2luY2x1ZGUgPGd0ay9ndGsu aD4KKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAog R19CRUdJTl9ERUNMUwogCitlbnVtIENoYWluRXZlbnRzIHsKKyAgICBDaGFpbk5vbmUsCisgICAg Q2hhaW5LZXlQcmVzcywKKyAgICBDaGFpbktleVJlbGVhc2UKK307CisKK3N0cnVjdCBfV2ViS2l0 V2ViVmlld0Jhc2VQcml2YXRlIHsKKyAgICBPd25QdHI8UGFnZUNsaWVudEltcGw+IHBhZ2VDbGll bnQ7CisgICAgUmVmUHRyPFdlYlBhZ2VQcm94eT4gcGFnZVByb3h5OworICAgIGdib29sZWFuIGlz UGFnZUFjdGl2ZTsKKyAgICBDaGFpbkV2ZW50cyBzaG91bGRGb3J3YXJkTmV4dEtleWJvYXJkRXZl bnQ7CisgICAgR3RrSU1Db250ZXh0KiBpbUNvbnRleHQ7CisgICAgV2ViQ29yZTo6R3RrQ2xpY2tD b3VudGVyIGNsaWNrQ291bnRlcjsKKyAgICBXVEY6OkNTdHJpbmcgdG9vbHRpcFRleHQ7Cit9Owor CiBXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2VDcmVhdGUoV2ViQ29udGV4dCos IFdlYlBhZ2VHcm91cCopOwogCiBHdGtJTUNvbnRleHQqIHdlYmtpdFdlYlZpZXdCYXNlR2V0SU1D b250ZXh0KFdlYktpdFdlYlZpZXdCYXNlKik7Cg== 102258 2011-07-28 07:49:09 -0700 2011-07-28 10:25:00 -0700 Implementation for doneWithKeyEvent for WK2 GTK port - revision 5 tab_issue_fix.diff text/plain 8092 ravi.kasibhatla ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA3NjM2M2E4Li4xYThhYmU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMg QEAKKzIwMTEtMDctMjggIFJhdmkgUGhhbmVlbmRyYSBLYXNpYmhhdGxhICA8cmF2aS5rYXNpYmhh dGxhQG1vdG9yb2xhLmNvbT4KKworICAgICAgICBQYXNzIHRoZSBrZXlfcHJlc3NfZXZlbnQgb3Ig a2V5X3JlbGVhc2VfZXZlbnQgdG8gcGFyZW50IHdpZGdldCB3aGVuIGl0IGlzIG5vdCBoYW5kbGVk IGJ5IFdlYiBQcm9jZXNzLgorICAgICAgICAoaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTY0NzkwKQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogU2hhcmVkL05hdGl2ZVdlYktleWJvYXJkRXZlbnQuaDoKKyAgICAgICAgKFdl YktpdDo6TmF0aXZlV2ViS2V5Ym9hcmRFdmVudDo6bmF0aXZlRXZlbnQpOiBSZXR1cm4gYSBHZGtF dmVudCogaW5zdGVhZCBvZiBjb25zdCBHZGtFdmVudCogKG5vbi1jb25zdCkuCisgICAgICAgICog VUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpQ YWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCk6IEltcGxlbWVudGVkIGZvciBHVEsgcG9y dC4gU2V0cyBmbGFnIGlmIHRoZSBrZXlib2FyZCBldmVudCAKKyAgICAgICAgbmVlZHMgdG8gYmUg cGFzc2VkIHRvIHRoZSBwYXJlbnQgd2lkZ2V0LiBJbnZva2UgZ3RrX21haW5fZG9fZXZlbnQoKSBp ZiBldmVudCBuZWVkcyB0byBiZSBwYXNzZWQgdG8gcGFyZW50LgorICAgICAgICAqIFVJUHJvY2Vz cy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmg6IERlbGV0ZWQgb2Jzb2xldGUgZnVuY3Rpb25zIGRp ZE5vdEhhbmRsZUtleUV2ZW50ICYgZGlkTm90SGFuZGxlV2hlZWxFdmVudC4KKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHA6CisgICAgICAgICh3ZWJraXRf d2ViX3ZpZXdfYmFzZV9pbml0KTogSW5pdGlhbGl6ZSBzaG91bGRGb3J3YXJkTmV4dEtleUV2ZW50 IGZsYWcuCisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZUtleVByZXNzRXZlbnQpOiBQYXNzIGV2 ZW50IHRvIHBhcmVudCB3aWRnZXQgZGVwZW5kaW5nIG9uIHN0YXR1cyBmcm9tIGRvbmVXaXRoS2V5 RXZlbnQuIAorICAgICAgICAod2Via2l0V2ViVmlld0Jhc2VLZXlSZWxlYXNlRXZlbnQpOiBQYXNz IGV2ZW50IHRvIHBhcmVudCB3aWRnZXQgZGVwZW5kaW5nIG9uIHN0YXR1cyBmcm9tIGRvbmVXaXRo S2V5RXZlbnQuCisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZUZvcndhcmROZXh0S2V5RXZlbnQp OiBBUEkgdG8gc2V0IGZsYWcgc2hvdWxkRm9yd2FyZE5leHRLZXlFdmVudC4KKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaDogQWRkZWQgQVBJIHRv IHNldCBzaG91bGRGb3J3YXJkTmV4dEtleUV2ZW50IGZsYWcuCisKIDIwMTEtMDctMTcgIEFtcnV0 aCBSYWogIDxhbXJ1dGhyYWpAbW90b3JvbGEuY29tPgogCiAgICAgICAgIFtHVEtdIEZpeCBzZWxl Y3Rpb24gb2YgZWxlbWVudHMgaW4gYSBtdWx0aSBzZWxlY3QgbGlzdCBhbmQgcmVtb3ZlIGFuIHVu bmVjZXNzYXJ5IGluY2x1ZGUgaW4gV29ya1F1ZXVlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9TaGFyZWQvTmF0aXZlV2ViS2V5Ym9hcmRFdmVudC5oIGIvU291cmNlL1dlYktpdDIvU2hhcmVk L05hdGl2ZVdlYktleWJvYXJkRXZlbnQuaAppbmRleCA2ZjY2NTZkLi43NzhjMGYyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvTmF0aXZlV2ViS2V5Ym9hcmRFdmVudC5oCisrKyBi L1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9OYXRpdmVXZWJLZXlib2FyZEV2ZW50LmgKQEAgLTY3LDcg KzY3LDcgQEAgcHVibGljOgogI2VsaWYgUExBVEZPUk0oUVQpCiAgICAgY29uc3QgUUtleUV2ZW50 KiBuYXRpdmVFdmVudCgpIGNvbnN0IHsgcmV0dXJuICZtX25hdGl2ZUV2ZW50OyB9CiAjZWxpZiBQ TEFURk9STShHVEspCi0gICAgY29uc3QgR2RrRXZlbnQqIG5hdGl2ZUV2ZW50KCkgY29uc3QgeyBy ZXR1cm4gbV9uYXRpdmVFdmVudC5nZXQoKTsgfQorICAgIEdka0V2ZW50KiBuYXRpdmVFdmVudCgp IGNvbnN0IHsgcmV0dXJuIG1fbmF0aXZlRXZlbnQuZ2V0KCk7IH0KICNlbGlmIFBMQVRGT1JNKEVG TCkKICAgICBjb25zdCB2b2lkKiBuYXRpdmVFdmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fbmF0aXZl RXZlbnQ7IH0KICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvUGFnZUNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvUGFnZUNsaWVudEltcGwuY3BwCmluZGV4IGUwY2UzNzQuLjlhM2ViYmIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAg LTIwNSwxOSArMjA1LDE0IEBAIEludFJlY3QgUGFnZUNsaWVudEltcGw6OndpbmRvd1RvU2NyZWVu KGNvbnN0IEludFJlY3QmIHJlY3QpCiAgICAgcmV0dXJuIEludFJlY3QoY29udmVydFdpZGdldFBv aW50VG9TY3JlZW5Qb2ludChtX3ZpZXdXaWRnZXQsIHJlY3QubG9jYXRpb24oKSksIHJlY3Quc2l6 ZSgpKTsKIH0KIAotdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudChjb25zdCBO YXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCB3YXNFdmVudEhhbmRsZWQpCit2b2lkIFBhZ2VD bGllbnRJbXBsOjpkb25lV2l0aEtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQm IGV2ZW50LCBib29sIHdhc0V2ZW50SGFuZGxlZCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwot fQotCi12b2lkIFBhZ2VDbGllbnRJbXBsOjpkaWROb3RIYW5kbGVLZXlFdmVudChjb25zdCBOYXRp dmVXZWJLZXlib2FyZEV2ZW50JiBldmVudCkKLXsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotfQor ICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCisgICAgICAgIHJldHVybjsKIAotdm9pZCBQYWdlQ2xp ZW50SW1wbDo6ZGlkTm90SGFuZGxlV2hlZWxFdmVudChjb25zdCBOYXRpdmVXZWJXaGVlbEV2ZW50 JikKLXsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJr aXRXZWJWaWV3QmFzZSA9IFdFQktJVF9XRUJfVklFV19CQVNFKG1fdmlld1dpZGdldCk7CisgICAg d2Via2l0V2ViVmlld0Jhc2VGb3J3YXJkTmV4dEtleUV2ZW50KHdlYmtpdFdlYlZpZXdCYXNlKTsK KyAgICBndGtfbWFpbl9kb19ldmVudChldmVudC5uYXRpdmVFdmVudCgpKTsKIH0KIAogUGFzc1Jl ZlB0cjxXZWJQb3B1cE1lbnVQcm94eT4gUGFnZUNsaWVudEltcGw6OmNyZWF0ZVBvcHVwTWVudVBy b3h5KFdlYlBhZ2VQcm94eSogcGFnZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oCmluZGV4IDZhNWI1ZDUuLjYxYmFiNGQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmgKKysr IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaApAQCAt NzksOCArNzksNiBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgV2ViQ29yZTo6SW50UG9pbnQgc2Ny ZWVuVG9XaW5kb3coY29uc3QgV2ViQ29yZTo6SW50UG9pbnQmKTsKICAgICB2aXJ0dWFsIFdlYkNv cmU6OkludFJlY3Qgd2luZG93VG9TY3JlZW4oY29uc3QgV2ViQ29yZTo6SW50UmVjdCYpOwogICAg IHZpcnR1YWwgdm9pZCBkb25lV2l0aEtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZl bnQmLCBib29sIHdhc0V2ZW50SGFuZGxlZCk7Ci0gICAgdmlydHVhbCB2b2lkIGRpZE5vdEhhbmRs ZUtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmKTsKLSAgICB2aXJ0dWFsIHZv aWQgZGlkTm90SGFuZGxlV2hlZWxFdmVudChjb25zdCBOYXRpdmVXZWJXaGVlbEV2ZW50Jik7CiAg ICAgdmlydHVhbCBQYXNzUmVmUHRyPFdlYlBvcHVwTWVudVByb3h5PiBjcmVhdGVQb3B1cE1lbnVQ cm94eShXZWJQYWdlUHJveHkqKTsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8V2ViQ29udGV4dE1l bnVQcm94eT4gY3JlYXRlQ29udGV4dE1lbnVQcm94eShXZWJQYWdlUHJveHkqKTsKICAgICB2aXJ0 dWFsIHZvaWQgc2V0RmluZEluZGljYXRvcihQYXNzUmVmUHRyPEZpbmRJbmRpY2F0b3I+LCBib29s IGZhZGVPdXQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViVmlld0Jhc2UuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViVmlld0Jhc2UuY3BwCmluZGV4IDdmYWY4NDIuLjU0MTc5MWIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5j cHAKQEAgLTUzLDYgKzUzLDcgQEAgc3RydWN0IF9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUgewog ICAgIE93blB0cjxQYWdlQ2xpZW50SW1wbD4gcGFnZUNsaWVudDsKICAgICBSZWZQdHI8V2ViUGFn ZVByb3h5PiBwYWdlUHJveHk7CiAgICAgZ2Jvb2xlYW4gaXNQYWdlQWN0aXZlOworICAgIGdib29s ZWFuIHNob3VsZEZvcndhcmROZXh0S2V5RXZlbnQ7CiAgICAgR3RrSU1Db250ZXh0KiBpbUNvbnRl eHQ7CiAgICAgR3RrQ2xpY2tDb3VudGVyIGNsaWNrQ291bnRlcjsKICAgICBDU3RyaW5nIHRvb2x0 aXBUZXh0OwpAQCAtMTI5LDYgKzEzMCw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19i YXNlX2luaXQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlKQogICAgIHdlYmtp dFdlYlZpZXdCYXNlLT5wcml2ID0gcHJpdjsKIAogICAgIHByaXYtPmlzUGFnZUFjdGl2ZSA9IFRS VUU7CisgICAgcHJpdi0+c2hvdWxkRm9yd2FyZE5leHRLZXlFdmVudCA9IEZBTFNFOwogCiAgICAg Z3RrX3dpZGdldF9zZXRfZG91YmxlX2J1ZmZlcmVkKEdUS19XSURHRVQod2Via2l0V2ViVmlld0Jh c2UpLCBGQUxTRSk7CiAgICAgZ3RrX3dpZGdldF9zZXRfY2FuX2ZvY3VzKEdUS19XSURHRVQod2Vi a2l0V2ViVmlld0Jhc2UpLCBUUlVFKTsKQEAgLTIwMCw5ICsyMDIsMTYgQEAgc3RhdGljIGdib29s ZWFuIHdlYmtpdFdlYlZpZXdCYXNlS2V5UHJlc3NFdmVudChHdGtXaWRnZXQqIHdpZGdldCwgR2Rr RXZlbnRLZXkqIGUKICAgICBXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UgPSBXRUJLSVRf V0VCX1ZJRVdfQkFTRSh3aWRnZXQpOwogICAgIFdlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZSogcHJp diA9IHdlYlZpZXdCYXNlLT5wcml2OwogCisgICAgLy8gU2luY2UgV2ViUHJvY2VzcyBrZXkgZXZl bnQgaGFuZGxpbmcgaXMgbm90IHN5bmNocm9ub3VzLCBoYW5kbGUgdGhlIGV2ZW50IGluIHR3byBw YXNzZXMuCisgICAgLy8gV2hlbiBXZWJQcm9jZXNzIHByb2Nlc3NlcyB0aGUgaW5wdXQgZXZlbnQs IGl0IHdpbGwgY2FsbCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhLZXlFdmVudCAKKyAgICAvLyB3 aXRoIGV2ZW50IGhhbmRsZWQgc3RhdHVzIHdoaWNoIGRldGVybWluZXMgd2hldGhlciB0byBwYXNz IHRoZSBpbnB1dCBldmVudCB0byBwYXJlbnQgb3Igbm90IAorICAgIC8vIHVzaW5nIGd0a19tYWlu X2RvX2V2ZW50KCkuCisgICAgaWYgKHByaXYtPnNob3VsZEZvcndhcmROZXh0S2V5RXZlbnQpIHsK KyAgICAgICAgcHJpdi0+c2hvdWxkRm9yd2FyZE5leHRLZXlFdmVudCA9IEZBTFNFOworICAgICAg ICByZXR1cm4gR1RLX1dJREdFVF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJlbnRfY2xh c3MpLT5rZXlfcHJlc3NfZXZlbnQod2lkZ2V0LCBldmVudCk7CisgICAgfQogICAgIHByaXYtPnBh Z2VQcm94eS0+aGFuZGxlS2V5Ym9hcmRFdmVudChOYXRpdmVXZWJLZXlib2FyZEV2ZW50KHJlaW50 ZXJwcmV0X2Nhc3Q8R2RrRXZlbnQqPihldmVudCkpKTsKLQotICAgIHJldHVybiBHVEtfV0lER0VU X0NMQVNTKHdlYmtpdF93ZWJfdmlld19iYXNlX3BhcmVudF9jbGFzcyktPmtleV9wcmVzc19ldmVu dCh3aWRnZXQsIGV2ZW50KTsKKyAgICByZXR1cm4gVFJVRTsKIH0KIAogc3RhdGljIGdib29sZWFu IHdlYmtpdFdlYlZpZXdCYXNlS2V5UmVsZWFzZUV2ZW50KEd0a1dpZGdldCogd2lkZ2V0LCBHZGtF dmVudEtleSogZXZlbnQpCkBAIC0yMTMsOSArMjIyLDEyIEBAIHN0YXRpYyBnYm9vbGVhbiB3ZWJr aXRXZWJWaWV3QmFzZUtleVJlbGVhc2VFdmVudChHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRL ZXkqCiAgICAgaWYgKGd0a19pbV9jb250ZXh0X2ZpbHRlcl9rZXlwcmVzcyhwcml2LT5pbUNvbnRl eHQsIGV2ZW50KSkKICAgICAgICAgcmV0dXJuIFRSVUU7CiAKKyAgICBpZiAocHJpdi0+c2hvdWxk Rm9yd2FyZE5leHRLZXlFdmVudCkgeworICAgICAgICBwcml2LT5zaG91bGRGb3J3YXJkTmV4dEtl eUV2ZW50ID0gRkFMU0U7CisgICAgICAgIHJldHVybiBHVEtfV0lER0VUX0NMQVNTKHdlYmtpdF93 ZWJfdmlld19iYXNlX3BhcmVudF9jbGFzcyktPmtleV9yZWxlYXNlX2V2ZW50KHdpZGdldCwgZXZl bnQpOworICAgIH0KICAgICBwcml2LT5wYWdlUHJveHktPmhhbmRsZUtleWJvYXJkRXZlbnQoTmF0 aXZlV2ViS2V5Ym9hcmRFdmVudChyZWludGVycHJldF9jYXN0PEdka0V2ZW50Kj4oZXZlbnQpKSk7 Ci0KLSAgICByZXR1cm4gR1RLX1dJREdFVF9DTEFTUyh3ZWJraXRfd2ViX3ZpZXdfYmFzZV9wYXJl bnRfY2xhc3MpLT5rZXlfcmVsZWFzZV9ldmVudCh3aWRnZXQsIGV2ZW50KTsKKyAgICByZXR1cm4g VFJVRTsKIH0KIAogc3RhdGljIGdib29sZWFuIHdlYmtpdFdlYlZpZXdCYXNlQnV0dG9uUHJlc3NF dmVudChHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRCdXR0b24qIGJ1dHRvbkV2ZW50KQpAQCAt MzQzLDQgKzM1NSw3IEBAIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VTZXRUb29sdGlwVGV4dChXZWJL aXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UsIGNvbnN0IGNoYXIqCiAgICAgZ3RrX3dpZGdldF90 cmlnZ2VyX3Rvb2x0aXBfcXVlcnkoR1RLX1dJREdFVCh3ZWJWaWV3QmFzZSkpOwogfQogCi0KK3Zv aWQgd2Via2l0V2ViVmlld0Jhc2VGb3J3YXJkTmV4dEtleUV2ZW50KFdlYktpdFdlYlZpZXdCYXNl KiB3ZWJraXRXZWJWaWV3QmFzZSkKK3sKKyAgICB3ZWJraXRXZWJWaWV3QmFzZS0+cHJpdi0+c2hv dWxkRm9yd2FyZE5leHRLZXlFdmVudCA9IFRSVUU7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCmlu ZGV4IDY5OTY3MzguLmEzOTA2OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCkBAIC00Niw2ICs0 Niw4IEBAIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VDcmVhdGVXZWJQYWdlKFdlYktpdFdlYlZpZXdC YXNlKiwgV0tDb250ZXh0UmVmLCBXS1BhZ2VHcm91CiAKIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VT ZXRUb29sdGlwVGV4dChXZWJLaXRXZWJWaWV3QmFzZSosIGNvbnN0IGNoYXIqKTsKIAordm9pZCB3 ZWJraXRXZWJWaWV3QmFzZUZvcndhcmROZXh0S2V5RXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqKTsK KwogR19FTkRfREVDTFMKIAogI2VuZGlmIC8vIFdlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZV9oCg==