mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-13 10:25:01 +00:00
294 lines
8.2 KiB
C++
294 lines
8.2 KiB
C++
/* $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 <qtimer.h>
|
|
#include <qapp.h>
|
|
#include "QtBrowserContext.h" // includes QtContext.h
|
|
#include "qtbind.h"
|
|
#include <qmsgbox.h>
|
|
#include "layers.h"
|
|
#include "DialogPool.h"
|
|
#include "shist.h"
|
|
//#include "contexts.h"
|
|
#include <qobjcoll.h>
|
|
#include <string.h>
|
|
#include <qstring.h>
|
|
#include <qpainter.h>
|
|
#include <qmainwindow.h>
|
|
#include <qstatusbar.h>
|
|
|
|
|
|
|
|
/* 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);
|
|
}
|
|
}
|