/* $Id: synchron.cpp,v 1.1 1998/09/25 18:01:41 ramiro%netscape.com Exp $ * * The contents of this file are subject to the Netscape Public License * Version 1.0 (the "NPL"); you may not use this file except in * compliance with the NPL. You may obtain a copy of the NPL at * http://www.mozilla.org/NPL/ * * Software distributed under the NPL is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL * for the specific language governing rights and limitations under the * NPL. * * The Initial Developer of this code under the NPL is Netscape * Communications Corporation. Portions created by Netscape are * Copyright (C) 1998 Netscape Communications Corporation. Portions * created by Warwick Allison, Kalle Dalheimer, Eirik Eng, Matthias * Ettrich, Arnt Gulbrandsen, Haavard Nord and Paul Olav Tvete are * Copyright (C) 1998 Warwick Allison, Kalle Dalheimer, Eirik Eng, * Matthias Ettrich, Arnt Gulbrandsen, Haavard Nord and Paul Olav * Tvete. All Rights Reserved. */ #include #include #include "QtBrowserContext.h" // includes QtContext.h #include "qtbind.h" #include #include "layers.h" #include "DialogPool.h" #include "shist.h" //#include "contexts.h" #include #include #include #include #include #include /* this file contains some support for synchronous URL loading. * It is taken from the xfe though we are still not sure wether * we need this. * * Should be moved into a class..... */ bool fe_IsContextLooping(MWContext *context); bool fe_IsContextDestroyed(MWContext *context); bool fe_IsContextProtected(MWContext *context); void fe_UnProtectContext(MWContext *context); void fe_ProtectContext(MWContext *context); void fe_LowerSynchronousURLDialog (MWContext *context); void fe_synchronous_url_exit (URL_Struct *url, int status, MWContext *context); void fe_RaiseSynchronousURLDialog (MWContext *context, QWidget* parent, const char *title); int fe_AwaitSynchronousURL( MWContext* context ); void fe_StartProgressGraph ( MWContext* context ); void fe_SetCursor ( MWContext* context, bool ); void fe_url_exit (URL_Struct *url, int status, MWContext *context); int QtContext::getSynchronousURL ( QWidget* widget_to_grab, const char *title, URL_Struct *url, int output_format, void *call_data ) { #if 0// defined DEBUG_paul debug( "getSynchronousURL" ); #endif int status; url->fe_data = call_data; fe_RaiseSynchronousURLDialog( context, widget_to_grab, title ); status = NET_GetURL( url, output_format, context, fe_synchronous_url_exit ); if( status < 0 ) return status; else return fe_AwaitSynchronousURL( context ); } int fe_AwaitSynchronousURL( MWContext* context ) { /* Loop dispatching X events until the dialog box goes down as a result of the exit routine being called (which may be a result of the Cancel button being hit. */ int status; fe_ProtectContext( context ); while( CONTEXT_DATA ( context )->synchronous_url_dialog ) { qApp->processOneEvent(); } fe_UnProtectContext( context ); status = CONTEXT_DATA( context )->synchronous_url_exit_status; if( fe_IsContextDestroyed( context ) ) { free( CONTEXT_DATA( context ) ); free( context ); } return (status); } /* * fe_ProtectContext() * * Sets the dont_free_context_memory variable in the CONTEXT_DATA. This * will prevent the memory for the context and CONTEXT_DATA to be freed * even if the context was destroyed. */ void fe_ProtectContext(MWContext *context) { unsigned char del = 0; // XmDO_NOTHING; if (!CONTEXT_DATA(context)->dont_free_context_memory) { /* This is the first person trying to protect this context. * Dont allow the user to destroy this context using the windowmanger * delete menu item. */ //#warning Implement this. Kalle. // XtVaGetValues(CONTEXT_WIDGET(context), XmNdeleteResponse, &del, 0); CONTEXT_DATA(context)->delete_response = del; // XtVaSetValues(CONTEXT_WIDGET(context), // XmNdeleteResponse, XmDO_NOTHING, 0); } CONTEXT_DATA(context)->dont_free_context_memory++; } /* * fe_UnProtectContext() * * Undo what fe_ProtectContext() does. Unsets dont_free_context_memory * variable in the context_data. */ void fe_UnProtectContext(MWContext *context) { XP_ASSERT(CONTEXT_DATA(context)->dont_free_context_memory); if (CONTEXT_DATA(context)->dont_free_context_memory) { CONTEXT_DATA(context)->dont_free_context_memory--; if (!CONTEXT_DATA(context)->dont_free_context_memory) { /* This is the last person unprotecting this context. * Set the delete_response to what it was before. */ //#warning Implement this. Kalle. // XtVaSetValues(CONTEXT_WIDGET(context), XmNdeleteResponse, // CONTEXT_DATA(context)->delete_response, 0); } } } /* * fe_IsContextProtected() * * Return the protection state of the context. */ bool fe_IsContextProtected(MWContext *context) { return (CONTEXT_DATA(context)->dont_free_context_memory); } /* * fe_IsContextDestroyed() * * Return if the context was destroyed. This is valid only for protected * contexts. */ bool fe_IsContextDestroyed(MWContext *context) { return (CONTEXT_DATA(context)->destroyed); } /* Recurses over children of context, returning True if any context is stoppable. */ bool fe_IsContextLooping(MWContext *context) { int i = 1; MWContext *child; if (!context) return false; if (CONTEXT_DATA(context)->looping_images_p) return true; while ((child = (MWContext*)XP_ListGetObjectNum (context->grid_children, i++))) if (fe_IsContextLooping(child)) return true; return false; } void fe_LowerSynchronousURLDialog (MWContext *context) { if (CONTEXT_DATA (context)->synchronous_url_dialog) { CONTEXT_DATA (context)->synchronous_url_dialog = 0; /* If this context was destroyed, do not proceed furthur */ if (fe_IsContextDestroyed(context)) return; assert (CONTEXT_DATA (context)->active_url_count > 0); if (CONTEXT_DATA (context)->active_url_count > 0) CONTEXT_DATA (context)->active_url_count--; if (CONTEXT_DATA (context)->active_url_count <= 0) FE_AllConnectionsComplete (context); fe_SetCursor (context, false); } } void fe_synchronous_url_exit (URL_Struct *url, int status, MWContext *context) { if (status == MK_CHANGING_CONTEXT) return; fe_LowerSynchronousURLDialog (context); if (status < 0 && url->error_msg) { FE_Alert (context, url->error_msg); } NET_FreeURLStruct (url); CONTEXT_DATA (context)->synchronous_url_exit_status = status; } void fe_RaiseSynchronousURLDialog (MWContext *context, QWidget* parent, const char *title) { CONTEXT_DATA (context)->active_url_count++; if (CONTEXT_DATA (context)->active_url_count == 1) { CONTEXT_DATA (context)->clicking_blocked = true; fe_StartProgressGraph (context); fe_SetCursor (context, false); } CONTEXT_DATA (context)->synchronous_url_dialog = (QWidget*) ~0; CONTEXT_DATA (context)->synchronous_url_exit_status = 0; } void fe_StartProgressGraph ( MWContext* context ) { // debug( "fe_StartProgressGraph %p", context ); } void fe_SetCursor ( MWContext* context, bool huh) { // debug( "fe_SetCursor %p %s", context, huh ? "TRUE" : "FALSE" ); } void fe_url_exit (URL_Struct *url, int status, MWContext *context) { XP_ASSERT (status == MK_INTERRUPTED || CONTEXT_DATA (context)->active_url_count > 0); if (CONTEXT_DATA (context)->active_url_count > 0) CONTEXT_DATA (context)->active_url_count--; /* We should be guarenteed that XFE_AllConnectionsComplete() will be called right after this, if active_url_count has just gone to 0. */ if (status < 0 && url->error_msg) { FE_Alert (context, url->error_msg); } #if defined(EDITOR) && defined(EDITOR_UI) /* * Do stuff specific to the editor */ if (context->type == MWContextEditor) //#warning Put this back in when I understand what does. {} // fe_EditorGetUrlExitRoutine(context, url, status); #endif if (status != MK_CHANGING_CONTEXT) { NET_FreeURLStruct (url); } }