mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-08 05:52:32 +00:00
1010 lines
25 KiB
C
1010 lines
25 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* 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. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "xp.h"
|
|
#include "net.h"
|
|
#include "pa_parse.h"
|
|
#include "layout.h"
|
|
#include "laylayer.h"
|
|
#ifdef JAVA
|
|
#include "java.h"
|
|
#endif
|
|
#include "laystyle.h"
|
|
#include "layers.h"
|
|
#include "np.h"
|
|
|
|
#define JAVA_DEF_DIM 50
|
|
#define JAVA_DEF_BORDER 0
|
|
#define JAVA_DEF_VERTICAL_SPACE 0
|
|
#define JAVA_DEF_HORIZONTAL_SPACE 0
|
|
|
|
void lo_FinishJavaApp(MWContext *, lo_DocState *, LO_JavaAppStruct *);
|
|
static void lo_FormatJavaAppInternal(MWContext *context,
|
|
lo_DocState *state,
|
|
PA_Tag *tag,
|
|
LO_JavaAppStruct *java_app);
|
|
|
|
#if 0 /* not used */
|
|
void
|
|
LO_ClearJavaAppBlock(MWContext *context, LO_JavaAppStruct *java_app)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_DocState *main_doc_state;
|
|
lo_DocState *state;
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->doc_state == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (top_state->layout_blocking_element == (LO_Element *)java_app)
|
|
{
|
|
if (java_app->width == 0)
|
|
{
|
|
java_app->width = JAVA_DEF_DIM;
|
|
}
|
|
if (java_app->height == 0)
|
|
{
|
|
java_app->height = JAVA_DEF_DIM;
|
|
}
|
|
|
|
main_doc_state = top_state->doc_state;
|
|
state = lo_CurrentSubState(main_doc_state);
|
|
|
|
lo_FinishJavaApp(context, state, java_app);
|
|
lo_FlushBlockage(context, state, main_doc_state);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void
|
|
lo_FormatJavaObject(MWContext *context, lo_DocState *state, PA_Tag *tag, LO_JavaAppStruct *java_app)
|
|
{
|
|
PA_Block buff;
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_CLASSID);
|
|
if (buff != NULL)
|
|
{
|
|
char* str;
|
|
PA_LOCK(str, char *, buff);
|
|
if (XP_STRNCASECMP(str, "java:", 5) == 0)
|
|
java_app->selector_type = LO_JAVA_SELECTOR_OBJECT_JAVA;
|
|
else if (XP_STRNCASECMP(str, "javaprogram:", 12) == 0)
|
|
java_app->selector_type = LO_JAVA_SELECTOR_OBJECT_JAVAPROGRAM;
|
|
else if (XP_STRNCASECMP(str, "javabean:", 8) == 0)
|
|
java_app->selector_type = LO_JAVA_SELECTOR_OBJECT_JAVABEAN;
|
|
PA_UNLOCK(buff);
|
|
XP_FREE(buff);
|
|
}
|
|
|
|
if (java_app->selector_type == LO_JAVA_SELECTOR_OBJECT_JAVAPROGRAM)
|
|
{
|
|
java_app->objTag.ele_attrmask |= LO_ELE_HIDDEN;
|
|
}
|
|
else
|
|
{
|
|
/* Get the HIDDEN parameter */
|
|
java_app->objTag.ele_attrmask = 0;
|
|
buff = lo_FetchParamValue(context, tag, PARAM_HIDDEN);
|
|
if (buff != NULL)
|
|
{
|
|
Bool hidden = TRUE;
|
|
char* str;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
if (pa_TagEqual("no", str))
|
|
{
|
|
hidden = FALSE;
|
|
}
|
|
else if (pa_TagEqual("false", str))
|
|
{
|
|
hidden = FALSE;
|
|
}
|
|
else if (pa_TagEqual("off", str))
|
|
{
|
|
hidden = FALSE;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
|
|
if (hidden != FALSE)
|
|
{
|
|
java_app->objTag.ele_attrmask |= LO_ELE_HIDDEN;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Finish formatting the object */
|
|
lo_FormatJavaAppInternal(context, state, tag, java_app);
|
|
}
|
|
|
|
#define JAVA_PLUGIN_MIMETYPE "application/x-java-vm"
|
|
|
|
void
|
|
lo_FormatJavaApp(MWContext *context, lo_DocState *state, PA_Tag *tag)
|
|
{
|
|
LO_JavaAppStruct *java_app;
|
|
|
|
/*
|
|
* Fill in the java applet structure with default data
|
|
*/
|
|
java_app = (LO_JavaAppStruct *)lo_NewElement(context, state, LO_JAVA, NULL, 0);
|
|
if (java_app == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
java_app->objTag.type = LO_JAVA;
|
|
java_app->objTag.ele_id = NEXT_ELEMENT;
|
|
java_app->objTag.x = state->x;
|
|
java_app->objTag.x_offset = 0;
|
|
java_app->objTag.y = state->y;
|
|
java_app->objTag.y_offset = 0;
|
|
java_app->objTag.width = 0;
|
|
java_app->objTag.height = 0;
|
|
java_app->objTag.next = NULL;
|
|
java_app->objTag.prev = NULL;
|
|
|
|
java_app->objTag.ele_attrmask = 0;
|
|
java_app->selector_type = LO_JAVA_SELECTOR_APPLET;
|
|
|
|
/* Finish formatting the object */
|
|
lo_FormatJavaAppInternal(context, state, tag, java_app);
|
|
}
|
|
|
|
|
|
static void
|
|
lo_FormatJavaAppInternal(MWContext *context, lo_DocState *state, PA_Tag *tag, LO_JavaAppStruct *java_app)
|
|
{
|
|
PA_Block buff;
|
|
char *str;
|
|
int32 val;
|
|
int32 doc_width;
|
|
Bool widthSpecified = FALSE;
|
|
Bool heightSpecified = FALSE;
|
|
lo_DocLists *doc_lists;
|
|
|
|
java_app->nextApplet = NULL;
|
|
java_app->objTag.mocha_object = NULL;
|
|
java_app->objTag.FE_Data = NULL;
|
|
java_app->objTag.session_data = NULL;
|
|
java_app->objTag.line_height = state->line_height;
|
|
|
|
java_app->objTag.base_url = NULL;
|
|
java_app->attr_code = NULL;
|
|
java_app->attr_codebase = NULL;
|
|
java_app->attr_archive = NULL;
|
|
java_app->attr_name = NULL;
|
|
|
|
LO_NVList_Init( &java_app->attributes );
|
|
LO_NVList_Init( &java_app->parameters );
|
|
|
|
java_app->may_script = FALSE;
|
|
|
|
java_app->objTag.alignment = LO_ALIGN_BASELINE;
|
|
java_app->objTag.border_width = JAVA_DEF_BORDER;
|
|
java_app->objTag.border_vert_space = JAVA_DEF_VERTICAL_SPACE;
|
|
java_app->objTag.border_horiz_space = JAVA_DEF_HORIZONTAL_SPACE;
|
|
|
|
java_app->objTag.layer = NULL;
|
|
java_app->objTag.tag = tag;
|
|
|
|
/*
|
|
* Assign a unique index for this object
|
|
* and increment the master index.
|
|
*/
|
|
java_app->objTag.embed_index = state->top_state->embed_count++;
|
|
|
|
/*
|
|
* Save away the base of the document
|
|
*/
|
|
buff = PA_ALLOC(XP_STRLEN(state->top_state->base_url) + 1);
|
|
if (buff != NULL)
|
|
{
|
|
char *cp;
|
|
PA_LOCK(cp, char*, buff);
|
|
XP_STRCPY(cp, state->top_state->base_url);
|
|
PA_UNLOCK(buff);
|
|
java_app->objTag.base_url = buff;
|
|
}
|
|
else
|
|
{
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Check for an align parameter
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_ALIGN);
|
|
if (buff != NULL)
|
|
{
|
|
Bool floating;
|
|
|
|
floating = FALSE;
|
|
PA_LOCK(str, char *, buff);
|
|
java_app->objTag.alignment = lo_EvalAlignParam(str, &floating);
|
|
if (floating != FALSE)
|
|
{
|
|
java_app->objTag.ele_attrmask |= LO_ELE_FLOATING;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
|
|
/*
|
|
* Get the applet CODE or object CLASSID parameter. In both
|
|
* cases the value is place in java_app->attr_code
|
|
*/
|
|
if (java_app->selector_type == LO_JAVA_SELECTOR_APPLET)
|
|
{
|
|
/* APPLET tag CODE attribute */
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_CODE);
|
|
}
|
|
else
|
|
{
|
|
/* OBJECT tag CLASSID attribute */
|
|
|
|
char * str1, * str2;
|
|
PA_Block new_buff;
|
|
|
|
int selectorLength;
|
|
|
|
selectorLength = 5;
|
|
if (java_app->selector_type == LO_JAVA_SELECTOR_OBJECT_JAVAPROGRAM)
|
|
selectorLength = 12;
|
|
else if (java_app->selector_type == LO_JAVA_SELECTOR_OBJECT_JAVABEAN)
|
|
selectorLength = 9;
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_CLASSID);
|
|
|
|
if (buff != NULL)
|
|
{
|
|
/* remove the "java:", "javaprogram:", or "javabean:"
|
|
* protocol selector.
|
|
*/
|
|
PA_LOCK(str1, char *, buff);
|
|
new_buff = PA_ALLOC(XP_STRLEN(str1) + 1);
|
|
PA_LOCK(str2, char *, new_buff);
|
|
XP_STRCPY(str2, str1 + selectorLength);
|
|
PA_UNLOCK(new_buff);
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
buff = new_buff;
|
|
}
|
|
}
|
|
java_app->attr_code = buff;
|
|
|
|
/*
|
|
* Check for the loaderbase parameter.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_CODEBASE);
|
|
java_app->attr_codebase = buff;
|
|
|
|
/*
|
|
* Check for the archive parameter.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_ARCHIVE);
|
|
java_app->attr_archive = buff;
|
|
|
|
/*
|
|
* Check for a mayscript attribute
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_MAYSCRIPT);
|
|
if (buff != NULL)
|
|
{
|
|
java_app->may_script = TRUE;
|
|
PA_FREE(buff);
|
|
}
|
|
|
|
/*
|
|
* Get the name of this java applet.
|
|
*/
|
|
if (java_app->selector_type != LO_JAVA_SELECTOR_APPLET)
|
|
buff = lo_FetchParamValue(context, tag, PARAM_ID);
|
|
else
|
|
buff = lo_FetchParamValue(context, tag, PARAM_NAME);
|
|
if (buff != NULL)
|
|
{
|
|
PA_LOCK(str, char *, buff);
|
|
if (str != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
}
|
|
PA_UNLOCK(buff);
|
|
}
|
|
java_app->attr_name = buff;
|
|
|
|
doc_width = state->right_margin - state->left_margin;
|
|
|
|
/*
|
|
* Get the width parameter, in absolute or percentage.
|
|
* If percentage, make it absolute.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_WIDTH);
|
|
if (buff != NULL)
|
|
{
|
|
Bool is_percent;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
val = lo_ValueOrPercent(str, &is_percent);
|
|
if (is_percent != FALSE)
|
|
{
|
|
java_app->objTag.percent_width = val;
|
|
}
|
|
else
|
|
{
|
|
java_app->objTag.percent_width = 0;
|
|
java_app->objTag.width = val;
|
|
val = FEUNITS_X(val, context);
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
widthSpecified = TRUE;
|
|
}
|
|
val = LO_GetWidthFromStyleSheet(context, state);
|
|
if(val)
|
|
{
|
|
java_app->objTag.width = val;
|
|
widthSpecified = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Get the height parameter, in absolute or percentage.
|
|
* If percentage, make it absolute.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_HEIGHT);
|
|
if (buff != NULL)
|
|
{
|
|
Bool is_percent;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
val = lo_ValueOrPercent(str, &is_percent);
|
|
if (is_percent != FALSE)
|
|
{
|
|
java_app->objTag.percent_height = val;
|
|
}
|
|
else
|
|
{
|
|
java_app->objTag.percent_height = 0;
|
|
val = FEUNITS_Y(val, context);
|
|
}
|
|
java_app->objTag.height = val;
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
heightSpecified = TRUE;
|
|
}
|
|
|
|
val = LO_GetHeightFromStyleSheet(context, state);
|
|
if(val)
|
|
{
|
|
java_app->objTag.height = val;
|
|
heightSpecified = TRUE;
|
|
}
|
|
|
|
/* If they forgot to specify a width, make one up. */
|
|
if (!widthSpecified) {
|
|
val = 0;
|
|
if (heightSpecified) {
|
|
val = java_app->objTag.height;
|
|
}
|
|
else if (state->allow_percent_width) {
|
|
val = state->win_width * 90 / 100;
|
|
}
|
|
if (val < 1) {
|
|
val = 600;
|
|
}
|
|
java_app->objTag.width = val;
|
|
}
|
|
|
|
/* If they forgot to specify a height, make one up. */
|
|
if (!heightSpecified) {
|
|
val = 0;
|
|
if (widthSpecified) {
|
|
val = java_app->objTag.width;
|
|
}
|
|
else if (state->allow_percent_height) {
|
|
val = state->win_height / 2;
|
|
}
|
|
if (val < 1) {
|
|
val = 400;
|
|
}
|
|
java_app->objTag.height = val;
|
|
}
|
|
|
|
/* After going through all the trouble, just to make sure
|
|
* the object tag HIDDEN case is covered as well.
|
|
*/
|
|
if (java_app->objTag.ele_attrmask & LO_ELE_HIDDEN)
|
|
{
|
|
java_app->objTag.width = 0;
|
|
java_app->objTag.height = 0;
|
|
}
|
|
|
|
/*
|
|
* Get the border parameter.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_BORDER);
|
|
if (buff != NULL)
|
|
{
|
|
PA_LOCK(str, char *, buff);
|
|
val = XP_ATOI(str);
|
|
if (val < 0)
|
|
{
|
|
val = 0;
|
|
}
|
|
java_app->objTag.border_width = val;
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
java_app->objTag.border_width = FEUNITS_X(java_app->objTag.border_width, context);
|
|
|
|
/*
|
|
* Get the extra vertical space parameter.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_VSPACE);
|
|
if (buff != NULL)
|
|
{
|
|
PA_LOCK(str, char *, buff);
|
|
val = XP_ATOI(str);
|
|
if (val < 0)
|
|
{
|
|
val = 0;
|
|
}
|
|
java_app->objTag.border_vert_space = val;
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
java_app->objTag.border_vert_space = FEUNITS_Y(java_app->objTag.border_vert_space,
|
|
context);
|
|
|
|
/*
|
|
* Get the extra horizontal space parameter.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_HSPACE);
|
|
if (buff != NULL)
|
|
{
|
|
PA_LOCK(str, char *, buff);
|
|
val = XP_ATOI(str);
|
|
if (val < 0)
|
|
{
|
|
val = 0;
|
|
}
|
|
java_app->objTag.border_horiz_space = val;
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
java_app->objTag.border_horiz_space = FEUNITS_X(java_app->objTag.border_horiz_space,
|
|
context);
|
|
|
|
lo_FillInJavaAppGeometry(state, java_app, FALSE);
|
|
|
|
/*
|
|
* See if we have some saved embed/java_app session data to restore.
|
|
*/
|
|
if (state->top_state->savedData.EmbedList != NULL)
|
|
{
|
|
lo_SavedEmbedListData *embed_list;
|
|
embed_list = state->top_state->savedData.EmbedList;
|
|
|
|
/*
|
|
* If there is still valid data to restore available.
|
|
*/
|
|
if (java_app->objTag.embed_index < embed_list->embed_count)
|
|
{
|
|
lo_EmbedDataElement* embed_data_list;
|
|
|
|
PA_LOCK(embed_data_list, lo_EmbedDataElement*,
|
|
embed_list->embed_data_list);
|
|
java_app->objTag.session_data =
|
|
embed_data_list[java_app->objTag.embed_index].data;
|
|
PA_UNLOCK(embed_list->embed_data_list);
|
|
}
|
|
}
|
|
|
|
/* put the applet onto the applet list for later
|
|
* possible reflection */
|
|
doc_lists = lo_GetCurrentDocLists(state);
|
|
if (state->in_relayout) {
|
|
int32 i, count;
|
|
LO_JavaAppStruct *prev_applet, *cur_applet;
|
|
|
|
/*
|
|
* In the interest of changing as little as possible, I'm not
|
|
* going to change the applet_list to be in the order of layout
|
|
* (it is currently in reverse order). Instead, we do what
|
|
* everybody else does - iterate till the end of the list to get
|
|
* find an element with the correct index.
|
|
* If we're in table relayout, we need to replace the element
|
|
* of the same index in this list with the new layout element
|
|
* to prevent multiple reflection.
|
|
*/
|
|
count = 0;
|
|
cur_applet = doc_lists->applet_list;
|
|
while (cur_applet) {
|
|
cur_applet = cur_applet->nextApplet;
|
|
count++;
|
|
}
|
|
|
|
/* reverse order... */
|
|
prev_applet = NULL;
|
|
cur_applet = doc_lists->applet_list;
|
|
for (i = count-1; i >= 0; i--) {
|
|
if (i == doc_lists->applet_list_count) {
|
|
/* Copy over the mocha object (it might not exist) */
|
|
java_app->objTag.mocha_object = cur_applet->objTag.mocha_object;
|
|
|
|
java_app->nextApplet = cur_applet->nextApplet;
|
|
|
|
/* Replace the old applet with the new one */
|
|
if (prev_applet == NULL)
|
|
doc_lists->applet_list = java_app;
|
|
else
|
|
prev_applet->nextApplet = java_app;
|
|
doc_lists->applet_list_count++;
|
|
break;
|
|
}
|
|
prev_applet = cur_applet;
|
|
cur_applet = cur_applet->nextApplet;
|
|
}
|
|
}
|
|
else {
|
|
java_app->nextApplet = doc_lists->applet_list;
|
|
doc_lists->applet_list = java_app;
|
|
doc_lists->applet_list_count++;
|
|
}
|
|
|
|
state->current_java = java_app;
|
|
|
|
/* don't double-count loading applets due to table relayout */
|
|
if (!state->in_relayout)
|
|
{
|
|
state->top_state->mocha_loading_applets_count++;
|
|
}
|
|
}
|
|
|
|
#ifdef JAVA
|
|
void
|
|
lo_FinishJavaApp(MWContext *context, lo_DocState *state,
|
|
LO_JavaAppStruct *java_app)
|
|
{
|
|
int32 baseline_inc;
|
|
int32 line_inc;
|
|
int32 java_app_height, java_app_width;
|
|
|
|
if ( java_app->objTag.layer == NULL )
|
|
{
|
|
java_app->objTag.layer =
|
|
lo_CreateEmbeddedObjectLayer(context, state, (LO_Element*)java_app);
|
|
}
|
|
|
|
if (java_app->selector_type != LO_JAVA_SELECTOR_OBJECT_JAVAPROGRAM)
|
|
{
|
|
/*
|
|
* Eventually this will never happen since we always
|
|
* have dims here from either the image tag itself or the
|
|
* front end.
|
|
*/
|
|
if (java_app->objTag.width == 0)
|
|
{
|
|
java_app->objTag.width = JAVA_DEF_DIM;
|
|
}
|
|
if (java_app->objTag.height == 0)
|
|
{
|
|
java_app->objTag.height = JAVA_DEF_DIM;
|
|
}
|
|
}
|
|
|
|
java_app_width = java_app->objTag.width + (2 * java_app->objTag.border_width) +
|
|
(2 * java_app->objTag.border_horiz_space);
|
|
java_app_height = java_app->objTag.height + (2 * java_app->objTag.border_width) +
|
|
(2 * java_app->objTag.border_vert_space);
|
|
|
|
/*
|
|
* SEVERE FLOW BREAK! This may be a floating java_app,
|
|
* which means at this point we go do something completely
|
|
* different.
|
|
*/
|
|
if (java_app->objTag.ele_attrmask & LO_ELE_FLOATING)
|
|
{
|
|
java_app->objTag.x_offset += (int16)java_app->objTag.border_horiz_space;
|
|
java_app->objTag.y_offset += java_app->objTag.border_vert_space;
|
|
|
|
/*
|
|
* Insert this element into the float list.
|
|
*/
|
|
java_app->objTag.next = state->float_list;
|
|
state->float_list = (LO_Element *)java_app;
|
|
|
|
lo_AppendFloatInLineList(context, state, (LO_Element*)java_app, NULL);
|
|
|
|
lo_LayoutFloatJavaApp(context, state, java_app, TRUE);
|
|
|
|
/*
|
|
* Make sure the applet get created on
|
|
* the java side before we ever try to display
|
|
* (which the following if might do).
|
|
*/
|
|
if (java_app->objTag.session_data == NULL && !EDT_IS_EDITOR( context ))
|
|
{
|
|
/*
|
|
* This creates an applet in the java airspace,
|
|
* sends it the init message and sets up the
|
|
* session_data of the java_app structure.
|
|
*/
|
|
LJ_CreateApplet(java_app, context, state->top_state->force_reload);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Figure out how to align this java_app.
|
|
* baseline_inc is how much to increase the baseline
|
|
* of previous element of this line. line_inc is how
|
|
* much to increase the line height below the baseline.
|
|
*/
|
|
baseline_inc = 0;
|
|
line_inc = 0;
|
|
/*
|
|
* If we are at the beginning of a line, with no baseline,
|
|
* we first set baseline and line_height based on the current
|
|
* font, then place the image.
|
|
*/
|
|
if (state->baseline == 0)
|
|
{
|
|
state->baseline = 0;
|
|
}
|
|
|
|
java_app->objTag.x_offset += (int16)java_app->objTag.border_horiz_space;
|
|
java_app->objTag.y_offset += java_app->objTag.border_vert_space;
|
|
|
|
lo_LayoutInflowJavaApp(context, state, java_app, FALSE, &line_inc, &baseline_inc);
|
|
|
|
lo_AppendToLineList(context, state,
|
|
(LO_Element *)java_app, baseline_inc);
|
|
|
|
lo_UpdateStateAfterJavaAppLayout(state, java_app, line_inc, baseline_inc);
|
|
|
|
if (java_app->objTag.session_data == NULL && !EDT_IS_EDITOR( context )) {
|
|
/*
|
|
** This creates an applet in the java airspace, sends it the init
|
|
** message and sets up the session_data of the java_app structure:
|
|
*/
|
|
LJ_CreateApplet(java_app, context, state->top_state->force_reload);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
lo_CloseJavaApp(MWContext *context, lo_DocState *state,
|
|
LO_JavaAppStruct *java_app)
|
|
{
|
|
/*
|
|
** Create the applet first (if there wasn't a saved one in the
|
|
** history). That way we'll be able to remember reload method.
|
|
*/
|
|
if (java_app->objTag.session_data == NULL && !EDT_IS_EDITOR( context )) {
|
|
/*
|
|
** This creates an applet in the java airspace, sends it the init
|
|
** message and sets up the session_data of the java_app structure:
|
|
*/
|
|
LJ_CreateApplet(java_app, context, state->top_state->force_reload);
|
|
|
|
lo_AddEmbedData(context, java_app->objTag.session_data,
|
|
LJ_DeleteSessionData,
|
|
java_app->objTag.embed_index);
|
|
}
|
|
|
|
/*
|
|
* Have the front end fetch this java applet, and tells us
|
|
* its dimentions if it knows them.
|
|
*/
|
|
FE_GetJavaAppSize(context, java_app, state->top_state->force_reload);
|
|
|
|
/*
|
|
* We may have to block on this java applet until later
|
|
* when the front end can give us the width and height.
|
|
*
|
|
* Actaully this never can be the case in the current code
|
|
* for applet tag, and since the object tag *can* be 0,0 this
|
|
* is being commented out.
|
|
*/
|
|
/*
|
|
if ((java_app->objTag.width == 0)||(java_app->objTag.height == 0))
|
|
{
|
|
state->top_state->layout_blocking_element =
|
|
(LO_Element *)java_app;
|
|
}
|
|
else
|
|
{
|
|
lo_FinishJavaApp(context, state, java_app);
|
|
}
|
|
*/
|
|
lo_FinishJavaApp(context, state, java_app);
|
|
|
|
state->current_java = NULL;
|
|
}
|
|
#endif /* JAVA */
|
|
|
|
void
|
|
lo_RelayoutJavaApp(MWContext *context, lo_DocState *state, PA_Tag *tag,
|
|
LO_JavaAppStruct *java_app )
|
|
{
|
|
lo_DocLists *doc_lists;
|
|
|
|
lo_PreLayoutTag ( context, state, tag );
|
|
if (state->top_state->out_of_memory)
|
|
{
|
|
return;
|
|
}
|
|
|
|
java_app->objTag.x = state->x;
|
|
java_app->objTag.x_offset = 0;
|
|
java_app->objTag.y = state->y;
|
|
java_app->objTag.y_offset = 0;
|
|
|
|
/*
|
|
* Assign a unique index for this object
|
|
* and increment the master index.
|
|
*/
|
|
java_app->objTag.embed_index = state->top_state->embed_count++;
|
|
|
|
/*
|
|
* Since we saved the applet_list_count during table relayout,
|
|
* we increment it as if we were reprocessing the APPLET tag.
|
|
*/
|
|
doc_lists = lo_GetCurrentDocLists(state);
|
|
doc_lists->applet_list_count++;
|
|
|
|
state->current_java = java_app;
|
|
|
|
lo_PostLayoutTag ( context, state, tag, FALSE );
|
|
}
|
|
|
|
void
|
|
lo_FillInJavaAppGeometry(lo_DocState *state,
|
|
LO_JavaAppStruct *java_app,
|
|
Bool relayout)
|
|
{
|
|
int32 doc_width;
|
|
|
|
if (relayout == TRUE)
|
|
{
|
|
java_app->objTag.ele_id = NEXT_ELEMENT;
|
|
}
|
|
java_app->objTag.x = state->x;
|
|
java_app->objTag.y = state->y;
|
|
|
|
doc_width = state->right_margin - state->left_margin;
|
|
|
|
/*
|
|
* Get the width parameter, in absolute or percentage.
|
|
* If percentage, make it absolute.
|
|
*/
|
|
|
|
if (java_app->objTag.percent_width > 0) {
|
|
int32 val = java_app->objTag.percent_width;
|
|
if (state->allow_percent_width == FALSE) {
|
|
val = 0;
|
|
}
|
|
else {
|
|
val = doc_width * val / 100;
|
|
}
|
|
java_app->objTag.width = val;
|
|
}
|
|
|
|
/* Set java_app->objTag.height if java_app has a % height specified */
|
|
if (java_app->objTag.percent_height > 0) {
|
|
int32 val = java_app->objTag.percent_height;
|
|
if (state->allow_percent_height == FALSE) {
|
|
val = 0;
|
|
}
|
|
else {
|
|
val = state->win_height * val / 100;
|
|
}
|
|
java_app->objTag.height = val;
|
|
}
|
|
}
|
|
|
|
void
|
|
lo_LayoutInflowJavaApp(MWContext *context,
|
|
lo_DocState *state,
|
|
LO_JavaAppStruct *java_app,
|
|
Bool inRelayout,
|
|
int32 *line_inc,
|
|
int32 *baseline_inc)
|
|
{
|
|
int32 java_app_width, java_app_height;
|
|
Bool line_break;
|
|
PA_Block buff;
|
|
char *str;
|
|
LO_TextStruct tmp_text;
|
|
LO_TextInfo text_info;
|
|
|
|
/*
|
|
* All this work is to get the text_info filled in for the current
|
|
* font in the font stack. Yuck, there must be a better way.
|
|
*/
|
|
memset (&tmp_text, 0, sizeof (tmp_text));
|
|
buff = PA_ALLOC(1);
|
|
if (buff == NULL)
|
|
{
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
PA_LOCK(str, char *, buff);
|
|
str[0] = ' ';
|
|
PA_UNLOCK(buff);
|
|
tmp_text.text = buff;
|
|
tmp_text.text_len = 1;
|
|
tmp_text.text_attr =
|
|
#ifdef DOM
|
|
lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
state->font_stack->text_attr;
|
|
#endif
|
|
FE_GetTextInfo(context, &tmp_text, &text_info);
|
|
PA_FREE(buff);
|
|
|
|
java_app_width = java_app->objTag.width + (2 * java_app->objTag.border_width) +
|
|
(2 * java_app->objTag.border_horiz_space);
|
|
java_app_height = java_app->objTag.height + (2 * java_app->objTag.border_width) +
|
|
(2 * java_app->objTag.border_vert_space);
|
|
|
|
/*
|
|
* Will this java_app make the line too wide.
|
|
*/
|
|
if ((state->x + java_app_width) > state->right_margin)
|
|
{
|
|
line_break = TRUE;
|
|
}
|
|
else
|
|
{
|
|
line_break = FALSE;
|
|
}
|
|
|
|
/*
|
|
* if we are at the beginning of the line. There is
|
|
* no point in breaking, we are just too wide.
|
|
* Also don't break in unwrapped preformatted text.
|
|
* Also can't break inside a NOBR section.
|
|
*/
|
|
if ((state->at_begin_line != FALSE)||
|
|
(state->preformatted == PRE_TEXT_YES)||
|
|
(state->breakable == FALSE))
|
|
{
|
|
line_break = FALSE;
|
|
}
|
|
|
|
/*
|
|
* break on the java_app if we have
|
|
* a break.
|
|
*/
|
|
if (line_break != FALSE)
|
|
{
|
|
/*
|
|
* We need to make the elements sequential, linefeed
|
|
* before java app.
|
|
*/
|
|
state->top_state->element_id = java_app->objTag.ele_id;
|
|
|
|
if (!inRelayout)
|
|
{
|
|
lo_SoftLineBreak(context, state, TRUE);
|
|
}
|
|
else
|
|
{
|
|
lo_rl_AddSoftBreakAndFlushLine(context, state);
|
|
}
|
|
|
|
java_app->objTag.x = state->x;
|
|
java_app->objTag.y = state->y;
|
|
java_app->objTag.ele_id = NEXT_ELEMENT;
|
|
}
|
|
|
|
|
|
lo_CalcAlignOffsets(state, &text_info, java_app->objTag.alignment,
|
|
java_app_width, java_app_height,
|
|
&java_app->objTag.x_offset, &java_app->objTag.y_offset,
|
|
line_inc, baseline_inc);
|
|
}
|
|
|
|
void
|
|
lo_LayoutFloatJavaApp(MWContext *context,
|
|
lo_DocState *state,
|
|
LO_JavaAppStruct *java_app,
|
|
Bool updateFE)
|
|
{
|
|
int32 java_app_width;
|
|
|
|
java_app_width = (2 * java_app->objTag.border_width) +
|
|
(2 * java_app->objTag.border_horiz_space);
|
|
|
|
if (java_app->objTag.alignment == LO_ALIGN_RIGHT)
|
|
{
|
|
java_app->objTag.x = state->right_margin - java_app_width;
|
|
if (java_app->objTag.x < 0)
|
|
{
|
|
java_app->objTag.x = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
java_app->objTag.x = state->left_margin;
|
|
}
|
|
|
|
java_app->objTag.y = -1;
|
|
lo_AddMarginStack(state, java_app->objTag.x, java_app->objTag.y,
|
|
java_app->objTag.width, java_app->objTag.height,
|
|
java_app->objTag.border_width,
|
|
java_app->objTag.border_vert_space,
|
|
java_app->objTag.border_horiz_space,
|
|
java_app->objTag.alignment);
|
|
|
|
if (state->at_begin_line != FALSE)
|
|
{
|
|
lo_FindLineMargins(context, state, updateFE);
|
|
state->x = state->left_margin;
|
|
}
|
|
}
|
|
|
|
void
|
|
lo_UpdateStateAfterJavaAppLayout(lo_DocState *state,
|
|
LO_JavaAppStruct *java_app,
|
|
int32 line_inc,
|
|
int32 baseline_inc)
|
|
{
|
|
int32 java_app_width;
|
|
int32 x, y;
|
|
|
|
java_app_width = java_app->objTag.width + (2 * java_app->objTag.border_width) +
|
|
(2 * java_app->objTag.border_horiz_space);
|
|
|
|
state->baseline += (intn) baseline_inc;
|
|
state->line_height += (intn) (baseline_inc + line_inc);
|
|
|
|
/*
|
|
* Clean up state
|
|
*/
|
|
state->x = state->x + java_app->objTag.x_offset +
|
|
java_app_width - java_app->objTag.border_horiz_space;
|
|
state->linefeed_state = 0;
|
|
state->at_begin_line = FALSE;
|
|
state->trailing_space = FALSE;
|
|
state->cur_ele_type = LO_JAVA;
|
|
|
|
/* Determine the new position of the layer. */
|
|
x = java_app->objTag.x + java_app->objTag.x_offset + java_app->objTag.border_width;
|
|
y = java_app->objTag.y + java_app->objTag.y_offset + java_app->objTag.border_width;
|
|
|
|
/* Move layer to new position */
|
|
CL_MoveLayer(java_app->objTag.layer, x, y);
|
|
}
|
|
|