Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-05 00:25:27 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a71a79c489
gecko-dev/lib/layout/laydisp.c

849 lines
21 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* 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 "layout.h"
#include "laylayer.h"
#include "libi18n.h"
#include "xlate.h"
#include "layers.h"
#define IL_CLIENT /* XXXM12N Defined by Image Library clients */
#include "libimg.h" /* Image Library public API. */
#include "timing.h"
#ifdef PROFILE
#pragma profile on
#endif
#ifdef XP_MAC
# ifdef XP_TRACE
# undef XP_TRACE
# endif
# define XP_TRACE(X)
#else
#ifndef XP_TRACE
# define XP_TRACE(X) fprintf X
#endif
#endif /* XP_MAC */
/*
* BUGBUG LAYERS: This is a hack that is currently being used for selection
* but might be useful elsewhere. Essentially, for extending the selected
* text, we know exactly how much we want to draw (using FE_DisplaySubtext).
* Rather than ask for a synchronous refresh of the area and relying on
* LO_RefreshArea to do the correct drawing (actually, it can't do the
* correct drawing since it doesn't draw sub-strings), we temporarily replace
* the painter_func for the layer in question to one that just does the
* required drawing. We still do a synchronous refresh, but the temporary
* painter_func is called instead of the one that calls LO_RefreshArea.
*/
typedef struct LO_SelectionHackStruct {
MWContext *context;
LO_TextStruct *text;
int32 start_pos;
int32 end_pos;
Bool need_bg;
} LO_SelectionHackStruct;
static void
lo_selection_hack_painter_func(void *drawable,
CL_Layer *layer,
FE_Region update_region)
{
LO_SelectionHackStruct *hack = (LO_SelectionHackStruct *)CL_GetLayerClientData(layer);
FE_SetDrawable(hack->context, drawable);
/* For layers, we don't ever need to clear the background */
FE_DisplaySubtext(hack->context, FE_VIEW,
hack->text, hack->start_pos, hack->end_pos,
FALSE);
FE_SetDrawable(hack->context, NULL);
}
static void
lo_NormalizeStartAndEndOfSelection(LO_TextStruct *text, int32 *start,
int32 *end)
{
int32 p1, p2;
char *string;
int n;
int16 charset;
if (text->ele_attrmask & LO_ELE_SELECTED)
{
if (text->sel_start < 0)
{
p1 = 0;
}
else
{
p1 = text->sel_start;
}
if (text->sel_end < 0)
{
p2 = text->text_len - 1;
}
else
{
p2 = text->sel_end;
}
PA_LOCK(string, char *, text->text);
/*
* find beginning of first character
*/
charset = text->text_attr->charset;
switch (n = INTL_NthByteOfChar(charset, string, (int)(p1+1)))
{
case 0:
case 1:
break;
default:
p1 -= (n - 1);
if (p1 < 0)
{
p1 = 0;
}
break;
}
if (text->sel_start >= 0)
{
text->sel_start = p1;
}
/*
* find end of last character
*/
switch (n = INTL_NthByteOfChar(charset, string, (int)(p2+1)))
{
case 0:
break;
default:
p2 -= (n - 1);
if (p2 < 0)
{
p2 = 0;
}
/* fall through */
case 1:
p2 += INTL_IsLeadByte(charset, string[p2]);
if (p2 > text->text_len - 1)
{
p2 = text->text_len - 1;
}
break;
}
if (text->sel_end >= 0)
{
text->sel_end = p2;
}
*start = p1;
*end = p2;
PA_UNLOCK(text->text);
}
}
#ifdef DEBUG
void
LO_DUMP_RECT(XP_Rect *rect)
{
XP_TRACE(("Compositing rectangle: [%3d,%3d] %d x %d\n", rect->left, rect->top,
rect->right - rect->left, rect->bottom - rect->top));
}
#endif
/*
* BUGBUG LAYERS: Since we know that lo_DisplaySubtext is only done
* for selection, we generate a synchronous composite. This might
* not be the right thing to do: maybe we should have an additional
* argument to the LO_Display routines
*/
void
lo_DisplaySubtext(MWContext *context, LO_TextStruct *text,
int32 start_pos, int32 end_pos, Bool need_bg,
CL_Layer *sel_layer)
{
lo_NormalizeStartAndEndOfSelection(text, &start_pos, &end_pos);
/* If we have to draw, go through the compositor */
if (context->compositor) {
XP_Rect rect;
CL_Layer *layer;
int32 x_offset, y_offset;
if (!sel_layer)
layer = CL_FindLayer(context->compositor, LO_BODY_LAYER_NAME);
else
layer = sel_layer;
FE_GetTextFrame(context, text, start_pos, end_pos, &rect);
lo_GetLayerXYShift(layer, &x_offset, &y_offset);
XP_OffsetRect(&rect, -x_offset, -y_offset);
CL_UpdateLayerRect(context->compositor, layer, &rect, PR_FALSE);
return;
}
else
/* For layers, we don't ever need to clear the background */
FE_DisplaySubtext(context, FE_VIEW, text, start_pos, end_pos,
FALSE);
}
void
lo_DisplayText(MWContext *context,
LO_TextStruct *text, Bool need_bg)
{
int32 p1, p2;
LO_TextAttr tmp_attr;
LO_TextAttr *hold_attr;
TIMING_STOPCLOCK_OBJECT("lo:blank", context, context, "text");
/* Blinking text elements are placed in a separate layer */
if (context->compositor && text->text_attr->attrmask & LO_ATTR_BLINK)
{
if (! (text->ele_attrmask & LO_ELE_DRAWN))
{
/* XXX - If the BLINK is in a layer, we need to create the
blink layer as a child of that layer, not as a child of
the _BODY layer. */
CL_Layer *body_layer =
CL_FindLayer(context->compositor, LO_BODY_LAYER_NAME);
lo_CreateBlinkLayer(context, text, body_layer);
text->ele_attrmask |= LO_ELE_DRAWN;
}
/* All blink text drawing is handled by the blink layer's
painter function. Don't do any drawing here. */
return;
}
if (text->ele_attrmask & LO_ELE_SELECTED)
{
lo_NormalizeStartAndEndOfSelection(text, &p1, &p2);
if (p1 > 0)
{
/* For layers we don't ever need to clear the background */
FE_DisplaySubtext(context, FE_VIEW, text,
0, (p1 - 1), FALSE);
}
lo_CopyTextAttr(text->text_attr, &tmp_attr);
tmp_attr.fg.red = text->text_attr->bg.red;
tmp_attr.fg.green = text->text_attr->bg.green;
tmp_attr.fg.blue = text->text_attr->bg.blue;
tmp_attr.bg.red = text->text_attr->fg.red;
tmp_attr.bg.green = text->text_attr->fg.green;
tmp_attr.bg.blue = text->text_attr->fg.blue;
/* lo_CopyTextAttr doesn't copy the FE_Data. In
* this case, however, we need to copy the FE_Data
* because otherwise the front end will
* synthesize a new copy. This assumes that
* the FE_Data doesn't care about font color.
*/
tmp_attr.FE_Data = text->text_attr->FE_Data;
hold_attr = text->text_attr;
text->text_attr = &tmp_attr;
/* For layers we don't ever need to clear the background */
FE_DisplaySubtext(context, FE_VIEW, text, p1, p2,
FALSE);
text->text_attr = hold_attr;
if (p2 < (text->text_len - 1))
{
/* For layers we don't ever need to clear the background */
FE_DisplaySubtext(context, FE_VIEW, text,
(p2 + 1), (text->text_len - 1),
FALSE);
}
}
else
{
/* For layers we don't ever need to clear the background */
FE_DisplayText(context, FE_VIEW, text, FALSE);
}
}
void
lo_DisplayEmbed(MWContext *context, LO_EmbedStruct *embed)
{
CL_Layer *layer;
if (! context->compositor) {
FE_DisplayEmbed(context, FE_VIEW, embed);
return;
}
/* Don't ever display hidden embeds */
if (embed->objTag.ele_attrmask & LO_ELE_HIDDEN)
return;
layer = embed->objTag.layer;
XP_ASSERT(layer);
if (! layer) /* Paranoia */
return;
if (!(embed->objTag.ele_attrmask & LO_ELE_DRAWN)) {
/* Move layer to new position */
CL_MoveLayer(layer,
embed->objTag.x + embed->objTag.x_offset,
embed->objTag.y + embed->objTag.y_offset);
CL_SetLayerHidden(layer, PR_FALSE);
embed->objTag.ele_attrmask |= LO_ELE_DRAWN;
}
}
void
lo_DisplayBuiltin(MWContext *context, LO_BuiltinStruct *builtin)
{
CL_Layer *layer;
/* need to deal with layers here XXX */
if (! context->compositor) {
FE_DisplayBuiltin(context, FE_VIEW, builtin);
return;
}
layer = builtin->layer;
XP_ASSERT(layer);
if (! layer) /* Paranoia */
return;
if (!(builtin->ele_attrmask & LO_ELE_DRAWN)) {
/* Move layer to new position */
CL_MoveLayer(layer,
builtin->x + builtin->x_offset,
builtin->y + builtin->y_offset);
CL_SetLayerHidden(layer, PR_FALSE);
builtin->ele_attrmask |= LO_ELE_DRAWN;
}
}
#ifdef JAVA
void
lo_DisplayJavaApp(MWContext *context, LO_JavaAppStruct *java_app)
{
CL_Layer *layer;
if (! context->compositor) {
FE_DisplayJavaApp(context, FE_VIEW, java_app);
return;
}
layer = java_app->objTag.layer;
XP_ASSERT(layer);
if (! layer) /* Paranoia */
return;
if (!(java_app->objTag.ele_attrmask & LO_ELE_DRAWN)) {
/* Move layer to new position */
CL_MoveLayer(layer,
java_app->objTag.x + java_app->objTag.x_offset,
java_app->objTag.y + java_app->objTag.y_offset);
/* Now that layer is layed out to its final position,
we can display it */
CL_SetLayerHidden(layer, PR_FALSE);
java_app->objTag.ele_attrmask |= LO_ELE_DRAWN;
}
}
#endif
/* Make the image layer visible and draw the image border. Should only be called
if there is a compositor. */
static void
lo_DisplayImage(MWContext *context, LO_ImageStruct *image)
{
int bw = image->border_width;
XP_ASSERT(context->compositor);
/* Allow the compositor to start drawing the image layer. */
lo_ActivateImageLayer(context, image);
/* The image border, if present, draws in the parent of the image layer. */
if (bw) {
int x = image->x + image->x_offset + bw;
int y = image->y + image->y_offset + bw;
FE_DisplayBorder(context, FE_VIEW, x - bw, y - bw,
image->width + 2 * bw, image->height + 2 * bw, bw,
&image->text_attr->fg, LO_SOLID);
}
}
void
lo_DisplayImageWithoutCompositor(MWContext *context, LO_ImageStruct *image)
{
int bw = image->border_width;
int x = image->x + image->x_offset + bw;
int y = image->y + image->y_offset + bw;
int width = image->width;
int height = image->height;
/* This routine should only be called in the absence of a compositor. */
XP_ASSERT(!context->compositor);
/* Handle the TextFE. */
if (context->type == MWContextText) {
XL_DisplayTextImage(context, FE_VIEW, image);
return;
}
if (image->is_icon) {
IL_DisplayIcon(context->img_cx, image->icon_number, x, y);
}
else {
int cnv_x = context->convertPixX;
int cnv_y = context->convertPixY;
IL_DisplaySubImage(image->image_req, x/cnv_x, y/cnv_y, 0, 0,
width/cnv_x, height/cnv_y);
}
if (bw)
FE_DisplayBorder(context, FE_VIEW, x - bw, y - bw, width + 2 * bw,
height + 2 * bw, bw, &image->text_attr->fg, LO_SOLID);
}
void
lo_DisplaySubImageWithoutCompositor(MWContext *context, LO_ImageStruct *image,
int32 x, int32 y, uint32 width, uint32 height)
{
int bw = image->border_width;
int x_pos = image->x + image->x_offset + bw;
int y_pos = image->y + image->y_offset + bw;
int sub_x, sub_y, sub_w, sub_h;
/* This routine should only be called in the absence of a compositor. */
XP_ASSERT(!context->compositor);
/* Handle the TextFE. */
if (context->type == MWContextText) {
XL_DisplayTextImage(context, FE_VIEW, image);
return;
}
if (x < x_pos) {
sub_x = x_pos;
sub_w = width + x - x_pos;
}
else {
sub_x = x;
sub_w = width;
}
if (y < y_pos) {
sub_y = y_pos;
sub_h = height + y - y_pos;
}
else {
sub_y = y;
sub_h = height;
}
if (x + width > x_pos + image->width)
sub_w += (x_pos + image->width - x - width);
if (y + height > y_pos + image->height)
sub_h += (y_pos + image->height - y - height);
if (sub_w > 0 && sub_h > 0) {
if (image->is_icon) {
IL_DisplayIcon(context->img_cx, image->icon_number,
x_pos, y_pos);
}
else {
int cnv_x = context->convertPixX;
int cnv_y = context->convertPixY;
IL_DisplaySubImage(image->image_req, x_pos/cnv_x, y_pos/cnv_y,
(sub_x - x_pos)/cnv_x, (sub_y - y_pos)/cnv_y,
sub_w/cnv_x, sub_h/cnv_y);
}
}
if (bw)
FE_DisplayBorder(context, FE_VIEW, x - bw, y - bw, width + 2 * bw,
height + 2 * bw, bw, &image->text_attr->fg,
LO_SOLID);
}
/* Should only be called in the absence of a compositor. */
void
lo_ClipImage(MWContext *context, LO_ImageStruct *image,
int32 x, int32 y, uint32 width, uint32 height)
{
int32 sub_x, sub_y;
uint32 sub_w, sub_h;
/*
* If the two don't overlap, do nothing.
*/
if (((int32)(image->x + image->x_offset + image->width +
2*image->border_width) < x)||
((int32)(x + width) < (int32)(image->x + image->x_offset))||
((int32)(image->y + image->y_offset + image->height +
2*image->border_width) < y)||
((int32)(y + height) < (int32)(image->y + image->y_offset)))
{
return;
}
if ((image->x + image->x_offset) >= x)
{
sub_x = image->x + image->x_offset;
}
else
{
sub_x = x;
}
if ((int32)(image->x + image->x_offset + image->width + 2*image->border_width)
<= (int32)(x + width))
{
sub_w = image->x + image->x_offset + image->width +
2*image->border_width - sub_x;
}
else
{
sub_w = x + width - sub_x;
}
if ((image->y + image->y_offset) >= y)
{
sub_y = image->y + image->y_offset;
}
else
{
sub_y = y;
}
if ((int32)(image->y + image->y_offset + image->height + 2*image->border_width)
<= (int32)(y + height))
{
sub_h = image->y + image->y_offset + image->height +
2*image->border_width - sub_y;
}
else
{
sub_h = y + height - sub_y;
}
if (((int32)sub_w >= (int32)(image->width - 2))&&
((int32)sub_h >= (int32)(image->height - 2)))
{
lo_DisplayImageWithoutCompositor(context, (LO_ImageStruct *)image);
}
else
{
lo_DisplaySubImageWithoutCompositor(context, (LO_ImageStruct *)image,
sub_x, sub_y, sub_w, sub_h);
}
}
void
lo_DisplayEdge(MWContext *context, LO_EdgeStruct *edge)
{
if (edge->visible != FALSE)
{
FE_DisplayEdge(context, FE_VIEW, edge);
}
}
void
lo_DisplayTable(MWContext *context, LO_TableStruct *table)
{
FE_DisplayTable(context, FE_VIEW, table);
}
void
lo_DisplaySubDoc(MWContext *context, LO_SubDocStruct *subdoc)
{
FE_DisplaySubDoc(context, FE_VIEW, subdoc);
}
void
lo_DisplayCell(MWContext *context, LO_CellStruct *cell)
{
/* If this cell is empty, bail */
if (cell->cell_list == NULL && cell->cell_float_list == NULL)
return;
if (context->compositor && cell->cell_bg_layer)
CL_SetLayerHidden(cell->cell_bg_layer, PR_FALSE);
FE_DisplayCell(context, FE_VIEW, cell);
}
void
lo_DisplayLineFeed(MWContext *context,
LO_LinefeedStruct *lfeed, Bool need_bg)
{
LO_TextAttr tmp_attr;
LO_TextAttr *hold_attr;
if (lfeed->ele_attrmask & LO_ELE_SELECTED)
{
lo_CopyTextAttr(lfeed->text_attr, &tmp_attr);
tmp_attr.fg.red = lfeed->text_attr->bg.red;
tmp_attr.fg.green = lfeed->text_attr->bg.green;
tmp_attr.fg.blue = lfeed->text_attr->bg.blue;
tmp_attr.bg.red = lfeed->text_attr->fg.red;
tmp_attr.bg.green = lfeed->text_attr->fg.green;
tmp_attr.bg.blue = lfeed->text_attr->fg.blue;
hold_attr = lfeed->text_attr;
lfeed->text_attr = &tmp_attr;
FE_DisplayLineFeed(context, FE_VIEW, lfeed, (XP_Bool)need_bg);
lfeed->text_attr = hold_attr;
}
else
{
FE_DisplayLineFeed(context, FE_VIEW, lfeed, (XP_Bool)need_bg);
}
}
void
lo_DisplayHR(MWContext *context, LO_HorizRuleStruct *hrule)
{
FE_DisplayHR(context, FE_VIEW, hrule);
}
void
lo_DisplayBullet(MWContext *context, LO_BulletStruct *bullet)
{
FE_DisplayBullet(context, FE_VIEW, bullet);
}
void
lo_DisplayFormElement(MWContext *context, LO_FormElementStruct *form_element)
{
CL_Layer *layer;
if (! context->compositor) {
FE_DisplayFormElement(context, FE_VIEW, form_element);
return;
}
layer = form_element->layer;
XP_ASSERT(layer);
if (! layer) /* Paranoia */
return;
if (!(form_element->ele_attrmask & LO_ELE_DRAWN)) {
/* Move layer to new position */
CL_MoveLayer(layer,
form_element->x + form_element->x_offset +
form_element->border_horiz_space,
form_element->y + form_element->y_offset +
form_element->border_vert_space);
CL_SetLayerHidden(layer, PR_FALSE);
form_element->ele_attrmask |= LO_ELE_DRAWN;
}
}
void
lo_DisplayElement(MWContext *context, LO_Element *tptr,
int32 base_x, int32 base_y,
int32 x, int32 y,
uint32 width, uint32 height)
{
LO_Any *any = &tptr->lo_any;
XP_Rect bbox;
lo_GetElementBbox(tptr, &bbox);
XP_OffsetRect(&bbox, base_x, base_y);
if (bbox.top >= (int32)(y + height))
return;
if (bbox.bottom <= y )
return;
if (bbox.left >= (int32)(x + width))
return;
if (bbox.right <= x )
return;
/* Temporarily translate to new coordinate system */
any->x += base_x;
any->y += base_y;
switch (tptr->type)
{
case LO_TEXT:
if (tptr->lo_text.text != NULL)
lo_DisplayText(context, (LO_TextStruct *)tptr, FALSE);
break;
case LO_LINEFEED:
lo_DisplayLineFeed(context, (LO_LinefeedStruct *)tptr, FALSE);
break;
case LO_HRULE:
lo_DisplayHR(context, (LO_HorizRuleStruct *)tptr);
break;
case LO_FORM_ELE:
lo_DisplayFormElement(context, (LO_FormElementStruct *)tptr);
break;
case LO_BULLET:
lo_DisplayBullet(context, (LO_BulletStruct *)tptr);
break;
case LO_IMAGE:
if (context->compositor) {
/* Allow the compositor to start drawing the image. */
lo_DisplayImage(context, (LO_ImageStruct *)tptr);
}
else {
/* There is no compositor, so draw the image directly, with the
appropriate clip. */
lo_ClipImage(context,
(LO_ImageStruct *)tptr,
(x + base_x),
(y + base_y), width, height);
}
break;
case LO_TABLE:
lo_DisplayTable(context, (LO_TableStruct *)tptr);
break;
case LO_EMBED:
lo_DisplayEmbed(context, (LO_EmbedStruct *)tptr);
break;
case LO_BUILTIN:
lo_DisplayBuiltin(context, (LO_BuiltinStruct *)tptr);
break;
#ifdef JAVA
case LO_JAVA:
lo_DisplayJavaApp(context, (LO_JavaAppStruct *)tptr);
break;
#endif
case LO_EDGE:
lo_DisplayEdge(context, (LO_EdgeStruct *)tptr);
break;
case LO_CELL:
/* If this cell is a container for an inflow layer (and
therefore not a table cell), don't descend into the cell
because the layer's painter function will handle its
display. */
if (((LO_CellStruct*)tptr)->cell_inflow_layer)
break;
/* cmanske: reversed order so cell selection highlighting
shows up over text in the cell */
lo_DisplayCellContents(context, (LO_CellStruct *)tptr,
base_x, base_y, x, y, width, height);
lo_DisplayCell(context, (LO_CellStruct *)tptr);
break;
case LO_SUBDOC:
{
LO_SubDocStruct *subdoc;
int32 new_x, new_y;
uint32 new_width, new_height;
lo_DocState *sub_state;
subdoc = (LO_SubDocStruct *)tptr;
sub_state = (lo_DocState *)subdoc->state;
if (sub_state == NULL)
{
break;
}
lo_DisplaySubDoc(context, subdoc);
new_x = subdoc->x;
new_y = subdoc->y;
new_width = subdoc->x_offset + subdoc->width;
new_height = subdoc->y_offset + subdoc->height;
new_x = new_x - subdoc->x;
new_y = new_y - subdoc->y;
sub_state->base_x = subdoc->x +
subdoc->x_offset + subdoc->border_width;
sub_state->base_y = subdoc->y +
subdoc->y_offset + subdoc->border_width;
lo_RefreshDocumentArea(context, sub_state,
new_x, new_y, new_width, new_height);
}
break;
case LO_PARAGRAPH:
case LO_CENTER:
case LO_MULTICOLUMN:
case LO_LIST:
case LO_DESCTITLE:
case LO_DESCTEXT:
case LO_BLOCKQUOTE:
case LO_HEADING:
case LO_SPAN:
case LO_SUB:
case LO_SUPER:
/* all non-display, doc-state mutating elements. */
break;
case LO_TEXTBLOCK:
break;
case LO_FLOAT:
case LO_LAYER:
case LO_SPACER:
break;
default:
XP_TRACE(("lo_DisplayElement(%p) skip element type = %d\n", tptr, tptr->type));
break;
}
/* Restore original element's coordinates */
any->x -= base_x;
any->y -= base_y;
}
#ifdef PROFILE
#pragma profile off
#endif
Reference in New Issue View Git Blame Copy Permalink