/* -*- Mode: C++; tab-width: 8; 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 "layout.h" #include "laylayer.h" #include "libi18n.h" #include "edt.h" #include "layers.h" #include /* For lo_CharacterClassOf */ #ifndef XP_TRACE # define XP_TRACE(X) fprintf X #endif #ifdef TEST_16BIT #define XP_WIN16 #endif /* TEST_16BIT */ #ifdef XP_WIN16 #define SIZE_LIMIT 32000 #endif /* XP_WIN16 */ #ifdef PROFILE #pragma profile on #endif #ifdef DEBUG void lo_ValidatePosition(MWContext *context, LO_Position* position); void lo_ValidateSelection(MWContext *context, LO_Selection* selection); void lo_ValidatePosition2(MWContext *context, LO_Element* element, int32 position); void lo_ValidateSelection2(MWContext *context, LO_Element* elementB, int32 positionB, LO_Element* elementE, int32 positionE); #define LO_ASSERT_POSITION(context, p) lo_ValidatePosition(context, p) #define LO_ASSERT_SELECTION(context, s) lo_ValidateSelection(context, s) #define LO_ASSERT_POSITION2(context, e, p) lo_ValidatePosition2(context, e, p) #define LO_ASSERT_SELECTION2(context, eb, pb, ee, pe) lo_ValidateSelection2(context, eb, pb, ee, pe) #else #define LO_ASSERT_POSITION(context, p) {} #define LO_ASSERT_SELECTION(context, s) {} #define LO_ASSERT_POSITION2(context, e, p) {} #define LO_ASSERT_SELECTION2(context, eb, pb, ee, pe) {} #endif static void lo_bump_position(MWContext *context, lo_DocState *state, LO_Element *sel, int32 pos, LO_Element **new_sel, int32 *new_pos, Bool forward); /* * Utility functions to convert between insert point and selection end. * Returns FALSE if the conversion can't be done. * (Only happens when the insert point is off the beginning of the document, or the * selection end is off the end of the document.) In those cases, the input position is * returned unchanged. * */ Bool lo_ConvertInsertPointToSelectionEnd(MWContext* context, lo_DocState * state, LO_Element** element, int32* position); Bool lo_ConvertSelectionEndToInsertPoint(MWContext* context, lo_DocState * state, LO_Element** element, int32* position); void lo_HighlightSelect(MWContext *context, lo_DocState *state, LO_Element *start, int32 start_pos, LO_Element *end, int32 end_pos, Bool on); void lo_SetSelect(MWContext *context, lo_DocState *state, LO_Element *start, int32 start_pos, LO_Element *end, int32 end_pos, Bool on); void lo_StartNewSelection(MWContext *context, lo_DocState * state, LO_Element* eptr, int32 position); void lo_ExtendSelectionToPosition2(MWContext *context, lo_TopState* top_state, lo_DocState *state, LO_Element* eptr, int32 position); /* Makes sure *eptr points to an editable element. If *eptr doesn't, searches towards * the end of the document. * If no editiable element is found, the function * returns FALSE. */ Bool lo_EnsureEditableSearchNext(MWContext *context, lo_DocState *state, LO_Element** eptr); Bool lo_EnsureEditableSearchNext2(MWContext *context, lo_DocState *state, LO_Element** eptr, int32* ePositionPtr); /* Same as lo_EnsureEditableSearchNext, except searches towards the start of document. */ Bool lo_EnsureEditableSearchPrev(MWContext *context, lo_DocState *state, LO_Element** eptr); Bool lo_EnsureEditableSearchPrev2(MWContext *context, lo_DocState *state, LO_Element** eptr, int32* ePositionPtr); Bool lo_EnsureEditableSearch(MWContext *context, lo_DocState* state, LO_Position* p, Bool forward); Bool lo_EnsureEditableSearch2(MWContext *context, lo_DocState* state, LO_Element** eptr, int32* ePositionPtr, Bool forward); Bool lo_IsValidEditableInsertPoint2(MWContext *context, lo_DocState* state, LO_Element* eptr, int32 ePositionPtr); /* Normalizes the selection, if editing is turned on. Returns TRUE if the selection * is non empty. */ Bool lo_NormalizeSelection(MWContext *context); /* * Return FALSE if the selection point can't be normalized. * (i.e. if it's at the end of the document.) */ Bool lo_NormalizeSelectionPoint(MWContext *context, lo_DocState *state, LO_Element** pEptr, int32* pPosition); void lo_NormalizeSelectionEnd(MWContext *context, lo_DocState *state, LO_Element** pEptr, int32* pPosition); int32 lo_GetTextAttrMask(LO_Element* eptr); LO_AnchorData* lo_GetAnchorData(LO_Element* eptr); LO_Element* lo_GetNeighbor(LO_Element* element, Bool forward); int32 lo_GetElementEdge(LO_Element* element, Bool forward); int32 lo_GetMaximumInsertPointPosition(LO_Element* eptr); int32 lo_GetLastCharEndPosition(LO_Element* eptr); int32 lo_GetLastCharBeginPosition(LO_Element* eptr); int32 lo_IncrementPosition(LO_Element* eptr, int32 position); int32 lo_DecrementPosition(LO_Element* eptr, int32 position); Bool lo_IsEndOfParagraph2(MWContext* context, LO_Element* element, int32 position); Bool lo_FindDocumentEdge(MWContext* context, lo_DocState *state, LO_Position* edge, Bool select, Bool forward); Bool lo_IsEdgeOfDocument2(MWContext* context, lo_DocState *state, LO_Element* element, int32 position, Bool forward); Bool lo_IsEdgeOfDocument(MWContext* context, lo_DocState *state, LO_Position* where, Bool forward); void lo_SetInsertPoint(MWContext *context, lo_TopState *top_state, LO_Element* eptr, int32 position, CL_Layer *layer); /* * Implements the UI policy for a click on an element. Returns TRUE if the result is an insertion point. */ Bool lo_ProcessClick(MWContext *context, lo_TopState *top_state, lo_DocState *state, LO_HitResult* result, Bool requireCaret, CL_Layer *layer); Bool lo_ProcessDoubleClick(MWContext *context, lo_TopState *top_state, lo_DocState *state, LO_HitResult* result, CL_Layer *layer); Bool lo_ProcessAnchorClick(MWContext *context, lo_TopState *top_state, lo_DocState *state, LO_HitResult* result); Bool lo_SelectAnchor(MWContext* context, lo_DocState *state, LO_Element* eptr); void lo_SetSelection(MWContext *context, LO_Selection* selection, Bool extendingStart); void lo_FullSetSelection(MWContext *context, lo_DocState * state, LO_Element* start, int32 start_pos, LO_Element* end, int32 end_pos, Bool extendStart); /* Get various selection parts, expressed as insert points. */ void lo_GetAnchorPoint(MWContext *context, lo_DocState * state, LO_Element** pElement, int32* pPosition); void lo_GetExtensionPoint(MWContext *context, lo_DocState * state, LO_Element** pElement, int32* pPosition); Bool lo_FindBestPositionInTable(MWContext *context, lo_DocState* state, LO_TableStruct* pTable, int32 iDesiredX, int32 iDesiredY, Bool bForward, int32* pRetX, int32 *pRetY ); Bool lo_FindClosestUpDown_Cell(MWContext *pContext, lo_DocState* state, LO_CellStruct* cell, int32 x, int32 y, Bool bForward, int32* ret_x, int32* ret_y); LO_Element * lo_search_element_list_WideMatch(MWContext *context, LO_Element *eptr, LO_Element* eEndPtr, int32 x, int32 y, Bool bForward); Bool lo_EditableElement( int iType ) { if( iType == LO_TEXT || iType == LO_TEXTBLOCK || iType == LO_IMAGE || iType == LO_HRULE || iType == LO_LINEFEED || iType == LO_FORM_ELE ) { return TRUE; } else { return FALSE; } } PRIVATE int32 lo_ElementToCharOffset2(MWContext *context, lo_DocState *state, LO_Element *element, int32 x, int32* returnCharStart, int32* returnCharEnd) { LO_TextStruct *text_ele; LO_TextInfo text_info; int32 orig_len; int32 xpos; int32 cpos; int32 start, end; int16 charset; int32 startX; if ((element == NULL)||(element->type != LO_TEXT)) { return(-1); } text_ele = (LO_TextStruct *)element; if ((text_ele->text == NULL)||(text_ele->text_len <= 0)) { return -1; } startX = text_ele->x + text_ele->x_offset; xpos = x - startX; if (xpos < 0) { return -1; } if (xpos >= text_ele->width && returnCharStart == NULL) { return lo_GetLastCharEndPosition(element); } start = 0; end = lo_GetLastCharEndPosition(element); /* Make a guess as to where to start searching, assuming characters are * all roughly the same width. */ if ( text_ele->width > 0 ) { cpos = xpos * text_ele->text_len / text_ele->width; } else { cpos = 0; } if (cpos > end) { cpos = end; } orig_len = text_ele->text_len; charset = text_ele->text_attr->charset; if (INTL_CharSetType(charset) == SINGLEBYTE) { while (start < end) { XP_ASSERT(cpos >= 0); text_ele->text_len = (intn) cpos + 1; FE_GetTextInfo(context, text_ele, &text_info); if (xpos > text_info.max_width) { start = cpos + 1; } else { end = cpos; } cpos = (start + end) / 2; } /* Find character width by trickery */ text_ele->text_len = (intn) cpos; FE_GetTextInfo(context, text_ele, &text_info); if ( returnCharStart != NULL ) *returnCharStart = startX + text_info.max_width; text_ele->text_len = (intn) cpos+1; FE_GetTextInfo(context, text_ele, &text_info); if ( returnCharEnd != NULL ) *returnCharEnd = startX + text_info.max_width; } else { /* slow multibyte finding, I feel sad we can't use the beautiful single byte algorithm above */ int32 prev_xpos, last_xpos, last_pos; char *tptr; PA_LOCK(tptr, char *, text_ele->text); cpos = 0; prev_xpos = 0; last_xpos = text_ele->width ; last_pos = end ; while ((start <= end) && (cpos <= end)) { text_ele->text_len = (intn) cpos ; FE_GetTextInfo(context, text_ele, &text_info); if (xpos > text_info.max_width) { prev_xpos = text_info.max_width ; start = text_ele->text_len; } else /* since it goes char by char, finding ends here */ { last_xpos = text_info.max_width ; end = cpos; break ; } /* go to next char */ cpos = start + (int32)INTL_CharLen(charset, (unsigned char *)(tptr + start)); } cpos = start ; if (cpos > last_pos) cpos = last_pos ; PA_UNLOCK(text_ele->text); if ( returnCharStart != NULL ) *returnCharStart = startX + prev_xpos; if ( returnCharEnd != NULL) *returnCharEnd = startX + last_xpos; } text_ele->text_len = (intn) orig_len; return(cpos); } /* * For clients that don't care about the bounds of what they hit. */ PRIVATE int32 lo_ElementToCharOffset(MWContext *context, lo_DocState *state, LO_Element *element, int32 x) { return lo_ElementToCharOffset2(context, state, element, x, NULL, NULL); } void LO_StartSelection(MWContext *context, int32 x, int32 y, CL_Layer *layer) { #if 0 int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element *eptr; int32 position; int32 ret_x, ret_y; /* * 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; } state = top_state->doc_state; LO_HighlightSelection(context, FALSE); state->selection_start = NULL; state->selection_start_pos = 0; state->selection_end = NULL; state->selection_end_pos = 0; position = 0; eptr = lo_XYToDocumentElement(context, state, x, y, FALSE, TRUE, TRUE, &ret_x, &ret_y); if (eptr != NULL) { position = lo_ElementToCharOffset(context, state, eptr, ret_x); if (position < 0) { position = 0; } } state->selection_new = eptr; state->selection_new_pos = position; #endif LO_Click(context, x, y, ! EDT_IS_EDITOR(context), layer); /* Only allow selections in editor */ } /* * Used for right-clicks. */ void LO_SelectObject( MWContext *context, int32 x, int32 y, CL_Layer *layer) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_HitResult result; /* * 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; } state = top_state->doc_state; LO_Hit(context, x, y, FALSE, &result, layer); if ( ! lo_ProcessAnchorClick(context, top_state, state, &result ) ) { lo_ProcessClick(context, top_state, state, &result, FALSE, layer ); } } void LO_StartSelectionFromElement( MWContext *context, LO_Element *eptr, int32 new_pos, CL_Layer *layer ) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; if ( eptr ) { if ( ! lo_EnsureEditableSearchPrev2(context, state, &eptr, &new_pos) ) { XP_ASSERT(FALSE); return; } LO_ASSERT_POSITION2(context, eptr, new_pos); } LO_HighlightSelection(context, FALSE); state->selection_start = NULL; state->selection_start_pos = 0; state->selection_end = NULL; state->selection_end_pos = 0; state->selection_new = eptr; state->selection_new_pos = new_pos; state->selection_layer = layer; } #ifdef DEBUG PRIVATE void LO_DUMP_SELECTIONSTATE(MWContext *context) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; XP_TRACE(("selection 0x%08x %d 0x%08x %d new 0x%08x %d extending_start %d\n", state->selection_start, state->selection_start_pos, state->selection_end, state->selection_end_pos, state->selection_new, state->selection_new_pos, state->extending_start)); } PRIVATE void LO_DUMP_INSERT_POINT(char* s, LO_Element* element, int32 position) { if ( element ) { XP_TRACE(("%s %d:%d.%d ", s, element->type, element->lo_any.ele_id, position)); } else { XP_TRACE(("%s - NIL", s)); } } PRIVATE void LO_DUMP_POSITION(char* s, LO_Position* position) { LO_DUMP_INSERT_POINT(s, position->element, position->position); } PRIVATE void LO_DUMP_SELECTION2(char* s, LO_Element* a, int32 ap, LO_Element* b, int32 bp) { /* const char* kElementCodes = "?tlhi?????????????????";*/ XP_TRACE(("%s %d:%d.%d %d:%d.%d ", s, a->type, a->lo_any.ele_id, ap, b->type, b->lo_any.ele_id, bp)); } PRIVATE void LO_DUMP_SELECTION(char* s, LO_Selection* selection) { LO_DUMP_SELECTION2(s, selection->begin.element, selection->begin.position, selection->end.element, selection->end.position); } PRIVATE void LO_DUMP_HIT_RESULT(LO_HitResult* result) { switch ( result->type ) { case LO_HIT_UNKNOWN: XP_TRACE(("Unknown")); break; case LO_HIT_LINE: { char* s; switch ( result->lo_hitLine.region ) { case LO_HIT_LINE_REGION_BEFORE: { s = "before line"; } break; case LO_HIT_LINE_REGION_AFTER: { s = "after line"; } break; default: s = "LO_HIT_LINE Bad region"; break; } LO_DUMP_SELECTION(s, & result->lo_hitLine.selection); } break; case LO_HIT_ELEMENT: { char* s; switch ( result->lo_hitElement.region ) { case LO_HIT_ELEMENT_REGION_BEFORE: { s = "before element"; } break; case LO_HIT_ELEMENT_REGION_MIDDLE: { s = "middle element"; } break; case LO_HIT_ELEMENT_REGION_AFTER: { s = "after element"; } break; default: { s = "LO_HIT_ELEMENT unknown region"; } break; } LO_DUMP_POSITION(s, & result->lo_hitElement.position); } break; default: { XP_TRACE(("LO_HIT unknown result ")); } break; } } #endif Bool LO_IsSelected(MWContext *context) { int32 doc_id; lo_TopState *top_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 FALSE; } state = top_state->doc_state; return (state->selection_start != NULL); } Bool LO_IsSelectionStarted(MWContext *context) { int32 doc_id; lo_TopState *top_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 FALSE; } state = top_state->doc_state; return (state->selection_new != NULL); } PRIVATE void lo_JiggleToMakeEditable( MWContext *context, lo_DocState *state, LO_Element** ppElement, int32 *pPosition, Bool bForward) { /* If it's not an editable element, move to find one that is. * We don't call the ensure routines because we don't want to * select end-of-paragraph linefeeds here. * */ LO_Element* element = *ppElement; int32 position = *pPosition; if ( (! EDT_IS_EDITOR(context)) || (element && element->lo_any.edit_element) ) { return; } while( element && ! element->lo_any.edit_element ){ LO_Element* newElement; int32 newPosition; lo_bump_position(context, state, element, position, &newElement, &newPosition, bForward); if ( element == newElement && position == newPosition ) { /* We got stuck */ element = NULL; break; } element = newElement; position = newPosition; } if ( ! element ) { /* Ran off end of document */ element = *ppElement; position = *pPosition; while( element && ! element->lo_any.edit_element ){ LO_Element* newElement; int32 newPosition; lo_bump_position(context, state, element, position, &newElement, &newPosition, !bForward); if ( element == newElement && position == newPosition ) { /* We got stuck */ element = NULL; break; } element = newElement; position = newPosition; } } if ( element ) { *ppElement = element; *pPosition = lo_GetElementEdge(element, !bForward); } } /* This is only called from the editor. As a convienience to the * editor, we return the selection as a 1/2 open selection. That * means we convert the selection end into an insert point. */ void LO_GetSelectionEndPoints( MWContext *context, LO_Element** ppStart, intn *pStartOffset, LO_Element** ppEnd, intn *pEndOffset, Bool* pbFromStart, Bool* pbSingleItemSelection ) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element* startElement; int32 startPosition; LO_Element* endElement; int32 endPosition; /* * 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; } state = top_state->doc_state; startElement = state->selection_start; startPosition = state->selection_start_pos; /* If it's not an editable element, move backward to find one that is. * We don't call the ensure routines because we don't want to * select end-of-paragraph linefeeds here. * * But now that we have tables, we need to bump. */ lo_JiggleToMakeEditable( context, state, &startElement, &startPosition, FALSE); if( ppStart ) *ppStart = startElement; if( pStartOffset ) *pStartOffset = startPosition; /* Convert the selection end into an insert point. */ endElement = state->selection_end; endPosition = state->selection_end_pos; if ( endElement ) { lo_ConvertSelectionEndToInsertPoint(context, state, &endElement, &endPosition); } /* If it's not an editable element, move forward to find one that is. * We don't call the ensure routines because we don't want to * select end-of-paragraph linefeeds here. */ lo_JiggleToMakeEditable( context, state, &endElement, &endPosition, TRUE); if( ppEnd ) *ppEnd = endElement; if( pEndOffset ) *pEndOffset = endPosition; if( pbFromStart ) *pbFromStart = state->extending_start; /* * the editor needs to know if the select is just a single thing like a * image or a HRULE. */ if( pbSingleItemSelection ) *pbSingleItemSelection = ( startElement && startElement->type != LO_TEXT && startElement->type != LO_TEXTBLOCK && startElement == endElement ); /* * For lloyd's edification, if we have a single item seleciton, start_pos * is 0 and end_pos is 0 or 1 */ XP_ASSERT( pbSingleItemSelection && *pbSingleItemSelection ? startPosition == 0 && ( endPosition == 0 || endPosition == 1 ) : TRUE); } void LO_GetSelectionNewPoint( MWContext *context, LO_Element** ppNew, intn *pNewOffset) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; if( ppNew ) *ppNew = state->selection_new; if( pNewOffset ) *pNewOffset = state->selection_new_pos; } static intn lo_compare_selections(LO_Element *sel1, int32 pos1, LO_Element *sel2, int32 pos2) { if ((sel1 == NULL)||(sel2 == NULL)) { if (sel1 == sel2) { return(0); } else if (sel1 == NULL) { return(-1); } else { return(1); } } if (sel1->lo_any.ele_id < sel2->lo_any.ele_id) { return(-1); } else if (sel1->lo_any.ele_id > sel2->lo_any.ele_id) { return(1); } else if (sel1->lo_any.ele_id == sel2->lo_any.ele_id) { if (pos1 < pos2) { return(-1); } else if (pos1 > pos2) { return(1); } else if (pos1 == pos2) { return(0); } } #ifdef DEBUG assert (FALSE); #endif return(-1); } PRIVATE intn lo_ComparePositions(LO_Position* a, LO_Position* b) { return lo_compare_selections( a->element, a->position, b->element, b->position); } PRIVATE LO_Element* lo_BoundaryJumpingNext(MWContext *context, lo_DocState *state, LO_Element *eptr) { int32 last_id; LO_Element *cell_parent; /* * If no next element, see if we need to jump the cell wall. */ Bool success=FALSE; while(!success) { LO_Element* next = eptr->lo_any.next; last_id = eptr->lo_any.ele_id; cell_parent = NULL; while ( eptr && ! next ) { LO_Element* oldEptr = eptr; eptr = lo_JumpCellWall(context, state, eptr); if ( ! eptr || eptr == oldEptr ) break; /* Ran off the end of the document */ next = eptr->lo_any.next; } eptr = next; /* * When we walk onto a cell, * we need to walk into it if * it isn't empty. */ if ((eptr != NULL)&& (eptr->type == LO_CELL)&& (eptr->lo_cell.cell_list != NULL)) { cell_parent = eptr; eptr = eptr->lo_cell.cell_list; } /* * Heuristic: For some difficult tables, you may come back * to the same cell you left instead of progressing. * If so, try manually moving the cell forward. */ if ((eptr != NULL)&&(eptr->lo_any.ele_id == last_id)&& (cell_parent != NULL)) { LO_Element *guess; guess = cell_parent->lo_any.next; /* * If our guessed next element after the parent cell is * a non-empty cell, make the first element in that * cell our new element. */ if ((guess != NULL)&&(guess->type == LO_CELL)&& (guess->lo_cell.cell_list != NULL)) { eptr = guess->lo_cell.cell_list; } } /* * We don't want infinite loops. * If the element ID hasn't progressed, something * serious is wrong, and we should punt. */ if ((eptr != NULL)&&(eptr->lo_any.ele_id <= last_id)) { #ifdef DEBUG XP_TRACE(("Cell Jump loop avoidance 1\n")); #endif /* DEBUG */ return NULL; } success=TRUE; /* unless we detect a LO_TEXTBLOCK */ /* check textblock until not textblock leave prev as null if you hit null */ if (( next && eptr->type == LO_TEXTBLOCK ) || ( next && eptr->type == LO_DESCTITLE )) { success=FALSE; } } return eptr; } /* * We changed celljumping to boundary jumping to include type 19/LO_TEXTBLOCK as a type to skip past. anthonyd */ PRIVATE LO_Element* lo_BoundaryJumpingPrev(MWContext *context, lo_DocState *state, LO_Element *eptr) { /* * If no previous element, see if we need to jump the cell wall. */ LO_Element* prev; Bool success=FALSE; while(!success) { prev = eptr->lo_any.prev; while ( eptr && ! prev ) { LO_Element* oldEptr = eptr; eptr = lo_JumpCellWall(context, state, eptr); if ( ! eptr || eptr == oldEptr ) break; /* Ran off the front of the document */ prev = eptr->lo_any.prev; if ( ! prev ) continue; /* Ran off the front of the cell/document */ if ( prev->type == LO_TABLE ) { /* That was the first cell of the table. */ eptr = prev; prev = eptr->lo_any.prev; /* Repeat the check that was made above since we've moved eptr. */ if ( eptr == oldEptr ) break; } } success=TRUE; /* successfull until textblock check */ /* * When we walk onto a cell, * we need to walk into it if * it isn't empty. */ if ((prev != NULL)&& (prev->type == LO_CELL)&& (prev->lo_cell.cell_list_end != NULL)) { prev = prev->lo_cell.cell_list_end; } eptr = prev; /* check textblock until not textblock leave prev as null if you hit null */ if (( prev && eptr->type == LO_TEXTBLOCK ) || ( prev && eptr->type == LO_DESCTITLE )) { success=FALSE; } } return eptr; } static void lo_bump_position(MWContext *context, lo_DocState *state, LO_Element *sel, int32 pos, LO_Element **new_sel, int32 *new_pos, Bool forward) { LO_Element *eptr; int32 position; eptr = sel; position = pos; /* * Moving forward one selection position */ if (forward != FALSE) { /* * If it is not a text element, just move * to the next element. */ if (eptr->lo_any.type != LO_TEXT) { eptr = lo_BoundaryJumpingNext(context, state, eptr); if (eptr == NULL) { eptr = sel; } /* * Else start at the beginning of the next element */ else { position = 0; } } /* * Else this is a text element, so check moving * forward within the element. */ else { intn maxPosition = lo_GetLastCharBeginPosition(eptr); /* * If we are already at the end of the text * element we are back to moving on to the * next element. */ if (position < maxPosition) { position = lo_IncrementPosition(eptr, position); } else { eptr = lo_BoundaryJumpingNext(context, state, eptr); if (eptr == NULL) { eptr = sel; } /* * Else start at the beginning of the next element */ else { position = 0; } } } } /* * Else moving backward one selection position */ else { /* * If it is not a text element, just move * to the previous element. */ if (eptr->lo_any.type != LO_TEXT) { eptr = lo_BoundaryJumpingPrev(context, state, eptr); /* * If no previous element, don't move it. */ if (eptr == NULL) { eptr = sel; } /* * Else start at the end of the previous element. * (only matters for text elements) */ else { position = lo_GetLastCharBeginPosition(eptr); } } /* * Else this is a text element, so check moving * backward within the element. */ else { /* * If we are already at the beginning of the text * element we are back to moving back to the * previous element. */ if (position == 0) { eptr = lo_BoundaryJumpingPrev(context, state, eptr); /* * If no previous element, don't move it. */ if (eptr == NULL) { eptr = sel; } /* * Else start at the end of the previous * element. * (only matters for text elements) */ else { position = lo_GetLastCharBeginPosition(eptr); } } /* * This is the easy case, move one position * backward in the selected text element. */ else { position = lo_DecrementPosition(eptr, position); } } } *new_sel = eptr; *new_pos = position; } PRIVATE Bool lo_BumpPosition(MWContext *context, lo_DocState *state, LO_Position* position, Bool forward) { LO_Element* newElement; int32 newPosition; lo_bump_position(context, state, position->element, position->position, &newElement, &newPosition, forward); if ( newElement == NULL || lo_compare_selections(newElement, newPosition, position->element, position->position) == 0) { /* We ran out of room. */ return FALSE; } position->element = newElement; position->position = newPosition; return TRUE; } PRIVATE Bool lo_ValidEditableElement(MWContext *context, LO_Element* eptr) { return lo_EditableElement(eptr->type) && ( (!EDT_IS_EDITOR(context) ) || (eptr->lo_any.edit_element != 0 && eptr->lo_any.edit_offset >= 0)); } PRIVATE Bool lo_ValidEditableElementIncludingParagraphMarks(MWContext *context, LO_Element* pElement) { return lo_ValidEditableElement(context, pElement) || (pElement->type== LO_LINEFEED && pElement->lo_linefeed.break_type == LO_LINEFEED_BREAK_PARAGRAPH); } /* Moves by one editable position forward or backward. Returns FALSE if it couldn't. * Assumes that position is normalized, doesn't denormalize it. */ PRIVATE Bool lo_BumpNormalizedEditablePosition(MWContext *context, lo_DocState *state, LO_Element **pEptr, int32 *pPosition, Bool direction) { LO_Element* newEptr; int32 newPosition; if ( ! ( pEptr && *pEptr && pPosition ) ) { XP_ASSERT(FALSE); return FALSE; } newEptr = *pEptr; newPosition = *pPosition; { int32 length = lo_GetElementLength(newEptr); if ( ! (newPosition >= 0 && ( newPosition < length || length == 0 ) ) ) { XP_ASSERT(FALSE); return FALSE; } } do { LO_Element* oldEptr = newEptr; int32 oldPosition = newPosition; lo_bump_position(context, state, newEptr, newPosition, &newEptr, &newPosition, direction); if ( newEptr == NULL || lo_compare_selections(newEptr, newPosition, oldEptr, oldPosition) == 0) { /* We ran out of room. */ return FALSE; } } while ( ! lo_ValidEditableElementIncludingParagraphMarks(context, newEptr) ); *pEptr = newEptr; *pPosition = newPosition; return TRUE; } /* This function is only intended for the internal use of * lo_BumpEditablePosition. It handles the quick case where * the position doesn't cross over the object boundary. */ PRIVATE Bool lo_QuickBumpEditablePosition(MWContext *context, lo_DocState *state, LO_Element **pEptr, int32 *pPosition, Bool direction) { if ( direction ) { if ( *pPosition < lo_GetMaximumInsertPointPosition(*pEptr) ) { /* Easy case: Moving forward within an element. */ *pPosition = lo_IncrementPosition(*pEptr, *pPosition); /* XP_TRACE(("new position = %d", *pPosition)); */ return TRUE; } } else { if ( *pPosition > 0 ) { /* Easy case: Moving backward within an element. */ *pPosition = lo_DecrementPosition(*pEptr, *pPosition); /* XP_TRACE(("new position = %d", *pPosition)); */ return TRUE; } } return FALSE; } /* Moves by one editable position forward or backward. Returns FALSE if it couldn't. * position can be denormalized on entry and may be denormalized on exit. */ Bool lo_BumpEditablePosition(MWContext *context, lo_DocState *state, LO_Element **pEptr, int32 *pPosition, Bool direction) { LO_Element* newEptr; int32 newPosition; if ( ! ( pEptr && *pEptr && pPosition ) ) { XP_ASSERT(FALSE); return FALSE; } newEptr = *pEptr; newPosition = *pPosition; if ( ! lo_QuickBumpEditablePosition(context, state, &newEptr, &newPosition, direction ) ) { /* Normalize, and try again. */ if ( ! lo_NormalizeSelectionPoint(context, state, &newEptr, &newPosition) ) return FALSE; if ( ! lo_QuickBumpEditablePosition(context, state, &newEptr, &newPosition, direction ) ) { /* Now that it's normalized, try the heavy-duty bump. */ if ( ! lo_BumpNormalizedEditablePosition(context, state, &newEptr, &newPosition, direction) ) { return FALSE; } } } *pEptr = newEptr; *pPosition = newPosition; return TRUE; } PRIVATE Bool lo_BumpEditablePositionForward(MWContext *context, lo_DocState *state, LO_Element **pEptr, int32 *pPosition) { return lo_BumpEditablePosition(context, state, pEptr, pPosition, TRUE); } PRIVATE Bool lo_BumpEditablePositionBackward(MWContext *context, lo_DocState *state, LO_Element **pEptr, int32 *pPosition) { return lo_BumpEditablePosition(context, state, pEptr, pPosition, FALSE); } PRIVATE void lo_ChangeSelection(MWContext *context, lo_DocState *state, LO_Element *changed_start, LO_Element *changed_end, int32 changed_start_pos, int32 changed_end_pos) { LO_Element *eptr; int32 position; LO_Element *start, *end; int32 start_pos, end_pos; intn compare_start; intn compare_end; /* * Handle case where there's no existing selection */ if ( state->selection_start == NULL ) { lo_HighlightSelect(context, state, changed_start, changed_start_pos, changed_end, changed_end_pos, TRUE); return; } start = state->selection_start; start_pos = state->selection_start_pos; end = state->selection_end; end_pos = state->selection_end_pos; lo_NormalizeSelectionEnd(context, state, &end, &end_pos); /* * If the end of the old selection is less than * the start of the new one. Or the end of the new one is * less than the start of the old one. * Erase the old one, draw the new one. */ if ((lo_compare_selections(end, end_pos, changed_start, changed_start_pos) < 0)|| (lo_compare_selections(changed_end, changed_end_pos, start, start_pos) < 0)) { lo_HighlightSelect(context, state, start, start_pos, end, end_pos, FALSE); lo_HighlightSelect(context, state, changed_start, changed_start_pos, changed_end, changed_end_pos, TRUE); } else { compare_start = lo_compare_selections(changed_start, changed_start_pos, start, start_pos); compare_end = lo_compare_selections(changed_end, changed_end_pos, end, end_pos); /* * If the start position has moved either draw more, * or erase some of the old. */ if (compare_start < 0) { lo_HighlightSelect(context, state, changed_start, changed_start_pos, start, start_pos, TRUE); } else if (compare_start > 0) { lo_bump_position(context, state, changed_start, changed_start_pos, &eptr, &position, FALSE); lo_HighlightSelect(context, state, start, start_pos, eptr, position, FALSE); } /* * If the end position has moved either draw more, * or erase some of the old. */ if (compare_end > 0) { lo_HighlightSelect(context, state, end, end_pos, changed_end, changed_end_pos, TRUE); } else if (compare_end < 0) { lo_bump_position(context, state, changed_end, changed_end_pos, &eptr, &position, TRUE); lo_HighlightSelect(context, state, eptr, position, end, end_pos, FALSE); } } } Bool LO_SelectElement( MWContext *context, LO_Element *eptr, int32 position, Bool bFromStart ) { int32 doc_id; lo_TopState *top_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 FALSE; } state = top_state->doc_state; /* If we've been handed a non-editable item, go to the previous editable item */ if ( ! lo_EnsureEditableSearchPrev2(context, state, &eptr, &position) ) { return FALSE; } if ( lo_IsEdgeOfDocument2(context, state, eptr, position, ! bFromStart ) ) { return FALSE; } /* If we're selecting backwards, actually select one lower */ if ( bFromStart ) { if ( ! lo_BumpEditablePositionBackward(context, state, &eptr, &position) ) return FALSE; } /* End is the same as the beginning. */ lo_FullSetSelection(context, state, eptr, position, eptr, position, bFromStart); return TRUE; } /* Internal routine that should not be exported */ void LO_ExtendSelectionFromElement( MWContext *context, LO_Element *eptr, int32 position, Bool bFromStart ) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element *changed_start, *changed_end; int32 changed_start_pos, changed_end_pos; /* * 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; } state = top_state->doc_state; /* * If we have started a new selection, replace the old one with * this new one before extending */ if (state->selection_new != NULL) { lo_StartNewSelection(context, state, eptr, position); return; } /* * If we somehow got here without having any selection or started * selection, start it now where we are. */ if (state->selection_start == NULL) { state->selection_start = eptr; state->selection_start_pos = position; state->selection_end = state->selection_start; state->selection_end_pos = state->selection_start_pos; state->extending_start = FALSE; } /* * By some horrendous bug the start was set and the end was not, * and there was no newly started selection. Correct this now. */ if (state->selection_end == NULL) { state->selection_end = state->selection_start; state->selection_end_pos = state->selection_start_pos; state->extending_start = FALSE; } /* * Extend the same side we extended last time. */ if (state->extending_start != FALSE) { changed_start = eptr; changed_start_pos = position; changed_end = state->selection_end; changed_end_pos = state->selection_end_pos; } else { changed_start = state->selection_start; changed_start_pos = state->selection_start_pos; changed_end = eptr; changed_end_pos = position; } /* * If we crossed our start and end positions, switch * them, and switch which end we are extending from. */ if (changed_start->lo_any.ele_id > changed_end->lo_any.ele_id) { eptr = changed_start; position = changed_start_pos; changed_start = changed_end; changed_start_pos = changed_end_pos; changed_end = eptr; changed_end_pos = position; if (state->extending_start != FALSE) { state->extending_start = FALSE; } else { state->extending_start = TRUE; } } else if ((changed_start->lo_any.ele_id == changed_end->lo_any.ele_id)&& (changed_start_pos > changed_end_pos)) { position = changed_start_pos; changed_start_pos = changed_end_pos; changed_end_pos = position; if (state->extending_start != FALSE) { state->extending_start = FALSE; } else { state->extending_start = TRUE; } } lo_ChangeSelection(context, state, changed_start, changed_end, changed_start_pos, changed_end_pos); lo_SetSelect(context, state, changed_start, changed_start_pos, changed_end, changed_end_pos, TRUE); state->selection_start = changed_start; state->selection_start_pos = changed_start_pos; state->selection_end = changed_end; state->selection_end_pos = changed_end_pos; /* * Cannot have a new selection after an extend. */ state->selection_new = NULL; state->selection_new_pos = 0; #if 0 /* * If the beginning and the endpoints were not the beginning and end points * then the editors notion of bFromStart is backwards. */ if( state->extending_start ){ state->extending_start = !bFromStart; } else { state->extending_start = bFromStart; } #endif } void LO_SelectRegion( MWContext *context, LO_Element *begin, int32 beginPosition, LO_Element* end, int32 endPosition, Bool fromStart , Bool forward) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; if ( ! begin || !end ) { XP_ASSERT(FALSE); return; } #if 0 lo_NormalizeSelectionPoint(context, state, &begin, &beginPosition); lo_NormalizeSelectionPoint(context, state, &end, &endPosition); #endif #if 0 XP_TRACE(("begin %d %d %d end %d %d %d start %d forward %d", begin->type, begin->lo_any.ele_id, beginPosition, end->type, end->lo_any.ele_id, endPosition, fromStart, forward)); #endif /* Normalize end-points for end-of line conditions */ if ( fromStart ) { if ( !forward && begin->type == LO_LINEFEED && beginPosition == 0 ) { lo_BumpEditablePositionBackward(context, state, &begin, &beginPosition); } } else { LO_Element* prev; if ( forward && endPosition == 0 && ( end->type == LO_LINEFEED || ((prev = lo_BoundaryJumpingPrev(context, state, end)) != NULL && prev->type == LO_LINEFEED ) ) ) { lo_BumpEditablePositionForward(context, state, &end, &endPosition); } } LO_StartSelectionFromElement( context, begin, beginPosition, NULL ); LO_ExtendSelectionFromElement( context, end, endPosition, fromStart ); state->extending_start = fromStart; } void lo_SetSelection(MWContext *context, LO_Selection* selection, Bool extendingStart) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; lo_FullSetSelection( context, state, selection->begin.element, selection->begin.position, selection->end.element, selection->end.position, extendingStart); } void lo_FullSetSelection(MWContext *context, lo_DocState * state, LO_Element* start, int32 start_pos, LO_Element* end, int32 end_pos, Bool extendFromStart) { LO_Element* normalizedStart = start; int32 normalizedStartPosition = start_pos; LO_Element* normalizedEnd = end; int32 normalizedEndPosition = end_pos; LO_ASSERT_POSITION2(context, start, start_pos); LO_ASSERT_POSITION2(context, end, end_pos); /* The non-editor portions of layout can't deal with a * de-normalized positions. So we normalize it here. */ /* LO_DUMP_SELECTION2("FullSetSelection", start, start_pos, end, end_pos); */ #if 0 lo_NormalizeSelectionPoint(context, state, &normalizedStart, &normalizedStartPosition); #endif if ( lo_GetElementLength(normalizedStart) <= normalizedStartPosition ) { normalizedStart = lo_BoundaryJumpingNext(context, state, normalizedStart); normalizedStartPosition = 0; } lo_NormalizeSelectionEnd(context, state, &normalizedEnd, &normalizedEndPosition); /* If we've been handed a bad selection, just return. */ if ( ! ( normalizedStart && normalizedEnd && lo_compare_selections(normalizedStart, normalizedStartPosition, normalizedEnd, normalizedEndPosition) <= 0 ) ) { XP_TRACE(("lo_FullSetSelection: bad selection.")); #ifdef DEBUG_EDIT_LAYOUT XP_ASSERT(FALSE); #endif return; } lo_ChangeSelection(context, state, normalizedStart, normalizedEnd, normalizedStartPosition, normalizedEndPosition); lo_SetSelect(context, state, normalizedStart, normalizedStartPosition, normalizedEnd, normalizedEndPosition, TRUE); state->selection_start = start; state->selection_start_pos = start_pos; state->selection_end = end; state->selection_end_pos = end_pos; state->extending_start = extendFromStart; /* * Cannot have a new selection after an extend. */ state->selection_new = NULL; state->selection_new_pos = 0; } /* Get the selection edges, expressed as insert points. */ PRIVATE void lo_GetSelectionEdge(MWContext *context, lo_DocState * state, LO_Element** pElement, int32* pPosition, Bool bForward) { if(state->selection_start && state->selection_end ) { if ( !bForward ) { *pElement = state->selection_start; *pPosition = state->selection_start_pos; } else { *pElement = state->selection_end; *pPosition = state->selection_end_pos; lo_ConvertSelectionEndToInsertPoint(context, state, pElement, pPosition); } } else { /* Use insert point */ *pElement = state->selection_new; *pPosition = state->selection_new_pos; } } void lo_GetAnchorPoint(MWContext *context, lo_DocState * state, LO_Element** pElement, int32* pPosition) { lo_GetSelectionEdge(context, state, pElement, pPosition, state->extending_start); } void lo_GetExtensionPoint(MWContext *context, lo_DocState * state, LO_Element** pElement, int32* pPosition) { lo_GetSelectionEdge(context, state, pElement, pPosition, !state->extending_start); } Bool lo_IsEndOfParagraph2(MWContext *context, LO_Element* element, int32 position) { if ( ! element ) { XP_ASSERT( FALSE ); return FALSE; } /* The browser doesn't set break_type, so every line is a paragraph to it. */ if ( element->type == LO_LINEFEED && ( ! EDT_IS_EDITOR(context) || element->lo_linefeed.break_type == LO_LINEFEED_BREAK_PARAGRAPH)) { return TRUE; } return FALSE; } PRIVATE Bool lo_IsEndOfParagraph(MWContext *context, LO_Position* position) { XP_ASSERT( position ); return lo_IsEndOfParagraph2(context, position->element, position->position); } PRIVATE Bool lo_IsHardBreak2(MWContext *context, LO_Element* element, int32 position) { if ( ! element ) { XP_ASSERT( FALSE ); return FALSE; } /* The browser doesn't set break_type, so every line is a hard break to it. */ if ( element->type == LO_LINEFEED && ( ! EDT_IS_EDITOR(context) || element->lo_linefeed.break_type != LO_LINEFEED_BREAK_SOFT)) { return TRUE; } return FALSE; } PRIVATE Bool lo_ExtendToIncludeHardBreak(MWContext* context, lo_DocState *state, LO_Selection* selection) { /* If this is a selection that ends in a hard break, extend the * selection to include the hard break. */ Bool result = FALSE; if ( EDT_IS_EDITOR(context) ) { LO_Position* end = &selection->end; if ( lo_IsHardBreak2(context, end->element,0) ) { result = TRUE; /* Already at a break character. */ } else { if ( end->position >= lo_GetLastCharEndPosition(end->element) ) { LO_Element* eol = lo_BoundaryJumpingNext(context, state, end->element); if ( lo_IsHardBreak2(context, eol,0) ) { /* Extend to include the paragraph end element */ end->element = eol; end->position = 0; result = TRUE; } } } } return result; } #ifdef DEBUG void lo_ValidatePosition(MWContext *context, LO_Position* position) { XP_ASSERT( position ); if ( position ) { lo_ValidatePosition2(context, position->element, position->position); } } void lo_ValidatePosition2(MWContext *context, LO_Element* element, int32 position) { int32 length; XP_ASSERT( element ); XP_ASSERT( context ); if ( context && element ) { length = lo_GetElementLength(element); XP_ASSERT( 0 <= position ); XP_ASSERT( position <= length ); if ( EDT_IS_EDITOR(context) ) { /* Either it's a line-feed with an eop, or it has an edit_element. */ if ( ! element->lo_any.edit_element ) { if (element->type == LO_LINEFEED) { if ( ! lo_IsEndOfParagraph2(context, element, position) ) { XP_TRACE(("lo_ValidatePosition2: illegal position: a line feed without an end-of-paragraph marker.")); #ifdef DEBUG_EDIT_LAYOUT XP_ASSERT(FALSE); #endif } } else { #ifdef DEBUG_EDIT_LAYOUT XP_ASSERT(FALSE); #endif } } } } } void lo_ValidateSelection(MWContext *context, LO_Selection* selection) { XP_ASSERT( selection ); lo_ValidateSelection2( context, selection->begin.element, selection->begin.position, selection->end.element, selection->end.position ); } void lo_ValidateSelection2(MWContext *context, LO_Element* beginElement, int32 beginPosition, LO_Element* endElement, int32 endPosition) { lo_ValidatePosition2( context, beginElement, beginPosition ); lo_ValidatePosition2( context, endElement, endPosition ); XP_ASSERT( lo_compare_selections(beginElement, beginPosition, endElement, endPosition) <= 0 ); } #endif /* * An insert point is one edit position greater than a selection end. But there are * two insert points for the edit position that falls between elements. One * insert point is for the end of the previous element. The other is for the * beginning of the next element. There are two corresponding selection ends. * * end of previous element: * insertion point: element = , position = * selection end: element = , position = - 1 * * start of next element: * insertion point: element = , position = 0 * selection end: element = , position = */ PRIVATE Bool lo_IsAtStartOfLine(MWContext* context, lo_DocState* state, LO_Element* element, int32 position) { LO_Element* prev; if ( position != 0 || ! element ) return FALSE; prev = element->lo_any.prev; if ( ! prev ) return TRUE; if ( prev->type == LO_LINEFEED || prev->type == LO_BULLET ) return TRUE; /* Numbered list test. */ if ( EDT_IS_EDITOR(context) && prev->type == LO_TEXT && prev->lo_text.edit_element == 0 ) return TRUE; return FALSE; } Bool lo_ConvertInsertPointToSelectionEnd(MWContext* context, lo_DocState * state, LO_Element** pElement, int32* pPosition) { LO_Element* eptr = *pElement; int32 position = *pPosition; /* Special case for insert points at beginning of lines. */ if ( lo_IsAtStartOfLine(context, state, eptr, position) ) { /* Skip backwards to line feed that has end-of-paragraph set */ while ( eptr && lo_BoundaryJumpingPrev(context, state, eptr) ) { lo_bump_position(context, state, eptr, position, &eptr, &position, FALSE); if ( ! eptr ) { break; } if ( eptr->type == LO_LINEFEED ) { if ( eptr->lo_linefeed.break_type != LO_LINEFEED_BREAK_SOFT ) { break; } } /* Linefeeds are editable, but the if test above filters them out. */ else if (lo_EditableElement(eptr->type) ) { break; } } position = lo_GetLastCharBeginPosition(eptr); } else if ( lo_BumpEditablePositionBackward(context, state, &eptr, &position) ) { if ( *pPosition == 0 ) { /* This is the "Start of next element" case. */ lo_BumpEditablePositionForward(context, state, &eptr, &position); } } else { /* If we can't go backwards, it means that the insert point was at the beginning of the document. * This is an error condition, because there is no legal selection end that corresponds * to this insert point. */ return FALSE; } /* It turns out that the end is the address of the last byte selected, not just the position of the * first byte of the two-byte character. So we have to bump forward and subtract one. * * (If we're a denormalized selection end, we don't increment our position. * that's what the "if" is for.) */ if ( position < lo_GetElementLength(eptr) ) { position = lo_IncrementPosition(eptr, position) - 1; } *pElement = eptr; *pPosition = position; return TRUE; } Bool lo_ConvertSelectionEndToInsertPoint(MWContext* context, lo_DocState * state, LO_Element** pElement, int32* pPosition) { LO_Element* eptr = *pElement; int32 position = *pPosition; int32 length = lo_GetElementLength(*pElement); LO_ASSERT_POSITION2( context, eptr, position ); /* It turns out that the end is the address of the last byte selected, not just the position of the * first byte of the two-byte character. So we have to add one and bump backward. */ if ( position >= length ) { /* this is the end-of-previous-element case. */ XP_ASSERT( position == length ); position = lo_GetLastCharBeginPosition(*pElement); /* If we can't go forward, it means that the selection end was beyond the end of the document. * This is an error condition. */ if ( ! lo_BumpEditablePositionForward(context, state, &eptr, &position) ) { return FALSE; } } else { position = lo_DecrementPosition(eptr, position + 1); /* This maps 0..length-1 into 1..length, which is OK. */ position = lo_IncrementPosition(eptr, position); } *pElement = eptr; *pPosition = position; LO_ASSERT_POSITION2( context, eptr, position ); return TRUE; } Bool lo_NormalizeSelectionPoint(MWContext *context, lo_DocState * state, LO_Element** pEptr, int32* pPosition) { /* * If the insert point is off the end of the element, make it the 0th selection of the next element. * If we can't normalize it, leave it alone. */ Bool result = TRUE; if ( *pEptr != NULL ) { int32 length = lo_GetElementLength(*pEptr); int32 newPosition = *pPosition; XP_ASSERT( 0 <= newPosition && newPosition <= length ); if ( newPosition >= length ) { if ( length <= 0 ) { /* There are some zero-length text elements in the browser, when * tables are around. Also, the editor uses zero-length text * elements for empty paragraphs and empty lines. */ newPosition = 0; } else { /* Needs to be internationalized */ newPosition = lo_GetLastCharBeginPosition(*pEptr); result = lo_BumpNormalizedEditablePosition(context, state, pEptr, &newPosition, TRUE); } if ( result ) { *pPosition = newPosition; } } } return result; } void lo_NormalizeSelectionEnd(MWContext *context, lo_DocState * state, LO_Element** pEptr, int32* pPosition) { /* * If the selection end point is off the end of the element, make it the last position of the element. */ if ( *pEptr != NULL ) { int32 length = lo_GetElementLength(*pEptr); XP_ASSERT( 0 <= *pPosition && *pPosition <= length ); if ( *pPosition >= length ) { *pPosition = lo_GetLastCharEndPosition(*pEptr); } } } PRIVATE intn lo_FancyHalfCompareSelections(LO_Element* start, int32 startPosition, LO_Element* end, int32 endPosition) { int32 startID = start->lo_any.ele_id; int32 endID = end->lo_any.ele_id; if ( startID < endID ) { if ( startID < (endID - 1) ) return -1; /* Has to be less */ if ( startPosition < lo_GetElementLength(start) ) return -1; if ( endPosition > 0 ) return -1; return 0; } XP_ASSERT(FALSE); return -1; } PRIVATE intn lo_FancyCompareSelections(MWContext *context, lo_DocState * state, LO_Element* start, int32 startPosition, LO_Element* end, int32 endPosition) { #if 0 /* We can't normalize past the end of the document. */ Bool startIsEOD = ! lo_NormalizeSelectionPoint(context, state, &start, &startPosition); Bool endIsEOD = ! lo_NormalizeSelectionPoint(context, state, &end, &endPosition); if ( startIsEOD && endIsEOD ) return 0; else if ( startIsEOD ) return 1; else if ( endIsEOD ) return -1; return lo_compare_selections(start, startPosition, end, endPosition); #endif int32 startID = 0; int32 endID = 0; /* Can not perform if no start or end element */ if(!start || !end) { return 0; } /* Now safe to set IDs */ startID = start->lo_any.ele_id; endID = end->lo_any.ele_id; if ( startID < endID ) { return lo_FancyHalfCompareSelections(start, startPosition, end, endPosition); } else if ( startID == endID ) { if ( startPosition < endPosition ) return -1; else if ( startPosition == endPosition ) return 0; return 1; } else /* startID > endID */ { return - lo_FancyHalfCompareSelections(end, endPosition, start, startPosition); } } void lo_StartNewSelection(MWContext *context, lo_DocState * state, LO_Element* eptr, int32 position) { /* * If the user hasn't moved the insertion point yet, start a selection. */ LO_Element* i_eptr = state->selection_new; int32 i_position = state->selection_new_pos; intn compare = lo_FancyCompareSelections(context, state, i_eptr, i_position, eptr, position); if ( compare < 0 ) { /* old < now, so they're dragging towards the end of the document */ lo_ConvertInsertPointToSelectionEnd(context, state, &eptr, &position); state->extending_start = FALSE; lo_FullSetSelection(context, state, i_eptr, i_position, eptr, position, FALSE); } else if ( compare == 0 ) { /* The user hasn't moved the mouse far enough to select anything. */ return; } else { /* Dragging towards start of document */ lo_ConvertInsertPointToSelectionEnd(context, state, &i_eptr, &i_position); state->extending_start = TRUE; lo_FullSetSelection(context, state, eptr, position, i_eptr, i_position, TRUE); } } void LO_ExtendSelection(MWContext *context, int32 x, int32 y) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element *eptr; int32 position; LO_HitResult result; /* * 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; } state = top_state->doc_state; LO_Hit(context, x, y, FALSE, &result, state->selection_layer); position = 0; eptr = NULL; switch ( result.type ) { case LO_HIT_LINE: { switch ( result.lo_hitLine.region ) { case LO_HIT_LINE_REGION_BEFORE: { /* Insertion point before first element of line */ eptr = result.lo_hitLine.selection.begin.element; position = result.lo_hitLine.selection.begin.position; } break; case LO_HIT_LINE_REGION_AFTER: { /* Insertion point after last element of line */ eptr = result.lo_hitLine.selection.end.element; position = result.lo_hitLine.selection.end.position; lo_ConvertSelectionEndToInsertPoint(context, state, &eptr, &position); if ( eptr->type == LO_LINEFEED ) position = 0; /* For editable line-feeds */ } break; default: break; } } break; case LO_HIT_ELEMENT: { eptr = result.lo_hitElement.position.element; position = result.lo_hitElement.position.position; switch ( result.lo_hitElement.region ) { case LO_HIT_ELEMENT_REGION_BEFORE: break; case LO_HIT_ELEMENT_REGION_MIDDLE: { /* The user wants this item selected. * * If the anchor point is before or at this item, the insert point should be * after this item. * */ LO_Element* anchorElement; int32 anchorPosition; lo_GetAnchorPoint(context, state, &anchorElement, &anchorPosition); if ( lo_FancyCompareSelections(context, state, anchorElement, anchorPosition, eptr, position) <= 0 ) { lo_BumpEditablePositionForward(context, state, &eptr, &position); } } break; case LO_HIT_ELEMENT_REGION_AFTER: { lo_BumpEditablePositionForward(context, state, &eptr, &position); } break; default: break; } } break; default: break; } if (eptr == NULL) { return; } lo_ExtendSelectionToPosition2(context, top_state, state, eptr, position); } void lo_ExtendSelectionToPosition2(MWContext *context, lo_TopState* top_state, lo_DocState *state, LO_Element* eptr, int32 position) { /* * Are we starting a new selection? */ if (state->selection_new != NULL) { lo_StartNewSelection(context, state, eptr, position); return; } /* * If we somehow got here without having any selection or started * selection, start it now where we are. */ if (state->selection_start == NULL) { state->selection_start = eptr; state->selection_start_pos = position; state->selection_end = state->selection_start; state->selection_end_pos = state->selection_start_pos; state->extending_start = FALSE; } /* * By some horrendous bug the start was set and the end was not, * and there was no newly started selection. Correct this now. */ if (state->selection_end == NULL) { state->selection_end = state->selection_start; state->selection_end_pos = state->selection_start_pos; state->extending_start = FALSE; } { LO_Element* anchorElement; int32 anchorPosition; intn compare; lo_GetAnchorPoint(context, state, &anchorElement, &anchorPosition); compare = lo_FancyCompareSelections(context, state, eptr, position, anchorElement, anchorPosition ); if ( compare == 0 ) { /* The anchor point might not be editable -- it might be the start of a line feed. * So Jiggle it. */ lo_JiggleToMakeEditable(context, state, &anchorElement, &anchorPosition, FALSE); lo_SetInsertPoint(context, top_state, anchorElement, anchorPosition, state->selection_layer); } else { LO_Element *changed_start, *changed_end; int32 changed_start_pos, changed_end_pos; Bool extendingStart; if ( compare < 0 ) { /* new position is less than anchor. So it's the start */ changed_start = eptr; changed_start_pos = position; changed_end = anchorElement; changed_end_pos = anchorPosition; extendingStart = TRUE; } else { /* new position is greater than anchor. So it's the end */ changed_start = anchorElement; changed_start_pos = anchorPosition; changed_end = eptr; changed_end_pos = position; extendingStart = FALSE; } lo_ConvertInsertPointToSelectionEnd(context, state, &changed_end, &changed_end_pos); lo_FullSetSelection(context, state, changed_start, changed_start_pos, changed_end, changed_end_pos, extendingStart); } } } void LO_EndSelection(MWContext *context) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; } #ifdef NOT_USED static void lo_copy_color(LO_Color *from_color, LO_Color *to_color) { to_color->red = from_color->red; to_color->green = from_color->green; to_color->blue = from_color->blue; } #endif /* NOT_USED */ /* * If this element is part of a cell, return that cell. */ LO_Element * lo_JumpCellWall(MWContext *context, lo_DocState *state, LO_Element *eptr) { LO_Element *parent; LO_Element *cell = NULL; LO_Element *prev_eptr; LO_Element *stop_eptr; int32 x, y; int32 ret_x, ret_y; Bool guess_mode; CL_Layer *layer; /* * We only turn this on if we are desparate and think * we are in a cell with NO selectable elements! */ guess_mode = FALSE; prev_eptr = NULL; x = eptr->lo_any.x + eptr->lo_any.x_offset; y = eptr->lo_any.y + eptr->lo_any.y_offset; /* * If this element is a zero width linefeed, it is unselectable, so * we need to special case this to work off the previous element * in the cell (if any). */ if (eptr->lo_any.width <= 0) { prev_eptr = eptr->lo_any.prev; /* * Gads, you have have zero width text followed by a * zero width linefeed. Move back until we get a real * width or can't go any furthur. */ while ((prev_eptr != NULL)&&(prev_eptr->lo_any.width <= 0)) { prev_eptr = prev_eptr->lo_any.prev; } if (prev_eptr != NULL) { x = prev_eptr->lo_any.x + prev_eptr->lo_any.x_offset; y = prev_eptr->lo_any.y + prev_eptr->lo_any.y_offset; } /* * If there is no previous element to the zero-width * one, guess in desperation by moving back one. * Probably there are no other elements in this * cell, go into guess_mode. */ else { guess_mode = TRUE; /* * We used to subtract 1 from the x pixel position, but * that didn't work in all cases and had the potential to * cause infinite loops. Now we don't and I feel a lot * happier. */ } } /* * figure out when to stop traversing inward. * If we have a prev_eptr then that is where we stop, * otherwise stop if we hit the starting element. */ if (prev_eptr != NULL) { stop_eptr = prev_eptr; } else { stop_eptr = eptr; } parent = NULL; /* This deals with the case where the table is in a layer. * We want to search within the corresponding block and * not in the base document for the enclosing cell. * BUGBUG This makes the assumption that if this table is * in a layer, that layer is part of the current selection * state. I don't know if this assumption is always true * for all invocations of this function. * joki: changing function to work based on layer key focus * instead of selected layer so that form elements will be * tabable in tables. 5/25/97. */ if (context->compositor && !(CL_IsKeyEventGrabber(context->compositor, NULL))) { layer = CL_GetKeyEventGrabber(context->compositor); if (layer && LO_GetIdFromLayer(context, layer) != LO_DOCUMENT_LAYER_ID) { LO_CellStruct *layer_cell = lo_GetCellFromLayer(context, layer); if (layer_cell) cell = lo_XYToCellElement(context, state, layer_cell, x, y, TRUE, FALSE, FALSE); } } if (cell == NULL) cell = lo_XYToDocumentElement(context, state, x, y, TRUE, FALSE, FALSE, &ret_x, &ret_y); while ((cell != NULL)&&(cell != stop_eptr)&&(cell->type == LO_CELL)) { parent = cell; cell = lo_XYToCellElement(context, state, (LO_CellStruct *)cell, x, y, TRUE, FALSE, FALSE); } /* * If we've traversed to our stopping point. */ if (cell == stop_eptr) { /* * If the stopping point has a cell parent, return it. */ if ((parent != NULL)&&(parent->type == LO_CELL)) { return(parent); } /* * Else we aren't in a cell, return the original element. */ else { return(eptr); } } /* * Else if we are in guess mode, we found a valid parent * cell that appears to have no children, then we need to check * if the first child of the parent is our stop_eptr, and if * so, return the cell parent. */ else if ((guess_mode != FALSE)&&(cell == NULL)&&(parent != NULL)&& (parent->type == LO_CELL)) { if (parent->lo_cell.cell_list == stop_eptr) { return(parent); } /* * If we get here we don't know what we found, so just * return. */ return(eptr); } /* If we found a parent that's a cell, then return it. * I think this case happens when we hit an element * that has the same coordinates are the element we * were given. An example would be a zero-length * text element before a linefeed. Maybe we should * change the search algorithm to skip zero-lenght elements? * */ else if ( (parent != NULL) && (parent->type == LO_CELL)) { return parent; } /* * Else, we've missed the stopping point for some reason. * Assume we aren't in a cell. */ else { return(eptr); } } void lo_SetSelect(MWContext *context, lo_DocState *state, LO_Element *start, int32 start_pos, LO_Element *end, int32 end_pos, Bool on) { LO_Element *eptr; if ((start == NULL)||(end == NULL)) { return; } eptr = start; while ((eptr != NULL)&&(eptr->lo_any.ele_id <= end->lo_any.ele_id)) { int32 last_id; switch (eptr->type) { case LO_TEXT: if (eptr->lo_text.text != NULL) { int32 p1, p2; if (eptr == start) { p1 = start_pos; } else { p1 = 0; } if (eptr == end) { p2 = end_pos; } else { p2 = lo_GetLastCharEndPosition(eptr); } if (p2 < p1) { p2 = p1; } if (on != FALSE) { eptr->lo_text.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_text.sel_start = (intn) p1; eptr->lo_text.sel_end = (intn) p2; } else { eptr->lo_text.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_text.sel_start = -1; eptr->lo_text.sel_end = -1; } } break; case LO_LINEFEED: if (on != FALSE) { eptr->lo_linefeed.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_linefeed.sel_start = 0; eptr->lo_linefeed.sel_end = 0; } else { eptr->lo_linefeed.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_linefeed.sel_start = -1; eptr->lo_linefeed.sel_end = -1; } break; case LO_IMAGE: #ifdef EDITOR if ( EDT_IS_EDITOR(context) ) { if (on != FALSE) { eptr->lo_image.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_image.sel_start = 0; eptr->lo_image.sel_end = 0; } else { eptr->lo_image.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_image.sel_start = -1; eptr->lo_image.sel_end = -1; } } break; #endif /* EDITOR */ case LO_HRULE: #ifdef EDITOR if ( EDT_IS_EDITOR(context) ) { if (on != FALSE) { eptr->lo_hrule.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_hrule.sel_start = 0; eptr->lo_hrule.sel_end = 0; } else { eptr->lo_hrule.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_hrule.sel_start = -1; eptr->lo_hrule.sel_end = -1; } } break; #endif /* EDITOR */ case LO_FORM_ELE: #ifdef EDITOR if ( EDT_IS_EDITOR(context) ) { if (on != FALSE) { eptr->lo_form.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_form.sel_start = 0; eptr->lo_form.sel_end = 0; } else { eptr->lo_form.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_form.sel_start = -1; eptr->lo_form.sel_end = -1; } } break; #endif /* EDITOR */ case LO_BULLET: case LO_SUBDOC: case LO_TABLE: default: break; } last_id = eptr->lo_any.ele_id; /* * Jump cell boundries if there is one between start * and end. */ if ((eptr->lo_any.next == NULL)&&(eptr != end)) { eptr = lo_JumpCellWall(context, state, eptr); } eptr = eptr->lo_any.next; /* * When we walk onto a cell, we need to walk into * it if it isn't empty. */ if ((eptr != NULL)&&(eptr->type == LO_CELL)&& (eptr->lo_cell.cell_list != NULL)) { eptr = eptr->lo_cell.cell_list; } /* * We don't want infinite loops. * If the element ID hasn't progressed, something * serious is wrong, and we should punt. */ if ((eptr != NULL)&&(eptr->lo_any.ele_id <= last_id)) { #ifdef DEBUG XP_TRACE(("Selection loop avoidance 1\n")); #endif /* DEBUG */ break; } } } typedef enum { HL_STARTED, HL_NOT_STARTED, HL_COMPLETED } LO_HighlightState; /* Highlight a range of elements from within a list of layout elements. Return values: HL_STARTED At least one element highlighted from list, but last element in range was not encountered on list. HL_NOT_STARTED Specified range did not contain any of the range of elements specified in the arguments. HL_COMPLETED Specified range of elements has been highlighted. */ static LO_HighlightState lo_HighlightElementList(MWContext *context, int32 base_x, int32 base_y, LO_Element *list, LO_Element *start, int32 start_pos, LO_Element *end, int32 end_pos, CL_Layer *layer, Bool on) { LO_Element *eptr; int16 charset; int32 p1, p2; LO_HighlightState highlight_state; if (list == NULL) return HL_COMPLETED; /* Locate first element to be highlighted in list */ eptr = list; while (eptr && eptr != start) { if (eptr->type == LO_CELL) { int32 x_offset = 0; int32 y_offset = 0; CL_Layer *cell_layer = layer; /* LO_CELLs can be either ordinary table cells or containers for in-flow layers */ if (eptr->lo_cell.cell_inflow_layer) { cell_layer = eptr->lo_cell.cell_inflow_layer; lo_GetLayerXYShift(cell_layer, &x_offset, &y_offset); } if (eptr->lo_cell.cell_list) { highlight_state=lo_HighlightElementList(context, base_x - x_offset, base_y - y_offset, eptr->lo_cell.cell_list, start, start_pos, end, end_pos, cell_layer, on); if (highlight_state == HL_COMPLETED) return HL_COMPLETED; if (highlight_state == HL_STARTED) { eptr = eptr->lo_any.next; break; } } } eptr = eptr->lo_any.next; } if (!eptr) return HL_NOT_STARTED; /* Paint highlighted elements */ while ((eptr != NULL) && (eptr->lo_any.ele_id <= end->lo_any.ele_id)) { int32 last_id; switch (eptr->type) { case LO_TEXT: if (eptr->lo_text.text == NULL) break; if (eptr == start) p1 = start_pos; else p1 = 0; if (eptr == end) p2 = end_pos; else p2 = lo_GetLastCharEndPosition(eptr); if (p2 < p1) p2 = p1; if ( p2 >= eptr->lo_text.text_len ) p2 = lo_GetLastCharEndPosition(eptr); if (on != FALSE) { eptr->lo_text.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_text.sel_start = (intn) p1; eptr->lo_text.sel_end = (intn) p2; } else { eptr->lo_text.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_text.sel_start = -1; eptr->lo_text.sel_end = -1; } charset = ((LO_TextStruct *) eptr)->text_attr->charset; if ((eptr == start) || ((eptr == end) && INTL_CharSetType(charset) != SINGLEBYTE)) { /* ugly processing for multibyte here */ char *string; int n; PA_LOCK(string, char *, eptr->lo_text.text); /* * find beginning of first character */ switch (n = INTL_NthByteOfChar(charset, string, (int)(p1+1))) { case 0: case 1: break; default: p1 -= (n - 1); if (p1 < 0) p1 = 0; break; } /* * 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 > lo_GetLastCharEndPosition(eptr)) { p2 = lo_GetLastCharEndPosition(eptr); } break; } PA_UNLOCK(eptr->lo_text.text); } if (p1 <= p2) { lo_DisplaySubtext(context, (LO_TextStruct *)eptr, p1, p2, !on, layer); } break; case LO_LINEFEED: if (on != FALSE) { eptr->lo_linefeed.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_linefeed.sel_start = 0; eptr->lo_linefeed.sel_end = 0; } else { eptr->lo_linefeed.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_linefeed.sel_start = -1; eptr->lo_linefeed.sel_end = -1; } lo_RefreshElement(eptr, layer, FALSE); break; case LO_HRULE: #ifdef EDITOR if ( EDT_IS_EDITOR(context) ) { if (on != FALSE) { eptr->lo_hrule.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_hrule.sel_start = 0; eptr->lo_hrule.sel_end = 0; } else { eptr->lo_hrule.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_hrule.sel_start = -1; eptr->lo_hrule.sel_end = -1; } lo_RefreshElement(eptr, layer, FALSE); } break; #endif case LO_FORM_ELE: #ifdef EDITOR if ( EDT_IS_EDITOR(context) ) { if (on != FALSE) { eptr->lo_form.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_form.sel_start = 0; eptr->lo_form.sel_end = 0; } else { eptr->lo_form.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_form.sel_start = -1; eptr->lo_form.sel_end = -1; } lo_DisplayFormElement(context, (LO_FormElementStruct *)eptr); } break; #endif case LO_IMAGE: #ifdef EDITOR if ( EDT_IS_EDITOR(context) ) { if (on != FALSE) { eptr->lo_image.ele_attrmask |= LO_ELE_SELECTED; eptr->lo_image.sel_start = 0; eptr->lo_image.sel_end = 0; } else { eptr->lo_image.ele_attrmask &= (~(LO_ELE_SELECTED)); eptr->lo_image.sel_start = -1; eptr->lo_image.sel_end = -1; } { LO_ImageStruct *lo_image = (LO_ImageStruct*)eptr; XP_Rect rect; rect.left = 0; rect.top = 0; rect.right = lo_image->width; rect.bottom = lo_image->height; CL_UpdateLayerRect(context->compositor, lo_image->layer, &rect, (PRBool)FALSE); } } #endif break; case LO_CELL: { LO_CellStruct *cell = &eptr->lo_cell; int32 x_offset = 0; int32 y_offset = 0; CL_Layer *cell_layer = layer; /* LO_CELLs can be either ordinary table cells or containers for in-flow layers */ if (cell->cell_inflow_layer) { cell_layer = cell->cell_inflow_layer; lo_GetLayerXYShift(cell_layer, &x_offset, &y_offset); } if (!eptr->lo_cell.cell_list) break; highlight_state = lo_HighlightElementList(context, base_x - x_offset, base_y - y_offset, eptr->lo_cell.cell_list, eptr->lo_cell.cell_list, 0, end, end_pos, cell_layer, on); if (highlight_state == HL_COMPLETED) { return HL_COMPLETED; } break; } case LO_SUBDOC: case LO_TABLE: case LO_BULLET: default: break; } last_id = eptr->lo_any.ele_id; eptr = eptr->lo_any.next; /* * We don't want infinite loops. * If the element ID hasn't progressed, something * serious is wrong, and we should punt. */ if ((eptr != NULL)&&(eptr->lo_any.ele_id <= last_id)) { #ifdef DEBUG XP_TRACE(("Selection loop avoidance 2\n")); #endif /* DEBUG */ break; } } /* We ran off the list without reaching the last element in the selection range, so tell our caller that there's more work to do. */ if (!eptr) return HL_STARTED; /* We reached the last element in the selection range. We're done. */ return HL_COMPLETED; } void lo_HighlightSelect(MWContext *context, lo_DocState *state, LO_Element *start, int32 start_pos, LO_Element *end, int32 end_pos, Bool on) { LO_Element **line_array, *list; LO_CellStruct *layer_cell; if ((start == NULL) || (end == NULL)) return; /* * Do a synchronous composite to flush any other drawing * request. Since we're going to replace the painter_func * of state->selection_layer, we don't want to ignore other * requests that might require this layer to draw. This call * must happen before the text element is modified in any way. */ if (context->compositor) CL_CompositeNow(context->compositor); /* The stinkin' editor doesn't set the selection layer yet. */ if (!state->selection_layer) state->selection_layer = CL_FindLayer(context->compositor, LO_BODY_LAYER_NAME); layer_cell = lo_GetCellFromLayer(context, state->selection_layer); if (layer_cell == NULL) { XP_LOCK_BLOCK(line_array, LO_Element**, state->line_array ); if (line_array) list = line_array[0]; else list = NULL; XP_UNLOCK_BLOCK( state->line_array ); } else list = layer_cell->cell_list; lo_HighlightElementList(context, state->base_x, state->base_y, list, start, start_pos, end, end_pos, state->selection_layer, on); /* On the Mac, we don't run timeouts during a selection, so the compositor won't run. Therefore we need to force any new selection to paint now. */ if (context->compositor) CL_CompositeNow(context->compositor); } void LO_HighlightSelection(MWContext *context, Bool on) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element *start, *end; int32 start_pos, end_pos; /* * 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; } state = top_state->doc_state; if ((state->selection_start == NULL)||(state->selection_end == NULL)) { return; } start = state->selection_start; start_pos = state->selection_start_pos; end = state->selection_end; end_pos = state->selection_end_pos; lo_HighlightSelect(context, state, start, start_pos, end, end_pos, on); } void LO_ClearSelection(MWContext *context) { int32 doc_id; lo_TopState *top_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; } state = top_state->doc_state; LO_HighlightSelection(context, FALSE); state->selection_start = NULL; state->selection_start_pos = 0; state->selection_end = NULL; state->selection_end_pos = 0; state->selection_layer = NULL; } PRIVATE XP_Block lo_SelectionToText(MWContext *context, lo_DocState *state, LO_Element *start, int32 start_pos, LO_Element *end, int32 end_pos) { LO_Element *eptr; LO_TextStruct tmp_text; LO_TextInfo text_info; LO_TextAttr tmp_attr; int32 space_width; int32 length; Bool indent_counts; PA_Block sbuff; XP_Block buff; char *str; char *tptr; /* int16 charset;*/ if ((start == NULL)||(end == NULL)) { return(NULL); } /* * All this work is to get the width of a " " in the default * fixed font. */ memset (&tmp_text, 0, sizeof (tmp_text)); sbuff = PA_ALLOC(1); if (sbuff == NULL) { return(NULL); } PA_LOCK(str, char *, sbuff); str[0] = ' '; PA_UNLOCK(sbuff); tmp_text.text = sbuff; tmp_text.text_len = 1; /* * Fill in default font information. */ lo_SetDefaultFontAttr(state, &tmp_attr, context); tmp_attr.fontmask |= LO_FONT_FIXED; tmp_text.text_attr = lo_FetchTextAttr(state, &tmp_attr); FE_GetTextInfo(context, &tmp_text, &text_info); PA_FREE(sbuff); space_width = text_info.max_width; if (space_width <= 0) { space_width = 2; } indent_counts = FALSE; length = 0; eptr = start; while ((eptr != NULL)&&(eptr->lo_any.ele_id <= end->lo_any.ele_id)) { int32 last_id; switch (eptr->type) { case LO_TEXT: if (eptr->lo_text.text != NULL) { if (indent_counts != FALSE) { int32 width; width = eptr->lo_text.x + eptr->lo_text.x_offset - state->win_left; width = (width + space_width - 1) / space_width; if (width < 0) { width = 0; } length += width; indent_counts = FALSE; } if ((eptr == start)||(eptr == end)) { int32 p1, p2; if (eptr == start) { p1 = start_pos; } else { p1 = 0; } if (eptr == end) { char *string; PA_LOCK(string, char *, eptr->lo_text.text); /* charset = eptr->lo_text.text_attr->charset; * p2 = end_pos + INTL_IsLeadByte(charset, string[end_pos]); * * p2 already point to the end of the selection * calling INTL_IsLeadByte(charset, string[end_pos]) is wrong here. */ p2 = end_pos; PA_UNLOCK(eptr->lo_text.text); if (p2 > lo_GetLastCharEndPosition(eptr)) { p2 = lo_GetLastCharEndPosition(eptr); } } else { p2 = lo_GetLastCharEndPosition(eptr); } if (p2 < p1) { p2 = p1; } length += (p2 - p1 + 1); } else { length += eptr->lo_text.text_len; } } break; case LO_LINEFEED: length += LINEBREAK_LEN; indent_counts = TRUE; break; case LO_HRULE: case LO_FORM_ELE: case LO_BULLET: case LO_IMAGE: case LO_SUBDOC: case LO_TABLE: default: break; } last_id = eptr->lo_any.ele_id; /* * Jump cell boundries if there is one between start * and end. */ if ((eptr->lo_any.next == NULL)&&(eptr != end)) { eptr = lo_JumpCellWall(context, state, eptr); } eptr = eptr->lo_any.next; /* * When we walk onto a cell, we need to walk into * it if it isn't empty. */ if ((eptr != NULL)&&(eptr->type == LO_CELL)&& (eptr->lo_cell.cell_list != NULL)) { eptr = eptr->lo_cell.cell_list; } /* * We don't want infinite loops. * If the element ID hasn't progressed, something * serious is wrong, and we should punt. */ if ((eptr != NULL)&&(eptr->lo_any.ele_id <= last_id)) { #ifdef DEBUG XP_TRACE(("Selection loop avoidance 3\n")); #endif /* DEBUG */ break; } } length++; #ifdef XP_WIN16 if (length > SIZE_LIMIT) { length = SIZE_LIMIT; } #endif /* XP_WIN16 */ buff = XP_ALLOC_BLOCK(length * sizeof(char)); if (buff == NULL) { return(NULL); } XP_LOCK_BLOCK(str, char *, buff); tptr = str; indent_counts = FALSE; length = 0; eptr = start; while ((eptr != NULL)&&(eptr->lo_any.ele_id <= end->lo_any.ele_id)) { int32 last_id; switch (eptr->type) { case LO_TEXT: if (eptr->lo_text.text != NULL) { char *text; if (indent_counts != FALSE) { int32 width; int32 i; width = eptr->lo_text.x + eptr->lo_text.x_offset - state->win_left; width = (width + space_width - 1) / space_width; if (width < 0) { width = 0; } length += width; #ifdef XP_WIN16 if (length > SIZE_LIMIT) { length -= width; break; } #endif /* XP_WIN16 */ for (i=0; ilo_text.text); /* charset = eptr->lo_text.text_attr->charset; * p2 = end_pos + INTL_IsLeadByte(charset, string[end_pos]); * * p2 already point to the end of the selection * calling INTL_IsLeadByte(charset, string[end_pos]) is wrong here. */ p2 = end_pos; PA_UNLOCK(eptr->lo_text.text); if (p2 > maxPos) { p2 = maxPos; } } else { p2 = maxPos; } if (p2 < p1) { p2 = p1; } len = p2 - p1 + 1; length += len; #ifdef XP_WIN16 if (length > SIZE_LIMIT) { length -= len; break; } #endif /* XP_WIN16 */ PA_LOCK(text, char *, eptr->lo_text.text); XP_BCOPY((char *)(text + p1), tptr, len); tptr = (char *)(tptr + len); PA_UNLOCK(eptr->lo_text.text); } else { length += eptr->lo_text.text_len; #ifdef XP_WIN16 if (length > SIZE_LIMIT) { length -= eptr->lo_text.text_len; break; } #endif /* XP_WIN16 */ PA_LOCK(text, char *, eptr->lo_text.text); XP_BCOPY(text, tptr, eptr->lo_text.text_len); tptr = (char *)(tptr + eptr->lo_text.text_len); PA_UNLOCK(eptr->lo_text.text); } } break; case LO_LINEFEED: length += LINEBREAK_LEN; #ifdef XP_WIN16 if (length > SIZE_LIMIT) { length -= LINEBREAK_LEN; break; } #endif /* XP_WIN16 */ XP_BCOPY(LINEBREAK, tptr, LINEBREAK_LEN); tptr = (char *)(tptr + LINEBREAK_LEN); indent_counts = TRUE; break; case LO_HRULE: case LO_FORM_ELE: case LO_BULLET: case LO_IMAGE: case LO_SUBDOC: case LO_TABLE: default: break; } last_id = eptr->lo_any.ele_id; /* * Jump cell boundries if there is one between start * and end. */ if ((eptr->lo_any.next == NULL)&&(eptr != end)) { eptr = lo_JumpCellWall(context, state, eptr); } eptr = eptr->lo_any.next; /* * When we walk onto a cell, we need to walk into * it if it isn't empty. */ if ((eptr != NULL)&&(eptr->type == LO_CELL)&& (eptr->lo_cell.cell_list != NULL)) { eptr = eptr->lo_cell.cell_list; } /* * We don't want infinite loops. * If the element ID hasn't progressed, something * serious is wrong, and we should punt. */ if ((eptr != NULL)&&(eptr->lo_any.ele_id <= last_id)) { #ifdef DEBUG XP_TRACE(("Selection loop avoidance 4\n")); #endif /* DEBUG */ break; } } str[length] = '\0'; length++; XP_UNLOCK_BLOCK(buff); return(buff); } XP_Block LO_GetSelectionText(MWContext *context) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element *start, *end; int32 start_pos, end_pos; XP_Block buff; /* * 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(NULL); } state = top_state->doc_state; if ((state->selection_start == NULL)||(state->selection_end == NULL)) { return(NULL); } start = state->selection_start; start_pos = state->selection_start_pos; end = state->selection_end; end_pos = state->selection_end_pos; /* Make sure the selection is normalized */ lo_NormalizeSelectionPoint(context, state, &start, &start_pos); lo_NormalizeSelectionEnd(context, state, &end, &end_pos); buff = lo_SelectionToText(context, state, start, start_pos, end, end_pos); return(buff); } Bool LO_HaveSelection(MWContext *context) { int32 doc_id; lo_TopState *top_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(FALSE); } state = top_state->doc_state; if ((state->selection_start == NULL)||(state->selection_end == NULL)) { return(FALSE); } else { return(TRUE); } } /* return true if there is a current selection */ PRIVATE Bool lo_GetSelection(MWContext *context, LO_Selection* selection) { int32 beginPosition; int32 endPosition; CL_Layer *sel_layer; /* LO_GetSelectionEndPoints uses int32. LO_Selection uses intn. So we need to * do the conversion here. */ LO_GetSelectionEndpoints(context, &selection->begin.element, &selection->end.element, &beginPosition, &endPosition, &sel_layer); selection->begin.position = (intn) beginPosition; selection->end.position = (intn) endPosition; return selection->begin.element != NULL && selection->end.element != NULL; } void LO_GetSelectionEndpoints(MWContext *context, LO_Element **start, LO_Element **end, int32 *start_pos, int32 *end_pos, CL_Layer **sel_layer) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; *start = NULL; *end = NULL; *start_pos = 0; *end_pos = 0; *sel_layer = NULL; /* * 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; } state = top_state->doc_state; if ((state->selection_start == NULL)||(state->selection_end == NULL)) { return; } *start = state->selection_start; *start_pos = state->selection_start_pos; *end = state->selection_end; *end_pos = state->selection_end_pos; *sel_layer = state->selection_layer; } /* Returns TRUE if there was anything to select. If there is no data, or if * we're in editor mode and there is no editable data, then FALSE is returned. */ Bool LO_SelectAll(MWContext *context) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Selection selection; /* * 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 FALSE; } state = top_state->doc_state; LO_HighlightSelection(context, FALSE); selection.begin.element = NULL; selection.begin.position = 0; selection.end.element = NULL; selection.end.position = 0; if ( ! ( lo_FindDocumentEdge(context, state, &selection.begin, TRUE, FALSE) && lo_FindDocumentEdge(context, state, &selection.end, TRUE, TRUE) ) ) { return FALSE; } #if 0 lo_ConvertInsertPointToSelectionEnd(context, state, &selection.end.element, &selection.end.position); #endif LO_ASSERT_SELECTION(context, &selection); /* * Nothing to select. */ if (selection.begin.element == NULL) { return FALSE; } state->selection_start = selection.begin.element; state->selection_start_pos = selection.begin.position; state->selection_end = selection.end.element; state->selection_end_pos = selection.end.position; #if 0 if ( ! lo_NormalizeSelection(context) ){ return FALSE; } #endif LO_HighlightSelection(context, TRUE); return TRUE; } #ifdef EDITOR /* This routine normalizes a selection so that it only selects editable elements. * It returns TRUE if the resulting selection is not empty. */ Bool lo_NormalizeSelection(MWContext *context) { Bool result; int32 doc_id; lo_TopState *top_state; lo_DocState *state; intn comparisonResult; #ifdef DEBUG lo_VerifyLayout(context); #endif /* DEBUG */ result = FALSE; /* * Get the unique document ID, and retreive this * document's layout state. */ doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); if ((top_state == NULL)||(top_state->doc_state == NULL)) { return FALSE; } state = top_state->doc_state; if ( ! ( lo_EnsureEditableSearchNext2(context, state, &state->selection_start, & state->selection_start_pos) && lo_EnsureEditableSearchPrev2(context, state, &state->selection_end, & state->selection_end_pos) ) ) { XP_ASSERT(FALSE); return FALSE; } /* * Ensure that the start position is before the end position */ comparisonResult = lo_compare_selections( state->selection_start, state->selection_start_pos, state->selection_end, state->selection_end_pos ); result = comparisonResult <= 0; if ( comparisonResult > 0 ) { /* * It's not a legal selection. This can happen if we're editing and * the selected element is not editable. In this case we null out the selection */ state->selection_start = NULL; state->selection_end = NULL; state->selection_start_pos = 0; state->selection_end_pos = 0; } return result; } #endif Bool lo_EnsureEditableSearchNext(MWContext *context, lo_DocState* state, LO_Element** eptr) { int32 position = 0; return lo_EnsureEditableSearch2(context, state, eptr, &position, TRUE); } Bool lo_EnsureEditableSearchNext2(MWContext *context, lo_DocState* state, LO_Element** eptr, int32* ePositionPtr) { return lo_EnsureEditableSearch2(context, state, eptr, ePositionPtr, TRUE); } Bool lo_EnsureEditableSearchPrev(MWContext *context, lo_DocState* state, LO_Element** eptr) { int32 position = lo_GetMaximumInsertPointPosition(*eptr); return lo_EnsureEditableSearch2(context, state, eptr, &position, FALSE); } Bool lo_EnsureEditableSearchPrev2(MWContext *context, lo_DocState* state, LO_Element** eptr, int32* ePositionPtr) { return lo_EnsureEditableSearch2(context, state, eptr, ePositionPtr, FALSE); } /* Returns TRUE if the result is editable. Doesn't change position if can't find editable. */ Bool lo_EnsureEditableSearch(MWContext *context, lo_DocState* state, LO_Position* p, Bool forward) { return lo_EnsureEditableSearch2(context, state, &p->element, &p->position, forward); } PRIVATE Bool lo_BumpToNextElement(MWContext *context, lo_DocState* state, LO_Element** eptr, int32* ePositionPtr, Bool forward) { LO_Element* element = *eptr; int32 position = *ePositionPtr; if ( forward ) { element = lo_BoundaryJumpingNext(context, state, element); } else { element = lo_BoundaryJumpingPrev(context, state, element); } if ( ! element ) return FALSE; if ( forward ) { position = 0; } else { position = lo_GetMaximumInsertPointPosition(element); } *eptr = element; *ePositionPtr = position; return TRUE; } Bool lo_EnsureEditableSearch2(MWContext *context, lo_DocState* state, LO_Element** eptr, int32* ePositionPtr, Bool forward) { Bool moved = FALSE; LO_Element* element = *eptr; int32 position = *ePositionPtr; if ( ! element ) return FALSE; while ( ! lo_IsValidEditableInsertPoint2(context, state, element, position ) ) { if ( ! lo_BumpToNextElement(context, state, &element, &position, forward ) ) { return FALSE; } moved = TRUE; } if ( moved ) { *eptr = element; *ePositionPtr = position; } return TRUE; } Bool lo_IsValidEditableInsertPoint2(MWContext *context, lo_DocState* state, LO_Element* eptr, int32 position) { return lo_ValidEditableElement(context, eptr) && position >= 0 && position <= lo_GetMaximumInsertPointPosition(eptr); } #ifdef EDITOR /* * This routine has too much knowledge of the layout engine. Need to revisit */ void LO_PositionCaret(MWContext *context, int32 x, int32 y, CL_Layer *layer) { LO_Click(context, x, y, TRUE, layer); } void LO_DoubleClick(MWContext *context, int32 x, int32 y, CL_Layer *layer) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_HitResult result; /* * 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; } state = top_state->doc_state; LO_Hit(context, x, y, FALSE, &result, layer); lo_ProcessDoubleClick(context, top_state, state, &result, layer); } #endif PRIVATE void lo_GetHorizontalBounds(LO_Element* eptr, int32* returnBegin, int32* returnEnd) { int32 width = eptr->lo_any.width; /* * Images need to account for border width */ if (eptr->type == LO_IMAGE) { width = width + (2 * eptr->lo_image.border_width); } if (width <= 0) { width = 1; } *returnBegin = eptr->lo_any.x + eptr->lo_any.x_offset; *returnEnd = *returnBegin + width; } int32 lo_GetTextAttrMask(LO_Element* eptr) { int32 mask = 0; LO_TextAttr* textAttr = 0; if ( ! eptr ) { XP_ASSERT(FALSE); return mask; } switch ( eptr->type ) { case LO_TEXT: textAttr = eptr->lo_text.text_attr; break; case LO_IMAGE: textAttr = eptr->lo_image.text_attr; break; case LO_LINEFEED: textAttr = eptr->lo_linefeed.text_attr; break; default: break; } if ( textAttr ) { mask = textAttr->attrmask; } return mask; } int32 lo_GetElementLength(LO_Element* eptr) { int32 length; if ( ! eptr ) { XP_ASSERT(FALSE); return 1; } switch ( eptr->type ) { case LO_TEXT: length = eptr->lo_text.text_len; break; case LO_TEXTBLOCK: case LO_DESCTITLE: length = 0; /*MJUDGE 2-5-98*/ break; case LO_HRULE: case LO_IMAGE: case LO_LINEFEED: default: length = 1; break; } return length; } LO_AnchorData* lo_GetAnchorData(LO_Element* eptr) { LO_AnchorData* result = 0; if ( ! eptr ) { XP_ASSERT(FALSE); return result; } switch ( eptr->type ) { case LO_TEXT: result = eptr->lo_text.anchor_href; break; case LO_IMAGE: result = eptr->lo_image.anchor_href; break; case LO_LINEFEED: result = eptr->lo_linefeed.anchor_href; break; default: break; } return result; } LO_Element* lo_GetNeighbor(LO_Element* element, Bool forward) { LO_Element* result = NULL; if ( element ) { if ( forward ) result = element->lo_any.next; else result = element->lo_any.prev; } return result; } int32 lo_GetElementEdge(LO_Element* element, Bool forward) { int32 result = 0; if ( element ) { if ( forward ) result = lo_GetElementLength(element); } return result; } int32 lo_GetMaximumInsertPointPosition(LO_Element* eptr) { if ( ! eptr ) { XP_ASSERT(FALSE); return 0; } #if 0 if ( eptr->type == LO_LINEFEED ) { return 0; } else { return lo_GetElementLength(eptr); } #endif return lo_GetElementLength(eptr); } int32 lo_IncrementPosition(LO_Element* eptr, int32 position) { int32 length = lo_GetElementLength(eptr); if ( position < length ) { if (eptr->type == LO_TEXT) { unsigned char *string; PA_LOCK(string, unsigned char *, eptr->lo_text.text); position = INTL_NextCharIdx(eptr->lo_text.text_attr->charset, string, position); PA_UNLOCK(eptr->lo_text.text); } else position++; } if ( position > length ) { position = length; } return position; } int32 lo_DecrementPosition(LO_Element* eptr, int32 position) { if ( position > 0 ) { if (eptr->type == LO_TEXT) { unsigned char *string; PA_LOCK(string, unsigned char *, eptr->lo_text.text); position = INTL_PrevCharIdx(eptr->lo_text.text_attr->charset, string, position); PA_UNLOCK(eptr->lo_text.text); } else position--; } if ( position < 0 ) { position = 0; } return position; } int32 lo_GetLastCharBeginPosition(LO_Element* eptr) { return lo_DecrementPosition(eptr, lo_GetElementLength(eptr)); } int32 lo_GetLastCharEndPosition(LO_Element* eptr) { return lo_GetElementLength(eptr) - 1; } void lo_HitLine(MWContext *context, lo_DocState *state, int32 x, int32 y, Bool requireCaret, LO_HitResult* result); void lo_HitLine2(MWContext *context, lo_DocState *state, LO_Element* element, int32 position, int32 x, LO_HitResult* result); Bool lo_PositionIsOffEndOfLine(LO_HitElementResult* elementResult); void lo_FullHitElement(MWContext *context, lo_DocState* state, int32 x, int32 y, Bool requireCaret, LO_Element* eptr, int32 ret_x, int32 ret_y, LO_HitResult* result); PRIVATE void lo_HitElement(MWContext *context, lo_DocState* state, int32 x, int32 y, Bool requireCaret, LO_Element* eptr, int32 ret_x, int32 ret_y, LO_HitResult* result) { /* We hit something */ result->type = LO_HIT_ELEMENT; result->lo_hitElement.position.element = eptr; switch ( eptr->lo_any.type ) { case LO_TEXT: { int32 charStart; int32 charEnd; result->lo_hitElement.position.position = lo_ElementToCharOffset2(context, state, eptr, ret_x, &charStart, &charEnd); if (result->lo_hitElement.position.position < 0) { result->lo_hitElement.position.position = 0; result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_BEFORE; } else { /* * eptr points to the element * region is the part of the element */ if( x > eptr->lo_any.x + eptr->lo_text.width ) { result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_AFTER; } else { int32 charMiddle = (charStart + charEnd) / 2; if ( ret_x < charMiddle ) { result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_BEFORE; } else { result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_AFTER; } } } } break; default: { int32 begin; int32 end; result->lo_hitElement.position.position = 0; lo_GetHorizontalBounds(eptr, &begin, &end); if ( requireCaret ) { int32 middle = (begin + end) / 2; result->lo_hitElement.region = ( x < middle ) ? LO_HIT_ELEMENT_REGION_BEFORE : LO_HIT_ELEMENT_REGION_AFTER; } else { int32 midBegin; int32 midEnd; midBegin = begin + 3; midEnd = end - 3; if ( midEnd - midBegin < 6 ) { if ( end - begin <= 6 ) { /* Very narrow picture. 0..6 pixels */ midBegin = begin; midEnd = end; } else { /* Narrow picture. 6+..12 pixels */ int32 margin = end - begin - 6; int32 halfMargin = margin / 2; midBegin = begin + halfMargin; midEnd = end - (margin - halfMargin); } } if ( x < midBegin ) { result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_BEFORE; } else if ( x < midEnd ) { result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_MIDDLE; } else { result->lo_hitElement.region = LO_HIT_ELEMENT_REGION_AFTER; } } } break; } } void lo_FullHitElement(MWContext *context, lo_DocState* state, int32 x, int32 y, Bool requireCaret, LO_Element* eptr, int32 ret_x, int32 ret_y, LO_HitResult* result) { if ( eptr->type != LO_LINEFEED ) { /* Seek forward to find an editable element */ if ( ! lo_EnsureEditableSearchNext(context, state, &eptr) ) { lo_EnsureEditableSearchPrev(context, state, &eptr); } lo_HitElement(context, state, x, y, requireCaret, eptr, ret_x, ret_y, result); /* Check if we ran off the end of the line */ if ( result->type == LO_HIT_UNKNOWN ) #if 0 /* leads to infinite recursion when draging around tables. */ if ( result->type == LO_HIT_UNKNOWN || result->type == LO_HIT_ELEMENT && lo_PositionIsOffEndOfLine(& result->lo_hitElement) ) #endif { /* XP_TRACE(("Element off end of line.")); */ lo_HitLine(context, state, x, y, requireCaret, result); } } else { /* There's a bug selecting the last character of text in a table * that bites us if we use lo_HitLine. So rather than starting the * search from the beginning, we start from the linefeed. */ lo_HitLine2(context, state, eptr, 0, x, result); } } PRIVATE void lo_HitCellWideMatch(MWContext *context, lo_DocState *state, LO_CellStruct* cellPtr, int32 x, int32 y, Bool requireCaret, LO_HitResult* result) { #if 0 LO_Element* eptr = lo_XYToNearestCellElement(context, state, cellPtr, x, y); #endif /* * The last argument is FALSE so that we search upwards. This helps us in tables * in the editor. */ LO_Element* eptr = lo_search_element_list_WideMatch(context, cellPtr->cell_list, NULL, x, y, FALSE); if ( eptr ) { lo_FullHitElement(context, state, x, y, requireCaret, eptr, x, y, result); } } PRIVATE void lo_HitCell(MWContext *context, lo_DocState *state, LO_CellStruct* cellPtr, int32 x, int32 y, Bool requireCaret, LO_HitResult* result) { LO_Element* eptr = lo_XYToNearestCellElement(context, state, cellPtr, x, y); if ( eptr ) { lo_FullHitElement(context, state, x, y, requireCaret, eptr, x, y, result); } } void lo_HitLine(MWContext *context, lo_DocState *state, int32 x, int32 y, Bool requireCaret, LO_HitResult* result) { int32 line; result->type = LO_HIT_UNKNOWN; /* * Search from current line backwards to find something to edit. */ for ( line = lo_PointToLine(context, state, x, y); line >= 0; line-- ) { LO_Element* begin; LO_Element* end; LO_Element* tptr; lo_GetLineEnds(context, state, line, & begin, & end); /* lo_GetLineEnds returns the start of the next line for 'end' */ if ( end ) { end = end->lo_any.prev; } else { /* Last line. We know that the last line only has one element. */ end = begin; } /* Except for cases where the entire line is a line feed, don't select the end line-feed. */ if ( begin->type != LO_LINEFEED && end->type == LO_LINEFEED ) { end = end->lo_any.prev; } if ( begin->type == LO_TABLE ) { /* Search inside the table to find which cell/caption we hit */ LO_Element* tptr; tptr = begin->lo_any.next; while ((tptr != NULL)&&(tptr->type == LO_CELL)) { if ( tptr->lo_any.x <= x && x < tptr->lo_any.x + tptr->lo_any.width && tptr->lo_any.y <= y && y < tptr->lo_any.y + tptr->lo_any.height ) { /* We hit this cell */ /* lo_HitCellWideMatch(context, state, (LO_CellStruct*) tptr, x, y, requireCaret, result); */ /* Replacing call to lo_HitCellWideMatch with lo_HitCell because the former function does not drill down into cell lists to find the closest document element to x,y. This fixes selection in tables. */ lo_HitCell(context, state, (LO_CellStruct*) tptr, x, y, requireCaret, result); break; } tptr = tptr->lo_any.next; } return; } /* * Loop through the elements in the line and, if any are inflow * layers, go into them. We bail out if we've reached the end of * the line (or null for the last line). */ for( tptr = begin; tptr && ((tptr != end) || (begin == end)); tptr = tptr->lo_any.next) { if ( tptr->type == LO_CELL && tptr->lo_cell.cell_inflow_layer && tptr->lo_any.x <= x && x < tptr->lo_any.x + tptr->lo_any.width && tptr->lo_any.y <= y && y < tptr->lo_any.y + tptr->lo_any.height ) { lo_HitCell(context, state, (LO_CellStruct *)tptr, x, y, requireCaret, result); return; } } /* Make the end-points editable */ if ( ! lo_EnsureEditableSearchNext(context, state, &begin) ) continue; if ( ! lo_EnsureEditableSearchPrev(context, state, &end) ) return; if ( begin && end && begin->lo_any.ele_id <= end->lo_any.ele_id ) { result->type = LO_HIT_LINE; if ( x < begin->lo_any.x ) { result->lo_hitLine.region = LO_HIT_LINE_REGION_BEFORE; } else { result->lo_hitLine.region = LO_HIT_LINE_REGION_AFTER; } result->lo_hitLine.selection.begin.element = begin; result->lo_hitLine.selection.begin.position = 0; result->lo_hitLine.selection.end.element = end; if ( end->type == LO_LINEFEED ) { result->lo_hitLine.selection.end.position = 0; } else { result->lo_hitLine.selection.end.position = lo_GetMaximumInsertPointPosition(end); } #if 0 XP_TRACE(("b %d e %d\n", result->lo_hitLine.begin->lo_any.ele_id, result->lo_hitLine.end->lo_any.ele_id)); #endif break; } } } #ifdef MQUOTE /* Returns true if the only elements between begin and end are bullets, not including endpoints. */ Bool lo_OnlyBulletsBetween(LO_Element *begin,LO_Element *end) { /* Both begin and end should exist, and begin should be strictly before end. */ if (!begin || !end || (begin->lo_any.ele_id >= end->lo_any.ele_id)) { XP_ASSERT(FALSE); return FALSE; } /* We should never get into an infinite loop because we made sure begin was before end. */ do { if (begin->lo_any.next == end) { return TRUE; } begin = begin->lo_any.next; } while (begin->type == LO_BULLET); /* Hit something that's not a bullet between begin and end. */ return FALSE; } #endif void lo_HitLine2(MWContext *context, lo_DocState *state, LO_Element* element, int32 position, int32 x, LO_HitResult* result) { LO_Element* begin; LO_Element* end; result->type = LO_HIT_UNKNOWN; end = element; for(;;) { /* If this is a non-editable line feed, go backwards to the previous editable line. */ while ( end && end->type == LO_LINEFEED && end->lo_linefeed.break_type == LO_LINEFEED_BREAK_SOFT) { end = end->lo_any.prev; } if ( ! end ) return; /* Search forward to find the end of line */ for ( ; end; end = end->lo_any.next) { if ( end->type == LO_LINEFEED ) break; } if ( ! end ) { return; } /* Search backwards to find the beginning of the line. */ for ( begin = end->lo_any.prev; begin; begin = begin->lo_any.prev) { if ( begin->type == LO_LINEFEED ) { #ifdef MQUOTE /* We have the case of an editable linefeed on a line by itself when the only thing on the line are bullets. I.e. from a tag. */ if ( lo_OnlyBulletsBetween(begin,end) ) #else if ( begin->lo_any.next == end ) #endif { /* editable linefeed on a line by itself. */ result->type = LO_HIT_LINE; if ( x < end->lo_any.x ) { result->lo_hitLine.region = LO_HIT_LINE_REGION_BEFORE; } else { result->lo_hitLine.region = LO_HIT_LINE_REGION_AFTER; } result->lo_hitLine.selection.begin.element = end; result->lo_hitLine.selection.begin.position = 0; result->lo_hitLine.selection.end = result->lo_hitLine.selection.begin; return; } begin = begin->lo_any.next; break; } if ( ! begin->lo_any.prev ) break; /* Start of document */ } if ( ! begin ) { /* Must be a line-feed at the beginning of the document */ begin = end; } /* Except for cases where the entire line is a line feed, don't select the end line-feed. */ if ( begin->type != LO_LINEFEED && end->type == LO_LINEFEED ) { end = end->lo_any.prev; } if ( ( begin->type == LO_TABLE ) || (begin->type == LO_CELL && begin->lo_cell.cell_inflow_layer) ) { /* If this is a table or an inflow layer, give up. We don't understand them, yet. */ return; } /* Make the end-points editable */ if ( ! lo_EnsureEditableSearchNext(context, state, & begin) ) { /* This is the last, unselectable line of a document in edit mode. * Select the previous line. */ if ( lo_EnsureEditableSearchPrev(context, state, & begin) ){ lo_HitLine2(context, state, begin, 0, 0, result); } return; } if ( ! lo_EnsureEditableSearchPrev(context, state, & end) ) return; if ( begin && end && begin->lo_any.ele_id <= end->lo_any.ele_id ) { /* This is a good line */ break; } /* At this point "end" points to the previous editable line. So try again. */ } result->type = LO_HIT_LINE; if ( x < begin->lo_any.x ) { result->lo_hitLine.region = LO_HIT_LINE_REGION_BEFORE; } else { result->lo_hitLine.region = LO_HIT_LINE_REGION_AFTER; } result->lo_hitLine.selection.begin.element = begin; result->lo_hitLine.selection.begin.position = 0; result->lo_hitLine.selection.end.element = end; if ( end->type == LO_LINEFEED ) { result->lo_hitLine.selection.end.position = 0; } else { result->lo_hitLine.selection.end.position = lo_GetMaximumInsertPointPosition(end); } } Bool lo_PositionIsOffEndOfLine(LO_HitElementResult* elementResult) { if ( elementResult->region == LO_HIT_ELEMENT_REGION_AFTER ) { LO_Element* eptr = elementResult->position.element; int32 position = elementResult->position.position; if ( eptr && eptr->lo_any.next && eptr->lo_any.next->type == LO_LINEFEED ) { return position >= lo_GetLastCharEndPosition(eptr); } } return FALSE; } /* * LO_Hit * Determines what semantic part of the layout was hit for a given x/y position. * This is intended to be called by cursor tracking, drag & drop, etc. * */ void LO_Hit(MWContext *context, int32 x, int32 y, Bool requireCaret, LO_HitResult* result, CL_Layer *layer) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_Element *eptr; int32 position; int32 ret_x, ret_y; LO_CellStruct *layer_cell; #if 0 lo_PrintLayout(context); #endif /* DEBUG */ result->type = LO_HIT_UNKNOWN; /* * 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; } state = top_state->doc_state; layer_cell = lo_GetCellFromLayer(context, layer); if (layer_cell != NULL) { lo_HitCell(context, state, layer_cell, x, y, requireCaret, result); } else { /* Clip Y to the last line of the document */ { LO_Position endOfDocument; int32 endY; LO_Element *last_eptr; last_eptr = LO_getFirstLastElement(context, FALSE); if (last_eptr == NULL) { return; } endY = last_eptr->lo_any.y + last_eptr->lo_any.y_offset + last_eptr->lo_any.height; if ( y >= endY ){ y = endY - 1; } } /* Clip Y to the first line of the document */ { LO_Position startOfDocument; int32 startY; LO_Element *first_eptr; first_eptr = LO_getFirstLastElement(context, TRUE); if (first_eptr == NULL) { return; } /* Curiously, tables have an offset which excludes their captions. So don't * add in the offset, or else you won't be able to select the caption of a * table at the start of a document. */ startY = first_eptr->lo_any.y; if ( y < startY ){ y = startY; } } /* Note: Setting the first Boolean to TRUE allows you to hit-select into floating elements, * which basicly means into floating tables. Unfortunately, floating element ids are not numbered * consecutively with respect to the main document flow, which means that selections that * cross from below the floating element into the floating element will compare and draw wrong. */ position = 0; eptr = lo_XYToDocumentElement2(context, state, x, y, FALSE, TRUE, TRUE, TRUE, &ret_x, &ret_y); /* LO_DUMP_INSERT_POINT("lo_XYToDocumentElement2", eptr, 0); */ if ( eptr ) { lo_FullHitElement(context, state, x, y, requireCaret, eptr, ret_x, ret_y, result); } else { lo_HitLine(context, state, x, y, requireCaret, result); } } #ifdef DEBUG { /* const char* kTypes[] = { "LO_HIT_UNKNOWN", "LO_HIT_LINE", "LO_HIT_ELEMENT"};*/ XP_ASSERT ( result->type >= LO_HIT_UNKNOWN && result->type <= LO_HIT_ELEMENT ); } #if 0 /* Useful for debugging mouse selection, */ LO_DUMP_HIT_RESULT(result); #endif #endif } void lo_SetInsertPoint(MWContext *context, lo_TopState *top_state, LO_Element* eptr, int32 position, CL_Layer *layer) { if ( EDT_IS_EDITOR(context) ) { #ifdef EDITOR LO_ASSERT_POSITION2(context, eptr, position); if ( ! lo_IsValidEditableInsertPoint2(context, top_state->doc_state, eptr, position) ) { XP_ASSERT(FALSE); } else { EDT_SetInsertPoint( top_state->edit_buffer, eptr->lo_any.edit_element, eptr->lo_any.edit_offset + position, position == 0); } #endif } LO_StartSelectionFromElement( context, eptr, position, layer ); } /* * Like LO_PositionCaret, except it selects non-text items as well. * Returns TRUE if the result is a selection, FALSE if the result is * an insertion point. (The layout level * does not understand the concept of insertion point.) */ Bool LO_Click(MWContext *context, int32 x, int32 y, Bool requireCaret, CL_Layer *layer) { int32 doc_id; lo_TopState *top_state; lo_DocState *state; LO_HitResult result; /* * 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 FALSE; } state = top_state->doc_state; LO_Hit(context, x, y, requireCaret, &result, layer); return lo_ProcessClick(context, top_state, state, &result, requireCaret, layer); } Bool lo_ProcessClick(MWContext *context, lo_TopState *top_state, lo_DocState *state, LO_HitResult* result, Bool requireCaret, CL_Layer *layer) { switch ( result->type ) { case LO_HIT_LINE: { switch ( result->lo_hitLine.region ) { case LO_HIT_LINE_REGION_BEFORE: { if ( requireCaret ) /* Insertion point before first element of line */ { LO_Element* eptr = result->lo_hitLine.selection.begin.element; int32 position = result->lo_hitLine.selection.begin.position; lo_SetInsertPoint(context, top_state, eptr, position, layer); return FALSE; } else { /* Select the line */ lo_ExtendToIncludeHardBreak(context, state, & result->lo_hitLine.selection); lo_SetSelection(context, & result->lo_hitLine.selection, FALSE); return TRUE; } } break; case LO_HIT_LINE_REGION_AFTER: { /* Set the insertion point after the last element of line */ LO_Element* eptr = result->lo_hitLine.selection.end.element; int32 position = result->lo_hitLine.selection.end.position; lo_EnsureEditableSearchPrev2(context, state, &eptr, &position); lo_SetInsertPoint(context, top_state, eptr, position, layer); return FALSE; } break; default: break; } } break; case LO_HIT_ELEMENT: { LO_Element* eptr = result->lo_hitElement.position.element; int32 position = result->lo_hitElement.position.position; switch ( result->lo_hitElement.region ) { case LO_HIT_ELEMENT_REGION_BEFORE: { lo_SetInsertPoint(context, top_state, eptr, position, layer); return FALSE; } break; case LO_HIT_ELEMENT_REGION_MIDDLE: { /* Select the element */ LO_StartSelectionFromElement( context, eptr, position, layer ); lo_BumpEditablePositionForward(context, state, &eptr, &position); LO_ExtendSelectionFromElement( context, eptr, position, FALSE ); LO_HighlightSelection(context, TRUE); return TRUE; } break; case LO_HIT_ELEMENT_REGION_AFTER: { lo_BumpEditablePositionForward(context, state, &eptr, &position); lo_SetInsertPoint(context, top_state, eptr, position, layer); return FALSE; } break; default: break; } } break; default: break; } return FALSE; } /* Shares much functionality with lo_ProcessClick * If any changes made in logic above, please check * this and make corresponding changes if relevant * Returns the element that we will drop at and position * within this element for text data */ LO_Element * lo_PositionDropCaret(MWContext *pContext, int32 x, int32 y, int32 * pPosition) { LO_Element* eptr = NULL; #ifdef EDITOR lo_TopState *top_state = lo_FetchTopState(XP_DOCID(pContext)); int32 position; LO_HitResult result; lo_DocState *state; if ((top_state == NULL)||(top_state->doc_state == NULL)) { return NULL; } state = top_state->doc_state; LO_Hit(pContext, x, y, FALSE /*requireCaret*/, &result, 0); /* This was copied from lo_ProcessClick above * We want to execute most of the same logic to locate the caret position * without calling lo_SetInsertPoint, which sets the regular caret * and is incompatable with a selection */ switch ( result.type ) { case LO_HIT_LINE: switch ( result.lo_hitLine.region ) { case LO_HIT_LINE_REGION_BEFORE: /* Drop point before first element of line */ eptr = result.lo_hitLine.selection.begin.element; position = result.lo_hitLine.selection.begin.position; break; case LO_HIT_LINE_REGION_AFTER: /* Set the drop point after the last element of line */ eptr = result.lo_hitLine.selection.end.element; position = result.lo_hitLine.selection.end.position; lo_EnsureEditableSearchPrev2(pContext, state, &eptr, &position); break; default: break; } break; case LO_HIT_ELEMENT: eptr = result.lo_hitElement.position.element; position = result.lo_hitElement.position.position; /* Move to just past the element if after it */ if( result.lo_hitElement.region == LO_HIT_ELEMENT_REGION_AFTER ){ lo_BumpEditablePositionForward(pContext, state, &eptr, &position); } break; default: break; } if( eptr ) { LO_ASSERT_POSITION2(pContext, eptr, position); if ( lo_IsValidEditableInsertPoint2(pContext, state, eptr, position) ) { if( EDT_IsSelected(pContext) ) { FE_DestroyCaret(pContext); } switch ( eptr->type ) { case LO_TEXT: FE_DisplayTextCaret( pContext, FE_VIEW, &eptr->lo_text, (ED_CaretObjectPosition)position ); break; case LO_IMAGE: FE_DisplayImageCaret( pContext, &eptr->lo_image, (ED_CaretObjectPosition)position ); break; default: FE_DisplayGenericCaret( pContext, &eptr->lo_any, (ED_CaretObjectPosition)position ); break; } } else { XP_ASSERT(FALSE); } } if( pPosition ){ *pPosition = position; } #endif /* EDITOR */ return eptr; } /* Returns TRUE if the result is an anchor. Also selects the entire anchor. */ Bool lo_ProcessAnchorClick(MWContext *context, lo_TopState *top_state, lo_DocState *state, LO_HitResult* result) { switch ( result->type ) { case LO_HIT_LINE: { return FALSE; } break; case LO_HIT_ELEMENT: { LO_Element* eptr = result->lo_hitElement.position.element; switch ( result->lo_hitElement.region ) { case LO_HIT_ELEMENT_REGION_BEFORE: case LO_HIT_ELEMENT_REGION_AFTER: { return lo_SelectAnchor(context, state, eptr); } break; case LO_HIT_ELEMENT_REGION_MIDDLE: { return FALSE; } break; default: break; } } break; default: break; } return FALSE; } PRIVATE void lo_FindStartOfParagraph(MWContext* context, lo_DocState * state, LO_Position* where, LO_Position* paragraphStart) { /* * Search backwards to find the beginning of the paragraph. A paragraph starts * with the beginning of the document, or after a forced break. */ LO_Element* element; if ( ! (where && where->element ) ) { XP_ASSERT(FALSE); return; } element = where->element; for(;;) { LO_Element* prev = element->lo_any.prev; if ( ! prev ) break; if ( lo_IsEndOfParagraph2(context, prev, 0) ) { break; } element = prev; } paragraphStart->element = element; paragraphStart->position = 0; lo_EnsureEditableSearchNext2(context, state, ¶graphStart->element, & paragraphStart->position); } PRIVATE void lo_FindEndOfParagraph(MWContext* context, lo_DocState * state, LO_Position* where, LO_Position* paragraphEnd) { /* * Search forward to find the end of the paragraph. A paragraph ends * at the end of the document, or before a forced break. */ LO_Element* element; if ( ! (where && where->element ) ) { XP_ASSERT(FALSE); return; } element = where->element; for(;;) { LO_Element* p = element->lo_any.next; if ( ! p ) break; element = p; if ( lo_IsEndOfParagraph2(context, element, 0) ) break; } paragraphEnd->element = element; paragraphEnd->position = lo_GetElementLength(element); if ( paragraphEnd->element->type == LO_LINEFEED ) { paragraphEnd->position = 1; } /* lo_EnsureEditableSearchPrev2(context, state, ¶graphEnd->element, & paragraphEnd->position); */ } PRIVATE void lo_FindParagraph(MWContext* context, lo_DocState *state, LO_Position* where, LO_Selection* paragraph) { lo_FindStartOfParagraph(context, state, where, & paragraph->begin); lo_FindEndOfParagraph(context, state, where, ¶graph->end); lo_ConvertInsertPointToSelectionEnd(context, state, ¶graph->end.element, ¶graph->end.position); LO_ASSERT_SELECTION(context, paragraph); } PRIVATE void lo_SelectParagraph(MWContext* context, lo_DocState *state, LO_Position* where) { LO_Selection selection; lo_FindParagraph(context, state, where, &selection); lo_SetSelection(context, &selection, FALSE); } PRIVATE intn pa_strcmp( PA_Block p1, PA_Block p2 ) { char *s1, *s2; intn ret; PA_LOCK( s1, char*, p1 ); PA_LOCK( s2, char*, p2 ); ret = XP_STRCMP( s1, s2 ); PA_UNLOCK( p1 ); PA_UNLOCK( p2 ); return ret; } PRIVATE Bool lo_AnchorsEqual( LO_AnchorData *p1, LO_AnchorData *p2 ) { if( pa_strcmp( p1->anchor, p2->anchor ) != 0 ) { return FALSE; } if( p1->target == 0 && p2->target == 0 ) { return TRUE; } if( p1->target && p2->target && pa_strcmp( p1->target, p2->target ) == 0 ) { return TRUE; } return FALSE; } PRIVATE Bool lo_FindAnchorEdge(MWContext* context, lo_DocState *state, LO_Position* where, LO_Position* result, Bool forward) { LO_Element* element = where->element; LO_AnchorData* goal = lo_GetAnchorData(element); if ( ! goal ) return FALSE; while(1) { LO_Element* next = lo_GetNeighbor(element, forward); LO_AnchorData* next_anchor; if ( next == 0 || (next_anchor = lo_GetAnchorData(next)) == 0 || !lo_AnchorsEqual( next_anchor,goal )) { break; } element = next; } /* LINEFEED elements can have anchor information. Backup. */ while ( element && element->type == LO_LINEFEED ) { element = lo_GetNeighbor(element, !forward); } result->element = element; result->position = lo_GetElementEdge(element, forward); return TRUE; } PRIVATE Bool lo_FindAnchor(MWContext* context, lo_DocState *state, LO_Position* where, LO_Selection* anchor) { LO_Selection selection; Bool result = lo_FindAnchorEdge(context, state, where, & selection.begin, FALSE) && lo_FindAnchorEdge(context, state, where, &selection.end, TRUE); if ( result ) { lo_ConvertInsertPointToSelectionEnd(context, state, &selection.end.element, &selection.end.position); LO_ASSERT_SELECTION(context, &selection); *anchor = selection; } return result; } Bool lo_SelectAnchor(MWContext* context, lo_DocState *state, LO_Element* eptr) { /* Select the entire anchor associated with eptr */ Bool result = FALSE; LO_Selection selection; LO_Position where; where.element = eptr; where.position = 0; result = lo_FindAnchor(context, state, &where, &selection); if ( result ) { lo_SetSelection(context, &selection, FALSE); } return result; } /* * This should move to a public header so that the routine can be internationalized more easily. * * The word-finding algorithm assumes that characters can be divided into different classes. * The classes are: single, space, and grouping. There are currently only two grouping * classes, because that's enough for english text. Some languages (e.g. Japanese, which has * romanji, katakana and hirigana, might encourage us to define more grouping classes.) */ #define LO_CC_SINGLE 0 #define LO_CC_SPACE 1 #define LO_CC_ALPHA 2 #define LO_CC_PUNCT 3 #define LO_CC_KANJI 4 #define LO_CC_KANA 5 #define LO_CC_OTHERS 6 PRIVATE intn lo_CharacterClassOf(MWContext* context, lo_DocState *state, LO_Position* where) { LO_Position position = *where; if ( ! lo_NormalizeSelectionPoint(context, state, &position.element, &position.position) ) { /* We've gone off the end of the world. */ return LO_CC_SINGLE; } switch ( position.element->type ) { case LO_LINEFEED: return LO_CC_SPACE; case LO_TEXT: { int16 charset; if ( position.element->lo_text.text_len <= 0 ) { return LO_CC_SPACE; } charset = position.element->lo_text.text_attr->charset; XP_ASSERT(position.position < position.element->lo_text.text_len); if (INTL_CharSetType(charset) == SINGLEBYTE) { /* Need to handle this on a character-set basis. */ char *tptr; char c; /* To do: The lock should be outside of the inner loop. */ PA_LOCK(tptr, char *, position.element->lo_text.text); if ( tptr ) { c = tptr[position.position]; } else { XP_ASSERT(FALSE); c = '\0'; } PA_UNLOCK(where->element->lo_text.text); if ( XP_IS_SPACE(c) ) return LO_CC_SPACE; else if ( isalnum(c) || ((unsigned char)c > 0x7F)) return LO_CC_ALPHA; else return LO_CC_PUNCT; } else { /* Do something smarter here. */ char *tptr; char c; intn iRet; /* To do: The lock should be outside of the inner loop. */ PA_LOCK(tptr, char *, position.element->lo_text.text); if ( tptr == NULL ) { XP_ASSERT(FALSE); c = '\0'; iRet = LO_CC_SINGLE; } else { c = tptr[position.position]; /* Don't know how much detail we want to do for multibyte, right now it divide into pronounce character and kanji character */ switch (INTL_CharClass(charset, (unsigned char *)(tptr+position.position))) { case SEVEN_BIT_CHAR: if ( XP_IS_SPACE(c) ) iRet = LO_CC_SPACE; else if ( isalnum(c) ) iRet = LO_CC_ALPHA; else iRet = LO_CC_PUNCT; break; case HALFWIDTH_PRONOUNCE_CHAR: case FULLWIDTH_PRONOUNCE_CHAR: iRet = LO_CC_KANA; break; case FULLWIDTH_ASCII_CHAR: iRet = LO_CC_ALPHA; break; case KANJI_CHAR: iRet = LO_CC_KANJI; break; case UNCLASSIFIED_CHAR: iRet = LO_CC_OTHERS; break; default: iRet = LO_CC_PUNCT; } } PA_UNLOCK(where->element->lo_text.text); return iRet; } } default: return LO_CC_SINGLE; } } Bool lo_IsEdgeOfDocument2(MWContext* context, lo_DocState *state, LO_Element* element, int32 position, Bool forward) { /* If we can bump the pointer, then we're not at the end of the document. */ if ( forward ) { LO_Element* next; if ( element->type != LO_LINEFEED && position < lo_GetElementLength(element) ) return FALSE; next = lo_BoundaryJumpingNext(context, state, element); if ( next == NULL || lo_BoundaryJumpingNext(context, state, next) == NULL ) return TRUE; } else { if ( position > 0 ) return FALSE; } { return ! lo_BumpEditablePosition(context, state, &element, &position, forward); } } Bool lo_IsEdgeOfDocument(MWContext* context, lo_DocState *state, LO_Position* where, Bool forward) { return lo_IsEdgeOfDocument2(context, state, where->element, where->position, forward); } PRIVATE Bool lo_TraverseElement(MWContext* context, lo_DocState *state, LO_Element** element, Bool forward) { if ( ! element || ! *element ) return FALSE; if ( forward ) { *element = lo_BoundaryJumpingNext(context, state, *element); } else { *element = lo_BoundaryJumpingPrev(context, state, *element); } return *element != NULL; } /* Stop for linefeeds */ PRIVATE Bool lo_IsLineEdge(MWContext* context, lo_DocState *state, LO_Element* element, int32 position, Bool skipSoftBreaks, Bool forward) { LO_Element* next = element; int32 nextPosition = position; if ( ! lo_BumpEditablePosition(context, state, &next, &nextPosition, forward) ) { /* Hit end of document. That counts as a linefeed. */ return TRUE; } /* Increment element towards next, looking for a linefeed */ if ( next == element ) { return element->type == LO_LINEFEED; } if ( next->type == LO_LINEFEED ) { return TRUE; } if ( ! lo_TraverseElement(context, state, &element, forward) ) return TRUE; while ( next != element ) { if ( element->type == LO_LINEFEED && (forward ? position <= 0 : position > 0) && ! lo_ValidEditableElement(context, element) ) { Bool hardBreak = element->lo_linefeed.break_type != LO_LINEFEED_BREAK_SOFT; if ( !skipSoftBreaks || hardBreak ) return TRUE; } /* Go on to next element */ if ( ! lo_TraverseElement(context, state, &element, forward) ) return TRUE; } /* Didn't find a linefeed yet. */ return FALSE; } /* As long as there's room and where is of the target class, move forward. * returns with where not equal to the character class, unless edge of line or document. * returns TRUE if not edge of document, else false. */ #define LO_SO_DOCUMENT_EDGE 0 #define LO_SO_LINEFEED 1 #define LO_SO_NEW_CHARACTER_CLASS 2 PRIVATE intn lo_SkipOver(MWContext* context, lo_DocState *state, LO_Position* where, intn targetCharacterClass, Bool forward) { while ( lo_CharacterClassOf(context, state, where) == targetCharacterClass ) { /* Stop for linefeeds */ if ( lo_IsLineEdge(context, state, where->element, where->position, targetCharacterClass == LO_CC_SPACE, forward) ) { /* Skip to the next character */ return LO_SO_LINEFEED; } if ( ! lo_BumpEditablePosition(context, state, &where->element, &where->position, forward) ) return LO_SO_DOCUMENT_EDGE; } return LO_SO_NEW_CHARACTER_CLASS; } PRIVATE Bool lo_MoveToNearestEdgeOfNextLine(MWContext* context, lo_DocState *state, LO_Position* where, Bool forward) { LO_Position caret = *where; Bool bHardBreak; while ( ! lo_IsLineEdge(context, state, caret.element, caret.position, FALSE, forward) ) { if (! lo_BumpEditablePosition ( context, state, &caret.element, &caret.position, forward ) ) return FALSE; } bHardBreak = caret.element && caret.element->type == LO_LINEFEED && caret.element->lo_linefeed.break_type == LO_LINEFEED_BREAK_HARD; if ( bHardBreak && ! forward && caret.position == 1 ) { /* This is the after-a-hard-break-and-before-a-paragraph-end case. */ caret.position = 0; } else if ( bHardBreak && forward && caret.position == 0 && caret.element->lo_any.next && caret.element->lo_any.next->type == LO_LINEFEED && caret.element->lo_any.next->lo_linefeed.break_type == LO_LINEFEED_BREAK_PARAGRAPH ) { /* This is the before-a-hard-break-before-a-paragraph-end case. */ caret.position = 1; } else { do { lo_TraverseElement(context, state, &caret.element, forward); #ifdef MQUOTE } while ( caret.element && ((caret.element->type == LO_LINEFEED && caret.element->lo_linefeed.break_type == LO_LINEFEED_BREAK_SOFT) || caret.element->type == LO_BULLET)); /* Added code above to skip over leading bullets resulting from */ #else } while ( caret.element && caret.element->type == LO_LINEFEED && caret.element->lo_linefeed.break_type == LO_LINEFEED_BREAK_SOFT); #endif if ( ! caret.element ) return FALSE; caret.position = 0; if ( ! forward && caret.element ){ if ( ! (caret.element->type == LO_LINEFEED && caret.element->lo_linefeed.break_type == LO_LINEFEED_BREAK_HARD ) ){ caret.position = lo_GetMaximumInsertPointPosition(caret.element); } } { /* Bump by one position if crossing from one line of wrapped text to another. * This is because the editor can't represent the difference between one edge * and the next for wrapped text. *sigh* */ if ( caret.element && where->element && caret.element->type == LO_TEXT && where->element->type == LO_TEXT && caret.element->lo_any.edit_element == where->element->lo_any.edit_element ) { if (! lo_BumpEditablePosition ( context, state, &caret.element, &caret.position, forward ) ) return FALSE; } } } /* Skip over junk at edge of line. (For example, bullets.) */ if ( ! lo_EnsureEditableSearch2(context, state, &caret.element, &caret.position, forward) ) { /* Either the end of the document, or the end of a cell. */ #if 0 if (! lo_BumpEditablePosition ( context, state, &caret.element, &caret.position, forward ) ) return FALSE; #endif return FALSE; } XP_ASSERT(caret.element != NULL); *where = caret; return TRUE; } /* Return TRUE if we actually found an edge. FALSE if we're off the start or end of the document. */ PRIVATE Bool lo_FindEdgeOfWord(MWContext* context, lo_DocState *state, LO_Position* where, LO_Position* wordEdge, Bool bSelect, Bool forward, Bool bIncludeSpacesAtEndOfWord) { /* * Search to find the edge of the word. * word = { single_word | alpha_word | punct_word | space_word } * single_word = LO_CC_SINGLE (e.g. chinese character for the season "autumn".) * alpha_word = LO_CC_ALPHA + LO_CC_SPACE * (e.g. "foo10 ") * punct_word = LO_CC_PUNCT + LO_CC_SPACE * (e.g. "---() ") * space_word = LO_CC_SPACE + (e.g. " ") */ intn characterClass; *wordEdge = *where; /* Check for end of document */ if ( lo_IsEdgeOfDocument(context, state, wordEdge, forward) ) { lo_FindDocumentEdge(context, state, wordEdge, bSelect, forward); return TRUE; } if ( lo_IsLineEdge(context, state, where->element, where->position, FALSE, forward) ) { return TRUE; } if ( !forward && lo_IsLineEdge(context, state, where->element, where->position, FALSE, !forward) ) { /* Starting at end of line. Move backward. */ lo_BumpEditablePosition(context, state, &wordEdge->element, &wordEdge->position, forward); } characterClass = lo_CharacterClassOf(context, state, wordEdge); if ( characterClass == LO_CC_SINGLE ) { if ( forward ) { lo_BumpEditablePositionForward(context, state, &wordEdge->element, &wordEdge->position); } } else { /* Match more of this class */ if ( ! forward ) { /* Skip over spaces */ if ( lo_SkipOver(context, state, wordEdge, LO_CC_SPACE, forward ) != LO_SO_NEW_CHARACTER_CLASS ) { goto exit; } characterClass = lo_CharacterClassOf(context, state, wordEdge); } if ( characterClass != LO_CC_SPACE ) { if ( lo_SkipOver(context, state, wordEdge, characterClass, forward) != LO_SO_NEW_CHARACTER_CLASS ) goto exit; } if ( forward ) { if ( bIncludeSpacesAtEndOfWord ) { /* Skip over spaces */ if ( lo_SkipOver(context, state, wordEdge, LO_CC_SPACE, forward ) != LO_SO_NEW_CHARACTER_CLASS ) goto exit; } } else { /* If we didn't hit the edge of the document, we are now one element further than we want to be. So back up one position. */ lo_BumpEditablePositionForward(context, state, &wordEdge->element, &wordEdge->position); } } exit: /* The edge might be a line feed. If so, move to an editable position. */ lo_EnsureEditableSearch(context, state, wordEdge, forward); return TRUE; } PRIVATE Bool lo_IsEmptyText(LO_Element* eptr) { if ( eptr && eptr->type == LO_TEXT && lo_GetElementLength(eptr) == 0 ) { return TRUE; } return FALSE; } PRIVATE Bool lo_FindLineEdge(MWContext* context, lo_DocState *state, LO_Position* where, LO_Position* lineEdge, Bool select, Bool forward) { /* Special case for hard breaks at end of paragraph */ Bool bHardBreakAtEndOfParagraph; if ( lo_IsEdgeOfDocument(context, state, lineEdge, forward) ) { lo_FindDocumentEdge(context, state, lineEdge, select, forward); return TRUE; } bHardBreakAtEndOfParagraph = lo_IsHardBreak2(context, where->element, 0) || (lo_IsEmptyText(where->element) && lo_IsHardBreak2(context, where->element->lo_any.next, 0)); if ( bHardBreakAtEndOfParagraph && forward) { /* "where" is the correct edge */ *lineEdge = *where; } else { LO_HitResult result; lo_HitLine2(context, state, where->element, where->position, where->element->lo_any.x, &result); if ( result.type != LO_HIT_LINE ) { XP_ASSERT(FALSE); return FALSE; } if ( forward ) { if ( select ) { lo_ExtendToIncludeHardBreak(context, state, & result.lo_hitLine.selection); } *lineEdge = result.lo_hitLine.selection.end; lo_ConvertSelectionEndToInsertPoint(context, state, &lineEdge->element, &lineEdge->position); } else { *lineEdge = result.lo_hitLine.selection.begin; } } return TRUE; } Bool lo_FindDocumentEdge(MWContext* context, lo_DocState *state, LO_Position* edge, Bool select, Bool forward) { LO_Element **array; LO_Element* eptr = NULL; #ifdef XP_WIN16 XP_Block *larray_array; #endif /* XP_WIN16 */ /* * Nothing to select. */ if (state->line_num <= 1) { return FALSE; } if ( forward ) { /* * Here we deal with the case where the current selection is within * a layer. In that case, we need to find the edge of the layer. */ if (state->selection_layer) { LO_CellStruct *layer_cell = lo_GetCellFromLayer(context, state->selection_layer); if (layer_cell) eptr = layer_cell->cell_list_end; } if (!eptr) /* * Get last element in doc. */ eptr = state->end_last_line; if (eptr == NULL) { eptr = state->selection_start; } /* * Since the last element is always a * linefeed, it is safe to set selection_end_pos to 0. */ edge->element = eptr; edge->position = 0; if ( EDT_IS_EDITOR(context) ) { /* Skip over end-of-document elements. */ int32 position = 0; while ( eptr && eptr->type == LO_LINEFEED && eptr->lo_linefeed.break_type == LO_LINEFEED_BREAK_PARAGRAPH ) { if ( ! lo_BumpEditablePositionBackward(context, state, &eptr, &position) ) break; } edge->element = eptr; edge->position = position; /* Skip forward to end of paragraph. */ while ( eptr && ! lo_IsEndOfParagraph2(context, eptr,0) ) { eptr = eptr->lo_any.next; } if ( eptr ) { edge->element = eptr; edge->position = select ? 1 : 0; } else { XP_ASSERT(FALSE); } } } else { /* * Here we deal with the case where the current selection is within * a layer. In that case, we need to find the edge of the layer. */ if (state->selection_layer) { LO_CellStruct *layer_cell = lo_GetCellFromLayer(context, state->selection_layer); if (layer_cell) eptr = layer_cell->cell_list; } if (!eptr) { /* * Get first element in doc. */ #ifdef XP_WIN16 XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array); state->line_array = larray_array[0]; XP_UNLOCK_BLOCK(state->larray_array); #endif /* XP_WIN16 */ XP_LOCK_BLOCK(array, LO_Element **, state->line_array); eptr = array[0]; XP_UNLOCK_BLOCK(state->line_array); } /* * No elements. */ if (eptr == NULL) { return FALSE; } edge->element = eptr; edge->position = 0; } /* Backtrack to ensure editability. */ lo_EnsureEditableSearch(context, state, edge, !forward); /* However, for selecting forward, we need to go over the edge. */ if ( select && forward ) { if ( edge->element->lo_any.next && edge->element->lo_any.next->type == LO_LINEFEED) { edge->element = edge->element->lo_any.next; edge->position = 1; } } return TRUE; } Bool lo_FindWord(MWContext* context, lo_DocState *state, LO_Position* where, LO_Selection* word) { lo_FindEdgeOfWord(context, state, where, &word->begin, TRUE, FALSE, TRUE); LO_ASSERT_POSITION(context, &word->begin); lo_FindEdgeOfWord(context, state, where, &word->end, TRUE, TRUE, FALSE); if ( word->begin.element == word->end.element && word->begin.position == word->end.position ) { /* For some reason the result is an insert point. Perhaps there are no words in * this document. */ return FALSE; } lo_ConvertInsertPointToSelectionEnd(context, state, &word->end.element, &word->end.position); LO_ASSERT_SELECTION(context, word); return TRUE; } PRIVATE void lo_SelectWord(MWContext* context, lo_DocState *state, LO_Position* where) { LO_Selection selection; Bool success = lo_FindWord(context, state, where, &selection); if ( success ) { lo_SetSelection(context, &selection, FALSE); } else { /* No word available. */ lo_SelectParagraph(context, state, where ); } } Bool lo_ProcessDoubleClick(MWContext *context, lo_TopState *top_state, lo_DocState *state, LO_HitResult* result, CL_Layer *layer) { switch ( result->type ) { case LO_HIT_LINE: { switch ( result->lo_hitLine.region ) { case LO_HIT_LINE_REGION_BEFORE: { lo_SelectParagraph(context, state, & result->lo_hitLine.selection.begin ); return TRUE; } break; case LO_HIT_LINE_REGION_AFTER: { LO_Selection selection = result->lo_hitLine.selection; /* If they double clicked after the end of the document, back them up. */ lo_EnsureEditableSearchPrev2(context, state, &selection.end.element, &selection.end.position); if ( lo_ExtendToIncludeHardBreak(context, state, &selection) ) { /* Select the paragraph end */ selection.begin = selection.end; lo_SetSelection(context, &selection, FALSE); } else { lo_SelectWord(context, state, &selection.end ); } return FALSE; } break; default: break; } } break; case LO_HIT_ELEMENT: { switch ( result->lo_hitElement.region ) { case LO_HIT_ELEMENT_REGION_BEFORE: case LO_HIT_ELEMENT_REGION_AFTER: { if ( ! lo_SelectAnchor(context, state, result->lo_hitElement.position.element ) ) lo_SelectWord(context, state, &result->lo_hitElement.position ); return FALSE; } break; case LO_HIT_ELEMENT_REGION_MIDDLE: { /* To do: Open editor on image. For now, act like click */ return lo_ProcessClick( context, top_state, state, result, FALSE, layer); } break; default: break; } } break; default: break; } return FALSE; } PRIVATE Bool lo_FindCharacterEdge(MWContext* context, lo_DocState *state, LO_Position* where, LO_Position* edge, Bool bSelect, Bool forward) { *edge = *where; if ( forward ) { if ( lo_IsEdgeOfDocument(context, state, edge, forward) ) { lo_FindDocumentEdge(context, state, edge, bSelect, forward); return where->element != edge->element && where->position != edge->position; } return lo_BumpEditablePosition(context, state, &edge->element, &edge->position, forward); } else { /* We're already at the edge of the character. */ return TRUE; } } PRIVATE Bool lo_FindChunkEdge(MWContext* context, lo_DocState *state, LO_Position* where, LO_Position* wordEdge, intn chunkType, Bool select, Bool forward) { Bool result; *wordEdge = *where; switch ( chunkType ) { case LO_NA_CHARACTER: result = lo_FindCharacterEdge(context, state, where, wordEdge, select, forward); break; case LO_NA_WORD: result = lo_FindEdgeOfWord(context, state, where, wordEdge, select, forward, TRUE); break; case LO_NA_LINEEDGE: result = lo_FindLineEdge(context, state, where, wordEdge, select, forward); break; case LO_NA_DOCUMENT: /* Doesn't care where we start. */ result = lo_FindDocumentEdge(context, state, wordEdge, select, forward); break; default: XP_ASSERT(FALSE); return FALSE; } /* Did we go off the end of the world? */ /* if ( result && ! lo_EnsureEditableSearch(context, state, wordEdge, forward) ) result = FALSE; */ return result; } PRIVATE Bool lo_GapWithBothSidesAllowed( MWContext *context, lo_DocState *state, LO_Position* caret) { LO_Position prev = *caret; LO_Position next = *caret; Bool result = FALSE; if ( caret->position == 0 ) { result = lo_BumpEditablePosition(context, state, &prev.element, &prev.position, FALSE); } else if ( caret->position == lo_GetElementLength(caret->element) ) { result = lo_BumpEditablePosition(context, state, &next.element, &next.position, TRUE); } if ( ! result ) return FALSE; /* OK, we're in the gap. */ if ( prev.element->type == LO_HRULE || next.element->type == LO_HRULE ) { /* It's a gap with hrules. Now, if there isn't a hard break, we're all set. */ LO_Element* element; for ( element = prev.element; element && element != next.element; element = element->lo_any.next) { if ( lo_IsHardBreak2(context, element, 0) ) { return FALSE; } } return TRUE; } return FALSE; } /* For logical navigation (e.g. next / prev word, character, paragraph) this function * performs all the book keeping to implement extension vs. moving the cursor. * * target - the unit of navigation -- the word / character that is selected. * bSelect - true if the current selection is to be extended. * bDeselecting - true if there used to be a selection, but it's going away. * bForward - true if the end of the target is to be used. * */ /* Compute new position */ Bool LO_ComputeNewPosition( MWContext *context, intn chunkType, Bool bSelect, Bool bDeselecting, Bool bForward, LO_Element** pElement, int32* pPosition ) { lo_TopState* top_state; lo_DocState *state; LO_Position wordEdge; LO_Position caret; Bool result = TRUE; /* LO_DUMP_SELECTIONSTATE(context); */ /* * Get the unique document ID, and retreive this * documents layout state. */ top_state = lo_FetchTopState(XP_DOCID(context)); if ((top_state == NULL)||(top_state->doc_state == NULL)) { return FALSE; } state = top_state->doc_state; if ( ! pElement || ! pPosition ) return FALSE; caret.element = *pElement; caret.position = *pPosition; wordEdge = caret; switch ( chunkType ) { case LO_NA_WORD: { Bool isLineEdge = lo_IsLineEdge(context, state, caret.element, caret.position, FALSE, bForward); Bool isHardBreak = lo_IsLineEdge(context, state, caret.element, caret.position, TRUE, bForward); if ( isLineEdge && bDeselecting ) break; if ( lo_IsEdgeOfDocument(context, state, &caret, bForward) ) { lo_FindDocumentEdge(context, state, &caret, bSelect, bForward); wordEdge = caret; } else { if ( isLineEdge ) { Bool bOverEdge = caret.element->type == LO_LINEFEED && caret.position > 0; lo_MoveToNearestEdgeOfNextLine(context, state, &caret, bForward); wordEdge = caret; if ( isHardBreak ) { if ( bSelect && bOverEdge && bForward ) { /* If the next line is a single line feed. */ if ( lo_GetElementLength(caret.element) == 0 ) { lo_BumpEditablePosition(context, state, &caret.element, &caret.position, bForward); wordEdge = caret; } else { lo_BumpEditablePosition(context, state, &caret.element, &caret.position, bForward); lo_FindChunkEdge(context, state, &caret, &wordEdge, chunkType, bSelect, bForward); } } } else { lo_FindChunkEdge(context, state, &caret, &wordEdge, chunkType, bSelect, bForward); } } else { if ( isLineEdge && ! bSelect ) { if ( isHardBreak ) { wordEdge = caret; } else { lo_FindChunkEdge(context, state, &caret, &wordEdge, chunkType, bSelect, bForward); } } else { /* If we're at the beginning of a word, and we are searching backwards, * we want the word before the word we're currently on. */ if ( ! bDeselecting && !isLineEdge && !bForward ) { lo_BumpEditablePosition(context, state, &caret.element, &caret.position, bForward); } lo_FindChunkEdge(context, state, &caret, &wordEdge, chunkType, bSelect, bForward); } } } } break; case LO_NA_CHARACTER: { Bool isLineEdge; /* Special rule: If navigating by unselected character, and there is a selection, then the * result is the edge in the direction of travel. */ if ( bDeselecting ) { break; } isLineEdge = lo_IsLineEdge(context, state, caret.element, caret.position, FALSE, bForward); if ( isLineEdge ) { Bool bDoubleGap = lo_GapWithBothSidesAllowed(context, state, &caret); result = lo_MoveToNearestEdgeOfNextLine(context, state, &caret, bForward); if ( ! result && bSelect && bForward ) { /* End of document case. Allowed to select the paragraph. */ lo_FindDocumentEdge(context, state, &caret, TRUE, TRUE); result = TRUE; } else if ( ! result ) { return FALSE; } else { /* If we are shift-selecting an hrule, bump an extra position, because the pseudo-position before and after an hrule doesn't really exist. */ if ( result && bSelect && bDoubleGap ) { result = lo_BumpEditablePosition(context, state, &caret.element, &caret.position, bForward); if ( ! result ) { /* End of document */ lo_FindDocumentEdge(context, state, &caret, bSelect, bForward); result = TRUE; } } } result = TRUE; /* Bogus -- should remove. */ wordEdge = caret; } else { /* If we are searching backwards, * we want the character before the character we're currently on. */ result = TRUE; if ( !bForward ) { result = lo_BumpEditablePosition(context, state, &caret.element, &caret.position, bForward); } if ( result ) { result = lo_FindChunkEdge(context, state, &caret, &wordEdge, chunkType, bSelect, bForward); } } } break; default: { result = lo_FindChunkEdge(context, state, &caret, &wordEdge, chunkType, bSelect, bForward); } break; } result = result && (bDeselecting || wordEdge.element != *pElement || wordEdge.position != *pPosition); if ( result ){ *pElement = wordEdge.element; *pPosition = wordEdge.position; } return result; } /* * Find the next or previous word and possibly extend the selection. */ Bool LO_NavigateChunk( MWContext *context, intn chunkType, Bool bSelect, Bool bForward ) { lo_TopState* top_state; lo_DocState *state; LO_Position caret; LO_Element *element; int32 position; Bool bSelectionExists; Bool bDeselecting; Bool bResult; /* LO_DUMP_SELECTIONSTATE(context); */ /* * Get the unique document ID, and retreive this * documents layout state. */ top_state = lo_FetchTopState(XP_DOCID(context)); if ((top_state == NULL)||(top_state->doc_state == NULL)) { return FALSE; } state = top_state->doc_state; bSelectionExists = state->selection_new == NULL; bDeselecting = bSelectionExists && ! bSelect; if ( bSelectionExists ) { /* There is no insert point. Use the extension point. */ if ( bSelect ) { lo_GetExtensionPoint(context, state, &element, &position); } else { lo_GetSelectionEdge(context, state, &element, &position, bForward); } } else { element = state->selection_new; position = state->selection_new_pos; } bResult = LO_ComputeNewPosition(context, chunkType, bSelect, bDeselecting, bForward, &element, &position); if ( bResult ) { caret.element = element; caret.position = position; if ( bSelect ) { lo_ExtendSelectionToPosition2(context, top_state, state, caret.element, caret.position); } else { if ( ! lo_EnsureEditableSearch(context, state, &caret, bForward) ) { /* Off the edge of the world. */ lo_EnsureEditableSearch(context, state, &caret, !bForward); } lo_SetInsertPoint(context, top_state, caret.element, caret.position, state->selection_layer); } } return bResult; } void LO_GetEffectiveCoordinates( MWContext *pContext, LO_Element *pElement, int32 position, int32* pX, int32* pY, int32* pWidth, int32* pHeight ) { *pY = pElement->lo_any.y + pElement->lo_any.y_offset; *pX = pElement->lo_any.x + pElement->lo_any.x_offset; *pWidth = pElement->lo_any.width; *pHeight = pElement->lo_any.height; switch ( pElement->type ) { case LO_IMAGE: *pWidth += 2 * pElement->lo_image.border_width; *pHeight += 2 * pElement->lo_image.border_width; if ( position > 0 ) { *pX = *pX + *pWidth; } break; case LO_TEXT: { int32 start = LO_TextElementWidth( pContext, (LO_TextStruct*)pElement, position); *pX += start; } break; case LO_HRULE: /* The effective y and height is the height of the following linefeed. */ { LO_Element* pNext = pElement->lo_any.next; if ( pNext && pNext->type == LO_LINEFEED ) { int32 dummyWidth; int32 dummyX; LO_GetEffectiveCoordinates(pContext, pNext, 0, &dummyX, pY, &dummyWidth, pHeight); } if ( position > 0 ) { *pX = *pX + *pWidth; } } break; case LO_LINEFEED: { if ( position > 0 ) { /* At start of next element. */ LO_Element* pNext = pElement->lo_any.next; if ( pNext ) { /* Just one level of recursion, since position = 0 */ LO_GetEffectiveCoordinates(pContext, pNext, 0, pX, pY, pWidth, pHeight); } } } break; default: break; } } PRIVATE Bool lo_FindClosestUpDown(MWContext *pContext, lo_DocState* state, int32 x, int32 y, Bool bForward, int32* ret_x, int32* ret_y) { int32 iLine; Bool bFound = FALSE; lo_TopState* top_state = lo_FetchTopState(XP_DOCID(pContext)); if ((top_state == NULL)||(top_state->doc_state == NULL)) { return FALSE; } /* find the line we are currently on */ iLine = lo_PointToLine( pContext, state, x, y ); if ( bForward ) { int32 maxLine; /* Down. MaxLine is - 2 for the lines data structure */ maxLine = state->line_num - 2; if ( EDT_IS_EDITOR(pContext) && top_state->doc_state == state ) { maxLine -= 2; /* and -2 for the phantom end-of-doc hrule*/ } for( ; iLine <= maxLine && !bFound; iLine++) { bFound = lo_FindBestPositionOnLine( pContext, state, iLine, x, y, bForward, ret_x, ret_y ); } } else { /* Up */ /*changed iline comparisson to include 0. is this correct? uparrow was not working*/ for( ; iLine >= 0 && !bFound; --iLine) { bFound = lo_FindBestPositionOnLine( pContext, state, iLine, x, y, bForward, ret_x, ret_y ); } } return bFound; } /* * Find a element up from this and set the cursor there. */ void LO_UpDown( MWContext *pContext, LO_Element *pElement, int32 position, int32 iDesiredX, Bool bSelect, Bool bForward ) { #ifdef EDITOR lo_TopState* top_state; lo_DocState *state; int32 x, y, width, height; Bool bFound = FALSE; LO_Element *pNext;/*used to look ahead for correct y*/ /* * Get the unique document ID, and retreive this * documents layout state. */ top_state = lo_FetchTopState(XP_DOCID(pContext)); if ((top_state == NULL)||(top_state->doc_state == NULL)) { return; } state = top_state->doc_state; /* Special case. If the element is a linefeed and the position is 1, * we have to move the cursor to the next element. */ if ( pElement && pElement->type == LO_LINEFEED && position > 0 ) { LO_Element* pNext = pElement->lo_linefeed.next; if ( pNext ) { pElement = pNext; position = 0; } } { LO_Position p; p.element = pElement; p.position = position; if ( lo_IsEdgeOfDocument(pContext, state, &p, bForward) ) { LO_NavigateChunk( pContext, LO_NA_DOCUMENT, bSelect, bForward); return; } } /* Find the effective coordinate of our current position */ LO_GetEffectiveCoordinates(pContext, pElement, position, &x, &y, &width, &height); /* Skip over this element */ pNext=NULL; /*if not forward, let the old way handle it.*/ if (bForward) { pNext=pElement->lo_any.next; while (pNext && (pNext->type!=LO_CELL) && (!lo_ValidEditableElement(pContext,pNext) || (pNext->lo_any.y == pElement->lo_any.y)) ) pNext=pNext->lo_any.next; /*if we find a cell, we will need more work.*/ if (pNext) y=pNext->lo_any.y; } if (!pNext) { if ( bForward) { y = pElement->lo_any.y + pElement->lo_any.line_height; } else { y = pElement->lo_any.y - 1; } } bFound = lo_FindClosestUpDown(pContext, state, iDesiredX, y, bForward, &x, &y); /* We found a text element on this line. Now, lets re-scan the line for * the best fit. */ if( bFound ){ if( bSelect ){ EDT_ExtendSelection( pContext, x, y ); EDT_EndSelection( pContext, x, y ); } else { LO_PositionCaret( pContext, x, y, NULL ); } } else { /* No more elements. */ /* Navigate to the edge of the document. */ LO_NavigateChunk( pContext, LO_NA_DOCUMENT, bSelect, bForward); } #endif } /* like lo_search_element_list, but matches nearest X */ LO_Element * lo_search_element_list_WideMatch(MWContext *context, LO_Element *eptr, LO_Element* eEndPtr, int32 x, int32 y, Bool bForward) { LO_Element* pFound = NULL; int32 bestDistanceX = 2000000; int32 bestDistanceY = 2000000; int32 distanceY; for ( ; eptr != eEndPtr && eptr != NULL; eptr = eptr->lo_any.next ) { int32 width, height; if( eptr->type != LO_CELL && eptr->type != LO_TABLE && ! lo_ValidEditableElementIncludingParagraphMarks(context, eptr)){ continue; } width = eptr->lo_any.width; /* * Images need to account for border width */ if (eptr->type == LO_IMAGE) { width = width + (2 * eptr->lo_image.border_width); } if (width <= 0) { width = 1; } height = eptr->lo_any.height; /* * Images need to account for border height */ if (eptr->type == LO_IMAGE) { height = height + (2 * eptr->lo_image.border_width); } distanceY = bestDistanceY + 1; if ( y < eptr->lo_any.y ) { /* This element is below the target. Consider it if we're searching forward. */ if ( bForward ) { distanceY = eptr->lo_any.y - y; } } else if ( eptr->lo_any.y + eptr->lo_any.y_offset + height <= y ) { /* This element is above the target. Consider it if we're searching backwards. */ if ( ! bForward ) { distanceY = y - (eptr->lo_any.y + eptr->lo_any.y_offset + height) + 1; } } else { distanceY = 0; } if ( distanceY <= bestDistanceY ) { if ( distanceY < bestDistanceY ) { /* We have a new winner in Y, so forget our X */ bestDistanceX = 2000000; bestDistanceY = distanceY; } /* We're looking for the closest match */ if ((x < (eptr->lo_any.x + eptr->lo_any.x_offset + width))&&(x >= eptr->lo_any.x)) { /* Can't get closer than containing. */ pFound = eptr; bestDistanceX = 0; if ( distanceY == 0 ) { break; } } else { int32 distance; if ( x < eptr->lo_any.x ) { distance = eptr->lo_any.x - x; } else { distance = x - (eptr->lo_any.x + eptr->lo_any.x_offset + width) + 1; } if ( distance < bestDistanceX ) { pFound = eptr; bestDistanceX = distance; } } } /* Skip over cells while searchig for the closest item */ if (eptr->type == LO_TABLE) { while ( eptr->lo_any.next && eptr->lo_any.next->type == LO_CELL ) { eptr = eptr->lo_any.next; } } } return pFound; } PRIVATE Bool lo_FindClosestUpDown_SubDoc(MWContext *pContext, lo_DocState* state, LO_SubDocStruct* pSubdoc, int32 x, int32 y, Bool bForward, int32* ret_x, int32* ret_y) { /* Cribbed from the end of lo_XYToDocumentElement2 */ int32 new_x, new_y; new_x = x - (pSubdoc->x + pSubdoc->x_offset + pSubdoc->border_width); new_y = y - (pSubdoc->y + pSubdoc->y_offset + pSubdoc->border_width); return lo_FindClosestUpDown(pContext, (lo_DocState *)pSubdoc->state, new_x, new_y, bForward, ret_x, ret_y); } Bool lo_FindClosestUpDown_Cell(MWContext *pContext, lo_DocState* state, LO_CellStruct* cell, int32 x, int32 y, Bool bForward, int32* ret_x, int32* ret_y) { /* Cells don't have line arrays. So we linearly search for our element. * This code was inspired by the code in lo_search_element_list and * lo_XYToCellElement */ LO_Element *eptr; LO_Element *element; eptr = cell->cell_list; element = lo_search_element_list_WideMatch(pContext, eptr, NULL, x, y, bForward); if (element == NULL) { eptr = cell->cell_float_list; element = lo_search_element_list_WideMatch(pContext, eptr, NULL, x, y, bForward); } if ((element != NULL)&&(element->type == LO_SUBDOC)) { return lo_FindClosestUpDown_SubDoc(pContext, state, (LO_SubDocStruct *)element, x, y, bForward, ret_x, ret_y); } else if ((element != NULL)&&(element->type == LO_CELL)) { return lo_FindClosestUpDown_Cell(pContext, state, (LO_CellStruct *)element, x, y, bForward, ret_x, ret_y); } else if ((element != NULL)&&(element->type == LO_TABLE)) { if ( lo_FindBestPositionInTable(pContext, state, (LO_TableStruct *)element, x, y, bForward, ret_x, ret_y) ) return TRUE; else { /* no more stuff in the table. Skip out of the table and try again. */ if ( bForward ) { y = element->lo_table.y + element->lo_table.y_offset + element->lo_table.height; } else { y = element->lo_table.y - 1; } /* Tail recursion. Maybe we should use goto? */ return lo_FindClosestUpDown_Cell(pContext, state, cell, x, y, bForward, ret_x, ret_y); } } else if (element != NULL) { /* Return this element's Y. */ int32 eHeight; int32 eWidth; int32 eX; int32 eY; LO_GetEffectiveCoordinates(pContext, element, 0, &eX, &eY, & eWidth, &eHeight); /* Clip x to be inside the bounds of the element */ if ( x >= eX + eWidth ) x = eX + eWidth - 1; if ( x < eX ) x = eX; *ret_x = x; *ret_y = eY; return TRUE; } else return FALSE; } PRIVATE LO_CellStruct* lo_FindBestCellInTable(MWContext *context, lo_DocState* state, LO_TableStruct* pTable, int32 iDesiredX, int32 iDesiredY, Bool bForward ) { /* Find end of table */ LO_Element* pClosest = NULL; LO_CellStruct* result = NULL; if ( pTable ) { LO_Element* pStart = pTable->next; LO_Element* pEnd = pStart; while ( pEnd && pEnd->type == LO_CELL ) { pEnd = pEnd->lo_any.next; } if ( pStart ) { pClosest = lo_search_element_list_WideMatch(context, pStart, pEnd, iDesiredX, iDesiredY, bForward); if ( pClosest && pClosest->type == LO_CELL ) { return result = &pClosest->lo_cell; } } } return result; } Bool lo_FindBestPositionInTable(MWContext *context, lo_DocState* state, LO_TableStruct* pTable, int32 iDesiredX, int32 iDesiredY, Bool bForward, int32* pRetX, int32 *pRetY ) { /* Up/Down can skip over cell boundaries. So we may have to search in two cells, the one * we started in, and the next one in the direction we're searching. * For simplicity, we search a cell, and if we don't hit anything, we bump the * y coordinate by the cell height, and search again. */ while(1) { LO_CellStruct* pCell = lo_FindBestCellInTable(context, state, pTable, iDesiredX, iDesiredY, bForward); if ( ! pCell ) return FALSE; if ( lo_FindClosestUpDown_Cell(context, state, pCell, iDesiredX, iDesiredY, bForward, pRetX, pRetY) ) { return TRUE; } /* Search the next cell */ if ( ! bForward ) { iDesiredY = pCell->y - 1; } else { iDesiredY = pCell->y + pCell->y_offset + pCell->height; } } } Bool lo_FindBestPositionOnLine(MWContext *context, lo_DocState* state, int32 iLine, int32 iDesiredX, int32 iDesiredY, Bool bForward, int32* pRetX, int32 *pRetY ) { LO_Element **line_array; LO_Element *pElement, *pEnd; LO_Element *pFound = NULL; Bool bDone = FALSE; XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array); if( iLine == state->line_num - 2 ){ pEnd = 0; } else { pEnd = line_array[iLine+1]; } pElement = line_array[iLine]; XP_UNLOCK_BLOCK(state->line_array); if ( pElement->type == LO_TABLE ) { return lo_FindBestPositionInTable(context, state, & pElement->lo_table, iDesiredX, iDesiredY, bForward, pRetX, pRetY); } for( ; pElement != pEnd && !bDone; pElement = pElement->lo_any.next){ if( lo_ValidEditableElementIncludingParagraphMarks(context, pElement)){ if( pFound ){ /* what is desired is before the element, take the absolute * value of the distance between the two elements */ if( iDesiredX < pElement->lo_any.x ){ if( pElement->lo_any.x - iDesiredX < iDesiredX - (*pRetX) ){ *pRetX = pElement->lo_any.x; *pRetY = pElement->lo_any.y; pFound = pElement; } bDone = TRUE; } else if( iDesiredX < pElement->lo_any.x + pElement->lo_any.width ) { *pRetY = pElement->lo_any.y; *pRetX = iDesiredX; pFound = pElement; bDone = TRUE; } else { *pRetX = iDesiredX; /* *pRetX = pElement->lo_any.x + pElement->lo_any.width; */ *pRetY = pElement->lo_any.y; pFound = pElement; } } else { if( iDesiredX < pElement->lo_any.x ){ *pRetX = pElement->lo_any.x; *pRetY = pElement->lo_any.y; bDone = TRUE; } else if( iDesiredX < pElement->lo_any.x + pElement->lo_any.width ) { *pRetY = pElement->lo_any.y; *pRetX = iDesiredX; bDone = TRUE; } else { *pRetX = iDesiredX; /* *pRetX = pElement->lo_any.x + pElement->lo_any.width; */ *pRetY = pElement->lo_any.y; } pFound = pElement; } } } if ( pFound && pFound->type == LO_CELL ) { return lo_FindClosestUpDown_Cell(context, state, &pFound->lo_cell, iDesiredX, iDesiredY, bForward, pRetX, pRetY); } else if ( pFound && pFound->type == LO_SUBDOC ) { return lo_FindClosestUpDown_SubDoc(context, state, &pFound->lo_subdoc, iDesiredX, iDesiredY, bForward, pRetX, pRetY); } return pFound != NULL; } ED_Buffer* LO_GetEDBuffer( MWContext *context) { #ifdef EDITOR int32 doc_id; lo_TopState *top_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 NULL; } return top_state->edit_buffer; #else return 0; #endif } /* #endif */ /* * Given a Text element and a character offset, find the width of upto that * offset. */ int32 LO_TextElementWidth(MWContext *context, LO_TextStruct *text_ele, int charOffset) { LO_TextInfo text_info; int orig_len; int32 retval; if ((text_ele->text == NULL)||(text_ele->text_len <= 0)) { return(0); } orig_len = text_ele->text_len; text_ele->text_len = charOffset; FE_GetTextInfo(context, text_ele, &text_info); retval = text_info.max_width; text_ele->text_len = orig_len; return retval; } #ifdef TEST_16BIT #undef XP_WIN16 #endif /* TEST_16BIT */ #ifdef PROFILE #pragma profile off #endif /* #ifndef NO_TAB_NAVIGATION */ /* Arthur Liu, 9/13/96 Reading through this file, I found LO_getDocState() should be a separate function. TODO, check this file(may be also other files), to replace the duplicated code with this function. */ PRIVATE lo_DocState * LO_getDocState(MWContext *context) { int32 doc_id; lo_TopState *top_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 NULL ; } return( top_state->doc_state ); } /* Arthur Liu, 9/13/96 LO_getFirstLastElement() was created for Keyboard Navigation. TODO: Its function is a subset of lo_FindDocumentEdge(..), and the latter may call LO_getFirstLastElement() to avoid code duplication. */ LO_Element * LO_getFirstLastElement(MWContext *context, int forward ) { lo_DocState *state; LO_Element **array; LO_Element* eptr; #ifdef XP_WIN16 XP_Block *larray_array; #endif /* XP_WIN16 */ if( NULL == ( state = LO_getDocState(context) ) ) return( NULL ); /* * Nothing to select. */ if (state->line_num <= 1) { return NULL ; } if ( ! forward ) { /* * Get last element in doc. */ eptr = state->end_last_line; if (eptr == NULL) { eptr = state->selection_start; /* ??? */ } } else /* wantFirst */ { /* * Get first element in doc. */ #ifdef XP_WIN16 XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array); state->line_array = larray_array[0]; XP_UNLOCK_BLOCK(state->larray_array); #endif /* XP_WIN16 */ XP_LOCK_BLOCK(array, LO_Element **, state->line_array); eptr = array[0]; XP_UNLOCK_BLOCK(state->line_array); /* * No elements. */ if (eptr == NULL) { return NULL ; } } return( eptr ); } /* LO_getFirstLastElement() */ /* return TRUE if pCurrentFocus->pElement is a tabable element, may also fill in pCurrentFocus->pAnchor, and pCurrentFocus->mapAreaIndex */ Bool LO_isTabableElement(MWContext *context, LO_TabFocusData *pCurrentFocus ) { /* For all LO_ types which update status bar, see CWinCX::OnMouseMoveForLayerCX(UINT uFlags, CPoint& cpPoint, for all links see CWinCX::OnLButtonUpForLayerCX(UINT uFlags, CPoint& cpPoint, XY& Point, */ Bool bIsTabable; LO_TextStruct *pText; LO_ImageStruct *pImage; lo_MapAreaRec *tempArea; LO_Element *pElement; LO_FormElementStruct *formEleStruct; if( pCurrentFocus == NULL ) return( FALSE ); pCurrentFocus->mapAreaIndex = 0; /* no area */ pCurrentFocus->pAnchor = NULL; pElement = pCurrentFocus->pElement; if( pElement == NULL ) return( FALSE ); bIsTabable = FALSE; switch( pElement->type ) { case LO_NONE : /* 0 */ break; case LO_TEXT : /* 1 */ pText = (LO_TextStruct *) pElement; if( pText ) bIsTabable = (pText->anchor_href && pText->anchor_href->anchor); if( bIsTabable ) pCurrentFocus->pAnchor = pText->anchor_href; break; case LO_LINEFEED : /* 2 */ break; case LO_HRULE : /* 3 */ break; case LO_IMAGE : /* 4 */ pImage = ( LO_ImageStruct *) pElement; /* first test image with a link */ bIsTabable = (pImage->anchor_href != NULL) && (pImage->anchor_href->anchor != NULL); if( bIsTabable ) { pCurrentFocus->pAnchor = pImage->anchor_href; break; } /* test use map */ tempArea = LO_getTabableMapArea(context, pImage, 1 ); /* 1 means get the first */ if( tempArea != NULL ) { pCurrentFocus->mapAreaIndex = 1; /* the first area */ pCurrentFocus->pAnchor = tempArea->anchor; bIsTabable = TRUE; } break; case LO_BULLET : /* 5 */ break; case LO_FORM_ELE : /* 6 */ /*TODO get anchor for buttons...*/ formEleStruct = (LO_FormElementStruct *) pElement; if( formEleStruct ) bIsTabable = LO_isTabableFormElement( formEleStruct ); break; case LO_SUBDOC : /* 7 */ break; case LO_TABLE : /* 8 */ break; case LO_CELL : /* 9 */ break; case LO_EMBED : /* 10 */ break; case LO_EDGE : /* 11 */ break; #ifdef JAVA case LO_JAVA : /* 12 */ break; #endif case LO_SCRIPT : /* 13 */ break; default : /* something wrong!! */ bIsTabable = FALSE; break; } return( bIsTabable ); } /* get first(last) if current element is NULL. */ Bool LO_getNextTabableElement( MWContext *context, LO_TabFocusData *pCurrentFocus, int forward ) { lo_DocState *state; LO_Element *currentElement; lo_MapAreaRec *tempArea; LO_AnchorData *pLastAnchorData; if( NULL == ( state = LO_getDocState(context) ) ) return( FALSE ); /* A text may have been fragmented into multiple lines because the text folding. If last tab focus is a LO_Text, remember its anchor to skip continuious text fragments. When the focus is drawn, all continuious fragments will hav efocus, See CWinCX::setTextTabFocusDrawFlag() in cmd\winfe\cxwin.cpp file. */ pLastAnchorData = NULL; /* assuming no need to skip continuious text fragments. */ currentElement = pCurrentFocus->pElement; /* find the first candidate, */ if( currentElement == NULL ) { /* find the first(last) element in the Doc as candidate, */ pCurrentFocus->pElement = LO_getFirstLastElement( context, forward ); /* forward is getting first */ /*TODO go down to cell_list if pElement has subtree */ } else { if( pCurrentFocus->pElement->lo_any.type == LO_TEXT ) pLastAnchorData = pCurrentFocus->pAnchor; /* need to skip continuious text fragments. */ /* if the last element is a image map, try go to next area in the map */ if( currentElement->lo_any.type == LO_IMAGE ) { if( forward ) { pCurrentFocus->mapAreaIndex++; tempArea = LO_getTabableMapArea(context, (LO_ImageStruct *)currentElement, pCurrentFocus->mapAreaIndex ); if( tempArea ) { pCurrentFocus->pAnchor = tempArea->anchor; return( TRUE ); } } else { /* if( forward ) */ pCurrentFocus->mapAreaIndex--; if( pCurrentFocus->mapAreaIndex > 0 ) { /* otherwise no need to search. */ tempArea = LO_getTabableMapArea(context, (LO_ImageStruct *)currentElement, pCurrentFocus->mapAreaIndex ); if( tempArea ) { pCurrentFocus->pAnchor = tempArea->anchor; return( TRUE ); } } } } /* advance the pointer, use the next(previous) as first candidate. pElement = lo_GetNeighbor( currentElement, forward); pElement = currentElement; */ lo_TraverseElement(context, state, &(pCurrentFocus->pElement), forward); } /*todo if not forward, get last area. */ pCurrentFocus->mapAreaIndex = 0; /* assumming no focus area */ pCurrentFocus->pAnchor = NULL; while ( pCurrentFocus->pElement != NULL ) { if( LO_isTabableElement(context, pCurrentFocus) ) { if( pLastAnchorData == NULL /* no need to skip continuious text fragments. */ || pCurrentFocus->pElement->lo_any.type != LO_TEXT || pLastAnchorData != pCurrentFocus->pAnchor ) return( TRUE ); /* else it is a text fragment with the same anchor as the last tabFocus text. In such case, continue search. */ } lo_TraverseElement(context, state, &(pCurrentFocus->pElement), forward); } return( FALSE ); } /* LO_getNextTabableElement */ /* NO_TAB_NAVIGATION */