BOOL CDRFilter::AddAttributesToArrowheadNode(NodeRenderableBounded *N, DocColour *Col, INT32 LineWidth,
LineCapType Cap, JointType Join)
{
if(IS_A(N, NodeGroup))
{
// go through all the members of the group setting their attributes
Node *pNode;
pNode = N->FindFirstChild();
while(pNode != 0)
{
if(IS_A(pNode, NodePath))
AddAttributesToArrowheadPath((NodePath *)pNode, Col, LineWidth, Cap, Join);
pNode = pNode->FindNext();
}
} else if(IS_A(N, NodePath))
{
// simply apply the attributes to this path
AddAttributesToArrowheadPath((NodePath *)N, Col, LineWidth, Cap, Join);
} else {
ERROR3("Something unexpected passed to AddAttributesToArrowheadNode");
}
return TRUE;
}
void NodeSimpleShape::PolyCopyNodeContents(NodeRenderable* pNodeCopy)
{
ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node");
ENSURE(IS_A(pNodeCopy, NodeSimpleShape), "PolyCopyNodeContents given wrong dest node type");
if (IS_A(pNodeCopy, NodeSimpleShape))
CopyNodeContents((NodeSimpleShape*)pNodeCopy);
}
void Chapter::PolyCopyNodeContents(NodeRenderable* pNodeCopy)
{
ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node");
ENSURE(IS_A(pNodeCopy, Chapter), "PolyCopyNodeContents given wrong dest node type");
if (IS_A(pNodeCopy, Chapter))
CopyNodeContents((Chapter*)pNodeCopy);
}
void NodeAnimatingBitmap::PolyCopyNodeContents(NodeRenderable* pNodeCopy)
{
ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node");
ENSURE(IS_A(pNodeCopy, NodeAnimatingBitmap), "PolyCopyNodeContents given wrong dest node type");
if (IS_A(pNodeCopy, NodeAnimatingBitmap))
CopyNodeContents((NodeAnimatingBitmap*)pNodeCopy);
}
void TemplateAttribute::PolyCopyNodeContents(NodeRenderable* pNodeCopy)
{
ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node");
ENSURE(IS_A(pNodeCopy, TemplateAttribute), "PolyCopyNodeContents given wrong dest node type");
if (IS_A(pNodeCopy, TemplateAttribute))
CopyNodeContents((TemplateAttribute*)pNodeCopy);
}
void AttrWebAddress::PolyCopyNodeContents(NodeRenderable* pNodeCopy)
{
ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node");
ENSURE(IS_A(pNodeCopy, AttrWebAddress), "PolyCopyNodeContents given wrong dest node type");
if (IS_A(pNodeCopy, AttrWebAddress))
CopyNodeContents((AttrWebAddress*)pNodeCopy);
}
OpState OpBreakAtPoints::GetState(String_256* UIDescription, OpDescriptor*)
{
OpState OpSt;
String_256 DisableReason;
OpSt.Greyed = FALSE;
BOOL FoundSelected = FALSE;
// Go through the selection until we find a selected point
SelRange* Selected = GetApplication()->FindSelection();
Node* pNode = Selected->FindFirst();
while (pNode)
{
if (IS_A(pNode,NodePath) || IS_A(pNode,NodeBlendPath))
{
NodePath* pNodePath = (NodePath*)pNode;
INT32 NumSplinters = pNodePath->InkPath.NumSplinters();
if (NumSplinters > 0)
{
// We need to ask the effected nodes if they (and their parents) can handle this node being replaced
ObjChangeFlags cFlags;
if (NumSplinters > 1)
cFlags.MultiReplaceNode = TRUE; // Node will be replaced with more than one node.
else
cFlags.ReplaceNode = TRUE; // Node will be replaced with one node only.
String_32 optokenstring(OPTOKEN_BREAKATPOINTS);
ObjChangeParamWithToken ObjChange(OBJCHANGE_STARTING,cFlags,pNodePath,NULL,&optokenstring);
// Will the node allow this op to happen?
if (pNodePath->AllowOp(&ObjChange,FALSE))
{
FoundSelected = TRUE;
break;
}
}
}
pNode = Selected->FindNext(pNode);
}
// The operation is disabled if there are no complex paths selected
if (!FoundSelected)
{
OpSt.Greyed = TRUE;
DisableReason = String_256(_R(IDS_NEEDS_SELECTED_POINT));
*UIDescription = DisableReason;
}
return(OpSt);
}
UINT32 GalleryLineDragInfo::GetCursorID(DragTarget* pDragTarget)
{
if (pDragTarget && pDragTarget->IS_KIND_OF(ViewDragTarget))
{
PageDropInfo PageDropInfo;
((ViewDragTarget*)pDragTarget)->GetDropInfo(&PageDropInfo);
NodeRenderableInk* pObjectHit = PageDropInfo.pObjectHit;
ObjectDragTarget TargetHit = PageDropInfo.TargetHit;
if (IS_A(pAttr, AttrStartArrow) || IS_A(pAttr, AttrEndArrow))
{
if (pObjectHit && pObjectHit->IS_KIND_OF(NodePath))
{
Path* pPath = &((NodePath*)pObjectHit)->InkPath;
BOOL IsStart;
if (DropStartOrEndArrow(pPath, PageDropInfo.DropPos, &IsStart))
{
TargetHit = IsStart ? STARTCOL_TARGET : ENDCOL_TARGET;
}
}
}
ClickModifiers ClickMods = ClickModifiers::GetClickModifiers();
BOOL IsInside = ClickMods.Constrain;
if (!IsInside && pObjectHit && pObjectHit->IsCompound())
{
TargetHit = MANY_TARGET;
}
switch (TargetHit)
{
case FILL_TARGET:
return IsInside ? _R(IDC_DROPINSIDEONLINE) : _R(IDC_CANDROPONLINE);
case LINE_TARGET:
return IsInside ? _R(IDC_DROPINSIDEONLINE) : _R(IDC_CANDROPONLINE);
case STARTCOL_TARGET:
return IsInside ? _R(IDC_DROPINSIDEONFILLSTART) : _R(IDC_CANDROPONFILLSTART);
case ENDCOL_TARGET:
return IsInside ? _R(IDC_DROPINSIDEONFILLEND) : _R(IDC_CANDROPONFILLEND);
case MANY_TARGET:
return IsInside ? _R(IDC_DROPINSIDEONLINE) : _R(IDC_CANDROPONLINE);
case NO_TARGET:
return _R(IDC_CANDROPONPAGE);
default:
break;
};
return _R(IDC_CANDROPONPAGE);
}
return _R(IDC_CANTDROP);
}
BOOL OpBackground::GetPageColour(Spread *pSpread, KernelBitmap **ppOutBitmap,
DocColour **ppOutColour)
{
ERROR2IF(pSpread == NULL,FALSE,"OpBackground::GetPageColour Bad params error!");
ERROR2IF(ppOutBitmap == NULL || ppOutColour == NULL,FALSE,"OpBackground::GetPageColour Bad params error!");
// Search for our special page background layer
Layer* pFoundLayer = pSpread->FindFirstPageBackgroundLayer();
if (pFoundLayer == NULL)
return FALSE;
// search for our page node
NodeRegularShape *pNode = DoFindPageRectangle(pSpread, pFoundLayer);
if (!pNode)
return FALSE;
// find the fill attribute applied to the page
NodeAttribute *pAppliedAttr = NULL;
pNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pAppliedAttr);
if (pAppliedAttr != NULL)
{
if (IS_A(pAppliedAttr, AttrFlatColourFill)) // flat colour fill?
{
// get the colour attribute
ColourFillAttribute *pColAttr = (ColourFillAttribute *)(pAppliedAttr->GetAttributeValue());
// set the colour pointer to the doc colour, and the bitmap pointer to NULL
*ppOutBitmap = NULL;
*ppOutColour = pColAttr->GetStartColour();
}
else if (IS_A(pAppliedAttr, AttrBitmapColourFill)) // bitmap fill
{
// set the colour pointer to NULL, and the bitmap pointer to the kernel bitmap
*ppOutBitmap = ((AttrFillGeometry *)pAppliedAttr)->GetBitmap();
*ppOutColour = NULL;
}
else
return FALSE;
}
else
return FALSE;
return TRUE;
}
NodeAttribute* GalleryLineDragInfo::MakeStartOrEndArrow(NodeAttribute* pArrowAttr, BOOL Start)
{
ArrowRec Arrow;
NodeAttribute* NewAttr;
if (IS_A(pArrowAttr, AttrStartArrow))
{
Arrow = ((AttrStartArrow*)pArrowAttr)->Value.StartArrow;
}
else
{
Arrow = ((AttrEndArrow*)pArrowAttr)->Value.EndArrow;
}
if (Start)
{
NewAttr = new AttrStartArrow();
((AttrStartArrow*)NewAttr)->Value.StartArrow = Arrow;
}
else
{
NewAttr = new AttrEndArrow();
((AttrEndArrow*)NewAttr)->Value.EndArrow = Arrow;
}
delete pArrowAttr;
return NewAttr;
}
/*
* set_cheapest
* Find the minimum-cost paths from among a relation's paths,
* and save them in the rel's cheapest-path fields.
*
* This is normally called only after we've finished constructing the path
* list for the rel node.
*
* If we find two paths of identical costs, try to keep the better-sorted one.
* The paths might have unrelated sort orderings, in which case we can only
* guess which might be better to keep, but if one is superior then we
* definitely should keep it.
*/
void
set_cheapest(rel_optmz_info_n *parent_rel)
{
struct list* pathlist = parent_rel->pathlist;
struct list_cell* p;
path_n* cheapest_startup_path;
path_n* cheapest_total_path;
ASSERT(IS_A(parent_rel, RelOptInfo));
if (pathlist == NIL)
elog(ERROR, "could not devise a query plan for the given query");
cheapest_startup_path = cheapest_total_path = (path_n *) linitial(pathlist);
for_each_cell(p, lnext(list_head(pathlist))) {
path_n* path = (path_n *) lfirst(p);
int cmp;
cmp = cmp_path_costs(cheapest_startup_path, path, STARTUP_COST);
if (cmp > 0
|| (cmp == 0
&& cmp_pathkeys(cheapest_startup_path->pathkeys,
path->pathkeys) == PATHKEYS_BETTER2))
cheapest_startup_path = path;
cmp = cmp_path_costs(cheapest_total_path, path, TOTAL_COST);
if (cmp > 0 ||
(cmp == 0 &&
cmp_pathkeys(cheapest_total_path->pathkeys,
path->pathkeys) == PATHKEYS_BETTER2))
cheapest_total_path = path;
}
// expand partial ref (it is ensured to be leaf by toposort), and eliminate nil rules
static void _expand_lex_def(struct ContextMap* context_map, Val name) {
Val curr;
bool found = ContextMap.find(context_map, name, &curr);
assert(found);
Val res = VAL_NIL;
for (; curr != VAL_NIL; curr = TAIL(curr)) {
if (IS_A(HEAD(curr), "RefPartialContext")) {
Val ref_name = AT(HEAD(curr), 0);
Val child_nodes;
bool found = ContextMap.find(context_map, ref_name, &child_nodes);
if (!found) {
COMPILE_ERROR("partial context not found: %.*s", (int)nb_string_byte_size(ref_name), nb_string_ptr(ref_name));
}
for (Val child_curr = child_nodes; child_curr != VAL_NIL; child_curr = TAIL(child_curr)) {
if (child_curr != VAL_NIL) {
res = nb_cons_new(child_curr, res);
}
}
}
}
// yes it allocs more, but necessary to keep the order consistent
ContextMap.insert(context_map, name, nb_cons_reverse(res));
}
void OpNudge::PerformMergeProcessing()
{
// Obtain a pointer to the operation history for the current document
OperationHistory* pOpHist = &pOurDoc->GetOpHistory();
// Ensure that we are the last operation added to the operation history
// Note cannot be an ERROR2 cos this function cannot fail.
ERROR3IF(pOpHist->FindLastOp() != this, "Last Op should be this op");
// OK lets see if the operation performed before this was an OpNudge operation
Operation* pPrevOp = pOpHist->FindPrevToLastOp();
if (pPrevOp != NULL) // Check if there was a previous op
{
if (IS_A(pPrevOp, OpNudge))
{
// Yes it was
// We can merge this op with pPrevOp if they both apply to the same set of objects
// This will be TRUE is their SelectionStates are the same.
RestoreSelectionsAction* pRestoreSelAct = (RestoreSelectionsAction*)
GetUndoActionList()->FindActionOfClass(CC_RUNTIME_CLASS(RestoreSelectionsAction));
ERROR3IF(pRestoreSelAct == NULL, "This op should have a RestoreSelectionsAction");
SelectionState* ThisOpsSelection = pRestoreSelAct->GetSelState();
pRestoreSelAct = (RestoreSelectionsAction*)
pPrevOp->GetUndoActionList()->FindActionOfClass(CC_RUNTIME_CLASS(RestoreSelectionsAction));
ERROR3IF(pRestoreSelAct == NULL, "OpNudge op should have a RestoreSelectionsAction");
SelectionState* LastOpsSelection = pRestoreSelAct->GetSelState();
if ((*ThisOpsSelection) == (*LastOpsSelection))
{
// scan to see if either of these ops hides a node
// if either do then we cannot merge them together
// this can happen if perhaps the extending definitions
// were changed by the nudge (sjk 27-7-00)
if (DoesActionListHideNodes(pPrevOp) || DoesActionListHideNodes(this) )
return;
// this op can be merged into the previous op, we simply need to combine the
// TransformNodeActions
TransformNodeAction* pTransNdAct = (TransformNodeAction*)
GetUndoActionList()->FindActionOfClass(CC_RUNTIME_CLASS(TransformNodeAction));
ERROR3IF(pTransNdAct == NULL, "This op should have a TransformNodeAction");
TransformNodeAction* pLastOpsTransNdAct = (TransformNodeAction*)
pPrevOp->GetUndoActionList()->FindActionOfClass(CC_RUNTIME_CLASS(TransformNodeAction));
ERROR3IF(pLastOpsTransNdAct == NULL,"OpNudgeOp should have a TransformNodeAction");
pLastOpsTransNdAct->CombineWith(pTransNdAct);
// This op is no longer required, so let's vape it
pOpHist->DeleteLastOp();
}
}
}
return;
}
BOOL GalleryLineDragInfo::OnPageDrop(ViewDragTarget* pDragTarget)
{
PageDropInfo PageDropInfo;
((ViewDragTarget*)pDragTarget)->GetDropInfo(&PageDropInfo);
NodeRenderableInk* pObjectHit = PageDropInfo.pObjectHit;
NodeAttribute* Attrib = SourceItem->CreateNewAttribute(IsAnAdjustDrag());
if (Attrib == NULL)
return FALSE;
if (pObjectHit && (IS_A(Attrib, AttrStartArrow) || IS_A(Attrib, AttrEndArrow)))
{
if (!pObjectHit->IS_KIND_OF(NodePath))
{
delete Attrib;
return FALSE;
}
Path* pPath = &((NodePath*)pObjectHit)->InkPath;
BOOL IsStart;
if (!DropStartOrEndArrow(pPath, PageDropInfo.DropPos, &IsStart))
{
delete Attrib;
return FALSE;
}
Attrib = MakeStartOrEndArrow(Attrib, IsStart);
}
if (pObjectHit)
{
// Hit a Line Object, so apply attribute to it
AttributeManager::ApplyAttribToNode(pObjectHit, Attrib);
}
else
{
// Didn't hit anything, so just set the current attribute
AttributeManager::AttributeSelected(Attrib);
}
return TRUE;
}
/*
* If we have a COUNT, and our input is a sort_pl node, notify it that it can
* use bounded sort. Also, if our input is a merge_append_pl, we can apply the
* same bound to any Sorts that are direct children of the merge_append_pl,
* since the merge_append_pl surely need read no more than that many tuples from
* any one input. We also have to be prepared to look through a result_pl,
* since the planner might stick one atop merge_append_pl for projection purposes.
*
* This is a bit of a kluge, but we don't have any more-abstract way of
* communicating between the two nodes; and it doesn't seem worth trying
* to invent one without some more examples of special communication needs.
*
* Note: it is the responsibility of nodeSort.c to react properly to
* changes of these parameters. If we ever do redesign this, it'd be a
* good idea to integrate this signaling with the parameter-change mechanism.
*/
static void
pass_down_bound(limit_ps *node, plan_state_n *child_node)
{
if (IS_A(child_node, SortState)) {
sort_ss *sortState;
int64 tuples_needed;
sortState = (sort_ss *) child_node;
tuples_needed = node->count + node->offset;
/* negative test checks for overflow in sum */
if (node->noCount || tuples_needed < 0) {
/* make sure flag gets reset if needed upon rescan */
sortState->bounded = false;
} else {
sortState->bounded = true;
sortState->bound = tuples_needed;
}
} else if (IS_A(child_node, MergeAppendState)) {
merge_append_ps *maState;
int i;
maState = (merge_append_ps *) child_node;
for (i = 0; i < maState->ms_nplans; i++)
pass_down_bound(node, maState->mergeplans[i]);
} else if (IS_A(child_node, ResultState)) {
/*
* An extra consideration here is that if the result_pl is projecting a
* targetlist that contains any SRFs, we can't assume that every input
* tuple generates an output tuple, so a sort_pl underneath might need to
* return more than N tuples to satisfy LIMIT N. So we cannot use
* bounded sort.
*
* If result_pl supported qual checking, we'd have to punt on seeing a
* qual, too. Note that having a resconstantqual is not a
* showstopper: if that fails we're not getting any rows at all.
*/
if (OUTER_PLAN_STATE(child_node) &&
!expr_returns_set((node_n *) child_node->plan->targetlist))
pass_down_bound(node, OUTER_PLAN_STATE(child_node));
}
}
/*
* xfrm_tgt_list()
* Turns a list of ResTarget's into a list of TargetEntry's.
*
* At this point, we don't care whether we are doing SELECT, INSERT,
* or UPDATE; we just transform the given expressions (the "val" fields).
*/
struct list* xfrm_tgt_list(parse_state_s* pstate, struct list* targetlist)
{
struct list *p_target = NIL;
struct list_cell *o_target;
foreach(o_target, targetlist) {
ResTarget *res = (ResTarget *) lfirst(o_target);
/*
* Check for "something.*". Depending on the complexity of the
* "something", the star could appear as the last field in ColumnRef,
* or as the last indirection item in A_Indirection.
*/
if (IS_A(res->val, ColumnRef)) {
column_ref_n *cref;
cref = (column_ref_n *) res->val;
if (IS_A(llast(cref->fields), A_Star)) {
/* It is something.*, expand into multiple items */
p_target = list_concat(p_target, ExpandColumnRefStar(pstate, cref, true));
continue;
}
} else if (IS_A(res->val, A_Indirection)) {
A_Indirection *ind;
ind = (A_Indirection*) res->val;
if (IS_A(llast(ind->indirection), A_Star)) {
/* It is something.*, expand into multiple items */
p_target = list_concat(p_target, ExpandIndirectionStar(pstate, ind, true));
continue;
}
}
/*
* Not "something.*", so transform as a single expression
*/
p_target = lappend(p_target, xfrm_tgt_entry(pstate, res->val, NULL, res->name, false));
}
BOOL Node::OptimiseAttributes()
{
Node* Current= this->FindFirstDepthFirst();
while (Current != NULL)
{
if (Current->IsCompound())
{
ENSURE(Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)), "Compound should be a NodeRenderableInk");
// It's a compound node, so factor out common attributes
// We don't want to attribute inside moulds (as yet)
if ( !((IS_A(Current, NodeMouldGroup)) || (IS_A(Current, NodeMoulder))) )
{
if (!((NodeRenderableInk*)Current)->FactorOutCommonChildAttributes())
{
return FALSE;
}
}
}
Current = Current->FindNextDepthFirst(this);
}
return TRUE;
}
BOOL WebAddressAttribute::Blend(BlendAttrParam *pBlendParam)
{
// Check entry param
ERROR3IF(pBlendParam == NULL,"NULL entry param");
if (pBlendParam == NULL) return FALSE;
WebAddressAttribute* pOtherWebAttr = (WebAddressAttribute*) pBlendParam->GetOtherAttrVal();
// Check that the other line attr val is not NULL, and is a WebAddressAttribute
ERROR3IF(pOtherWebAttr == NULL,"NULL other attr val");
ERROR3IF(!IS_A(pOtherWebAttr,WebAddressAttribute),"other attr val not a Web Address attr");
if (pOtherWebAttr == NULL || !IS_A(pOtherWebAttr,WebAddressAttribute)) return FALSE;
// If both attributes do not have a URL then we must return FALSE.
// Bug fix - Ranbirr 17/03/98
if(!this->HasURL() && !pOtherWebAttr->HasURL())
return FALSE;
// Get a new WebAddressAttribute to hold the blended version, (return FALSE if this fails)
WebAddressAttribute* pBlendedWebAttr = new WebAddressAttribute;
if (pBlendedWebAttr == NULL) return FALSE;
//If the blend ratio is less than 0.5, we use this WebAddressAttribute.
//Otherwise, we use the other WebAddressAttribute
double dRatio=pBlendParam->GetBlendRatio();
if (dRatio<0.5)
*pBlendedWebAttr=*this;
else
*pBlendedWebAttr=*pOtherWebAttr;
// Store the ptr to the new blended line width attr val
pBlendParam->SetBlendedAttrVal(pBlendedWebAttr);
return TRUE;
}
BOOL BitmapPreviewData::ExportBrowserTypeBitmap(KernelBitmap *pBmp,PathName *pOutFile)
{
ERROR3IF(pBmp == NULL, "NULL param passed in ExportPreviewBitmap");
ERROR3IF(pOutFile == NULL, "NULL param passed in ExportPreviewBitmap");
if ((pBmp == NULL) || (pOutFile == NULL))
return FALSE;
// create a disk file
CCDiskFile TempDiskFile(1024, FALSE, TRUE);
// Find the gif preview filter for export (so we don't get an options dialog box)
Filter *pFilter = Filter::GetFirst();
while (pFilter != NULL)
{
if (IS_A(pFilter,PreviewFilterGIF))
// This is the filter!
break;
// Try the next filter
pFilter = Filter::GetNext(pFilter);
}
if (pFilter == NULL)
return FALSE; // filter not found
// get the preview bitmap filter, so no dialog box is displayed
PreviewFilterGIF *pGIFFilter = (PreviewFilterGIF *)pFilter;
BOOL ok = TRUE;
// create an operation for the export
SelOperation *pOp = new SelOperation;
if (pOp != NULL)
{
ok = pGIFFilter->DoExportBitmap(pOp, &TempDiskFile, pOutFile, pBmp);
// delete the created operation
delete pOp;
}
else
return FALSE;
// close the file
if (TempDiskFile.isOpen())
TempDiskFile.close();
return ok;
}
/********************************************************************************************
> BOOL OpNudge::DoesActionListHideNodes(OpNudge * pOp)
Author: Simon_Knight (Xara Group Ltd) <*****@*****.**>
Created: 27/7/00
Inputs: ptr to the (nudge) operation
Outputs: -
Returns: TRUE if the action list for the op does a HideNodesAction
Purpose: To disallow the merging of nudge operations if a HideNodesAction was added
to this nudge op, as this wouldn't then undo correctly.
Errors: -
SeeAlso: -
********************************************************************************************/
BOOL OpNudge::DoesActionListHideNodes(Operation * pOp)
{
ActionList * pActions = pOp->GetUndoActionList();
ListItem* CurrentAction = pActions->GetHead();
while (CurrentAction != NULL) // For each action in the list
{
if (IS_A(CurrentAction, HideNodeAction))
return TRUE;
// Get next action
CurrentAction = pActions->GetNext(CurrentAction);
}
return FALSE;
}
/* --------------------------------
* exec_drop_single_tupslot
*
* Release a struct tupslot made with make_single_tupslot.
* DON'T use this on a slot that's part of a tuple table list!
* --------------------------------
*/
void
exec_drop_single_tupslot(struct tupslot *slot)
{
/* This should match exec_reset_tupslot's processing of one slot */
ASSERT(IS_A(slot, TupleTableSlot));
exec_clear_tuple(slot);
if (slot->tts_tupleDescriptor)
RELEASE_TUPLE_DESC(slot->tts_tupleDescriptor);
if (slot->tts_values)
pfree(slot->tts_values);
if (slot->tts_isnull)
pfree(slot->tts_isnull);
pfree(slot);
}
void NodeMouldGroup::Transform( TransformBase& Trans )
{
// there are only two types of transform that dont alter the
// relationship of the bounding box with respect to its objects.
// These are the only ones I can allow through otherwise the
// mould will shear.
// Unfortunately Scales don't seem to work too well either
// so we're gonna have to put up with simple translations only
// ok I've commented this lot out for now until someone complains
// about it... Moving the source objects about is a bit of a pain
// as during undo the final position of the object is weird.
// (See bug 4630 for instance)
if (IS_A(&Trans, Trans2DMatrix))
{
Trans2DMatrix* t = (Trans2DMatrix*)(&Trans);
Matrix m = t->GetMatrix();
if (m.IsTranslation())
NodeRenderableInk::TransformChildren(Trans);
}
}
/*
* Transform the subscript expressions.
*/
foreach(idx, indirection) {
A_Indices *ai = (A_Indices *) lfirst(idx);
node_n *subexpr;
ASSERT(IS_A(ai, A_Indices));
if (isSlice) {
if (ai->lidx) {
subexpr = xfrm_expr(pstate, ai->lidx);
/* If it's not int4 already, try to coerce */
subexpr = coerce_to_target_type(pstate, subexpr, expr_type(subexpr), INT4OID, -1,
COERCION_ASSIGNMENT, COERCE_IMPLICIT_CAST, -1);
if (subexpr == NULL)
ereport(ERROR, (
errcode(E_DATATYPE_MISMATCH),
errmsg("array subscript must have type integer"),
parser_errpos(pstate, expr_location(ai->lidx))));
} else {
/* Make a constant 1 */
subexpr = (node_n *) makeConst(INT4OID, -1, INVALID_OID, sizeof(int32), INT32_TO_D(1),
false, true);
/* pass by value */
}
lowerIndexpr = lappend(lowerIndexpr, subexpr);
}
subexpr = xfrm_expr(pstate, ai->uidx);
/* If it's not int4 already, try to coerce */
subexpr = coerce_to_target_type(pstate, subexpr, expr_type(subexpr), INT4OID, -1,
COERCION_ASSIGNMENT, COERCE_IMPLICIT_CAST, -1);
if (subexpr == NULL)
ereport(ERROR, (
errcode(E_DATATYPE_MISMATCH),
errmsg("array subscript must have type integer"),
parser_errpos(pstate, expr_location(ai->uidx))));
upperIndexpr = lappend(upperIndexpr, subexpr);
}
BOOL SGLineDragTarget::ProcessEvent(DragEventType Event, DragInformation *pDragInfo,
OilCoord *pMousePos, KeyPress* pKeyPress)
{
if (!pDragInfo->IsKindOf(CC_RUNTIME_CLASS(GalleryLineDragInfo)))
return(FALSE);
SGDisplayNode *DraggedNode = NULL;
BOOL IsSimpleBitmapDrag = TRUE;
if (IS_A(pDragInfo, GalleryLineDragInfo))
{
DraggedNode = ((GalleryLineDragInfo *)pDragInfo)->GetDraggedLineAttr();
}
if (DraggedNode != NULL)
{
switch(Event)
{
case DRAGEVENT_COMPLETED:
HandleDragCompleted((SuperGallery *) TargetDialog,
DraggedNode, pMousePos, IsSimpleBitmapDrag);
return(TRUE);
case DRAGEVENT_MOUSESTOPPED:
case DRAGEVENT_MOUSEMOVED:
case DRAGEVENT_MOUSEIDLE:
// Call a subroutine to work out and set our current cursor shape
return(DetermineCursorShape((SuperGallery *) TargetDialog,
DraggedNode, pMousePos));
default:
break;
}
}
// Otherwise, we aren't interested in the event, so we don't claim it
return(FALSE);
}
/* --------------------------------
* exec_reset_tupslot
*
* This releases any resources (buffer pins, tupdesc refcounts)
* held by the tuple table, and optionally releases the memory
* occupied by the tuple table data structure.
* It is expected that this routine be called by EndPlan().
* --------------------------------
*/
void
exec_reset_tupslot(
struct list *tupleTable, /* tuple table */
bool shouldFree) /* true if we should free memory */
{
struct list_cell* lc;
foreach(lc, tupleTable) {
struct tupslot *slot = (struct tupslot *) lfirst(lc);
/* Sanity checks */
ASSERT(IS_A(slot, TupleTableSlot));
/* Always release resources and reset the slot to empty */
exec_clear_tuple(slot);
if (slot->tts_tupleDescriptor) {
RELEASE_TUPLE_DESC(slot->tts_tupleDescriptor);
slot->tts_tupleDescriptor = NULL;
}
/* If shouldFree, release memory occupied by the slot itself */
if (shouldFree) {
if (slot->tts_values)
pfree(slot->tts_values);
if (slot->tts_isnull)
pfree(slot->tts_isnull);
pfree(slot);
}
}
/* If shouldFree, release the list structure */
if (shouldFree)
list_free(tupleTable);
}
void SelectionState::Restore(BOOL RestoreSelBlobs, BOOL RemoveBlobs)
{
DeselectAll(RemoveBlobs); // Deselect all selections
#ifdef _DEBUG
UINT32 NumRestored = 0;
#endif
// ----------------------------------------------------------------------------------
// Restore all nodes in the SelNdList
UINT32 i;
for (i=0; i < NumNd; i++)
{
// Only NodeRenderableInk nodes should be selected
ENSURE(SelNdList[i]->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)),
"Node to be selected is not a NodeRenderableInk");
// Ensure node to be selected is not already selected
//ENSURE(!(SelNdList[i]->IsSelected()), "Invalid selected node");
// Select the node
SelNdList[i]->SetSelected(TRUE);
#ifdef _DEBUG
NumRestored++;
#endif
}
// ----------------------------------------------------------------------------------
// Restore all nodes in the SelNdRngList
Node* Current;
for (i=0; i < NumNdRng; i++)
{
// A SelNdRng shold represent at least two contiguous selected nodes
ENSURE(SelNdRngList[i].NumSelected >= 2, "Number of nodes in SelNdRng < 2");
UINT32 NumNodesSelected = 0;
Current = SelNdRngList[i].FirstNode; // First node in range
// Select the next SelNdRng->NumSelected nodes
do
{
ENSURE((Current != NULL), "Node in a SelNdRng is NULL, Has tree changed ?" );
// Only NodeRenderableInk nodes should be selected
ENSURE(Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)),
"Selected node is not a NodeRenderableInk");
// [Phil, 11/10/2005] The Current node may be a Caret node
// because Carets are included in the selection, even when
// a sub-selection of characters is present, so that attributes
// optimise correctly within the text story
// However, the Record function treats them as single selected
// nodes, not part of a contiguous run of selected nodes to
// allow for them moving around...
// So we should ignore carets here
if (!IS_A(Current, CaretNode))
{
// Ensure SelNode not already selected
ENSURE(!(Current->IsSelected()), "Invalid selected node");
Current->SetSelected(TRUE); // Set the nodes selected flag
NumNodesSelected++;
#ifdef _DEBUG
NumRestored++;
#endif
}
Current = Current->FindNextNonHidden();
}
while (NumNodesSelected != SelNdRngList[i].NumSelected);
}
#if !defined(EXCLUDE_FROM_RALPH)
// Only restore the blobs if any selections have been restored
if (((NumNdRng != 0) || (NumNd !=0)) && RestoreSelBlobs) // We need to restore the selection blobs
{
// Find the current selections
SelRange* pSel;
pSel = GetApplication()->FindSelection();
Current = pSel->FindFirst(); // The first selected node
Spread *pSpread = NULL;
if (Current != NULL)
pSpread = Current->FindParentSpread();
// ENSURE(pSpread != NULL, "First selected node does not have a parent spread");
// It's a legal state to not find a selected node - the layers may all be locked.
if (pSpread == NULL)
{
AttrFillGeometry::LastRenderedMesh = NULL;
return;
}
// Go get the blob manager
BlobManager* BlobMgr = GetApplication()->GetBlobManager();
ENSURE( BlobMgr!=NULL, "Blob Manger was not there when we needed him!");
if (BlobMgr==NULL)
return;
Current = pSel->FindFirst(); // The first selected node
while (Current != NULL)
{
ENSURE(Current->IsSelected(), "Node not selected");
ENSURE(Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderable)),
"Selected Node not a NodeRenderable");
// Tell the node to add selection blobs
BlobMgr->RenderMyBlobsOn(NULL, pSpread, (NodeRenderable*)Current);
Current = pSel->FindNext(Current); // Get next selected node
}
Tool* pTool = Tool::GetCurrent();
// Get the tool to remove all its blobs before we deselect the nodes.
// Only do this if the current tool dosent update itself on sel changed messages
if (pSpread!=NULL && pTool!=NULL && !pTool->AreToolBlobsRenderedOnSelection())
pTool->RenderToolBlobs(pSpread,NULL);
AttrFillGeometry::LastRenderedMesh = NULL;
}
#endif
#ifdef _DEBUG
//if (IsUserName("Simon"))
// TRACE( _T(" Num Restored = %lu\n"), NumRestored);
#endif
}
BOOL SelectionState::Record()
{
// Make sure that Record has not been called before
ENSURE(((SelNdList == NULL) && (SelNdRngList == NULL)), "SelectionState::Record called twice");
// Find the current selections
SelRange* pSel;
pSel = GetApplication()->FindSelection();
Node* StartRange;
UINT32 SelNdRngListIndex = 0;
UINT32 SelNdListIndex = 0;
UINT32 NumSelectedNodes = pSel->Count();
if (NumSelectedNodes != 0)
{
// At this point we don't know exactly how much memory to allocate for the SelNdRngList
// and SelNdList. So we allocate two temporary arrays which are more than big enough to
// store the selection state. When we have completed recording the selection state into
// these temporary arrays, we know how big the SelNdRngList and SelNdList should
// be. so we can allocate memory for these and then copy the data from the temporary
// arrays into them.
SelNdRng* SelNdRngListTmp = new SelNdRng[NumSelectedNodes];
if (SelNdRngListTmp == NULL)
{
return FALSE;
}
Node** SelNdListTmp = new Node*[NumSelectedNodes];
if (SelNdListTmp == NULL)
{
delete[] SelNdRngListTmp; // Tidy up
return FALSE;
}
// Get the first selected node in the tree
Node * Current = pSel->FindFirst();
Node* Last;
BYTE NumAdjacentSel; // Number of contiguous selected nodes
#ifdef _DEBUG
UINT32 NumSel = 0;
#endif
// always use the selection object to determine next node to store... this fixes bug #10775 whereby
// selected Bevel,Contour & Shadow objects were not being restored on Undo
while (Current != NULL)
{
// At this point Current will always point to the next selected node which needs
// recording.
// Only NodeRenderableInk nodes should be selected
ENSURE(Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)),
"A non NodeRenderableInk node is selected");
NumAdjacentSel = 1;
#ifdef _DEBUG
NumSel++;
#endif
StartRange = Current;
Last = Current;
Current = pSel->FindNext(Current); //next from selection
// if we have at least two contiguous nodes, store as a range
if (Current && AreContiguous(Last, Current) && !IS_A(Last, CaretNode) && !IS_A(Current, CaretNode))
{
SelNdRngListTmp[SelNdRngListIndex].FirstNode = StartRange;
do
{
if (IS_A(Current, CaretNode))
{
// Give Caret it's own selection record but don't break the contiguous range
SelNdListTmp[SelNdListIndex] = Current;
SelNdListIndex++;
#ifdef _DEBUG
NumSel++;
#endif
}
else
{
NumAdjacentSel++;
#ifdef _DEBUG
NumSel++;
#endif
}
Last = Current;
Current = pSel->FindNext(Current);
if (Current == NULL)
break;
} while ((AreContiguous(Last,Current)) && (NumAdjacentSel < 255));
// Either there are no more contiguous selected nodes or
// we have hit the maximum number of selected nodes that a SelNdRng can
// represent.
SelNdRngListTmp[SelNdRngListIndex].NumSelected = NumAdjacentSel;
SelNdRngListIndex++;
}
else // Store node in the SelNdLst
{
ERROR3IF(StartRange==NULL, "Trying to add NULL pointer to SelNdList\n");
SelNdListTmp[SelNdListIndex] = StartRange;
SelNdListIndex++;
}
}
ERROR3IF(NumSel!=NumSelectedNodes,"Incorrect selection state stored!");
NumNd = SelNdListIndex;
NumNdRng = SelNdRngListIndex;
if (SelNdRngListIndex != 0)
{
// We have created at least one SelNdRange
SelNdRngList = new SelNdRng[NumNdRng];
if (SelNdRngList == NULL) // Out of memory
{
// Delete the two temporary lists
delete [] SelNdRngListTmp;
delete [] SelNdListTmp;
return FALSE;
}
// Copy the SelNdRngListTmp to the SelNdRngList
memcpy(SelNdRngList, SelNdRngListTmp, sizeof(SelNdRng)*NumNdRng);
}
delete[] SelNdRngListTmp; // No longer required
if (SelNdListIndex != 0)
{
SelNdList = new Node*[NumNd];
if (SelNdList == NULL) // Out of memory
{
delete [] SelNdListTmp;
if (SelNdRngList != NULL) // We allocated the SelNdRng list
{
delete [] SelNdRngList;
}
return FALSE;
}
// copy the SelNdListTmp to the SelNdList
memcpy(SelNdList, SelNdListTmp, sizeof(Node*)*NumNd);
}
delete[] SelNdListTmp; // No longer required
#ifdef _DEBUG
//if (IsUserName("Simon"))
//TRACE( _T("Number of nodes selected = %lu\n"), NumSel);
#endif
}
return (TRUE);
}
datum_t
connectby_text(PG_FUNC_ARGS)
{
char *relname = text_to_cstring(ARG_TEXT_PP(0));
char *key_fld = text_to_cstring(ARG_TEXT_PP(1));
char *parent_key_fld = text_to_cstring(ARG_TEXT_PP(2));
char *start_with = text_to_cstring(ARG_TEXT_PP(3));
int max_depth = ARG_INT32(4);
char *branch_delim = NULL;
bool show_branch = false;
bool show_serial = false;
return_set_info_n *rsinfo = (return_set_info_n *) fcinfo->resultinfo;
struct tuple * tupdesc;
AttInMetadata *attinmeta;
struct mctx * per_query_ctx;
struct mctx * oldcontext;
/* check to see if caller supports us returning a tuplestore */
if (rsinfo == NULL || !IS_A(rsinfo, ReturnSetInfo))
ereport(ERROR,
(errcode(E_FEATURE_NOT_SUPPORTED),
errmsg("set-valued function called in context that cannot accept a set")));
if (!(rsinfo->allowedModes & SFRM_Materialize) ||
rsinfo->expectedDesc == NULL)
ereport(ERROR,
(errcode(E_FEATURE_NOT_SUPPORTED),
errmsg("materialize mode required, but it is not " \
"allowed in this context")));
if (fcinfo->nargs == 6)
{
branch_delim = text_to_cstring(ARG_TEXT_PP(5));
show_branch = true;
}
else
/* default is no show, tilde for the delimiter */
branch_delim = pstrdup("~");
per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
oldcontext = mctx_switch(per_query_ctx);
/* get the requested return tuple description */
tupdesc = tupdesc_copy(rsinfo->expectedDesc);
/* does it meet our needs */
validateConnectbyTupleDesc(tupdesc, show_branch, show_serial);
/* OK, use it then */
attinmeta = TupleDescGetAttInMetadata(tupdesc);
/* OK, go to work */
rsinfo->returnMode = SFRM_Materialize;
rsinfo->setResult = connectby(relname,
key_fld,
parent_key_fld,
NULL,
branch_delim,
start_with,
max_depth,
show_branch,
show_serial,
per_query_ctx,
rsinfo->allowedModes & SFRM_Materialize_Random,
attinmeta);
rsinfo->setDesc = tupdesc;
mctx_switch(oldcontext);
/*
* SFRM_Materialize mode expects us to return a NULL Datum. The actual
* tuples are in our tuplestore and passed back through rsinfo->setResult.
* rsinfo->setDesc is set to the tuple description that we actually used
* to build our tuples with, so the caller can verify we did what it was
* expecting.
*/
return (datum_t) 0;
}
/*
* Parse a function call
*
* For historical reasons, Postgres tries to treat the notations tab.col
* and col(tab) as equivalent: if a single-argument function call has an
* argument of complex type and the (unqualified) function name matches
* any attribute of the type, we take it as a column projection. Conversely
* a function of a single complex-type argument can be written like a
* column reference, allowing functions to act like computed columns.
*
* Hence, both cases come through here. The is_column parameter tells us
* which syntactic construct is actually being dealt with, but this is
* intended to be used only to deliver an appropriate error message,
* not to affect the semantics. When is_column is true, we should have
* a single argument (the putative table), unqualified function name
* equal to the column name, and no aggregate or variadic decoration.
* Also, when is_column is true, we return NULL on failure rather than
* reporting a no-such-function error.
*
* The argument expressions (in fargs) must have been transformed already.
* But the agg_order expressions, if any, have not been.
*/
node_n*
ParseFuncOrColumn(
parse_state_s* pstate,
struct list *funcname,
struct list *fargs,
struct list *agg_order,
bool agg_star,
bool agg_distinct,
bool func_variadic,
WindowDef* over,
bool is_column,
int location)
{
oid_t rettype;
oid_t funcid;
struct list_cell *l;
struct list_cell *nextl;
node_n *first_arg = NULL;
int nargs;
int nargsplusdefs;
oid_t actual_arg_types[FUNC_MAX_ARGS];
oid_t *declared_arg_types;
struct list *argnames;
struct list *argdefaults;
node_n *retval;
bool retset;
int nvargs;
func_code_e fdresult;
/*
* Most of the rest of the parser just assumes that functions do not have
* more than FUNC_MAX_ARGS parameters. We have to test here to protect
* against array overruns, etc. Of course, this may not be a function,
* but the test doesn't hurt.
*/
if (list_length(fargs) > FUNC_MAX_ARGS) {
ereport(ERROR, (
errcode(E_TOO_MANY_ARGUMENTS),
errmsg_plural("cannot pass more than %d argument to a function",
"cannot pass more than %d arguments to a function",
FUNC_MAX_ARGS, FUNC_MAX_ARGS),
parser_errpos(pstate, location)));
}
/*
* Extract arg type info in preparation for function lookup.
*
* If any arguments are param_xp markers of type VOID, we discard them from
* the parameter list. This is a hack to allow the JDBC driver to not
* have to distinguish "input" and "output" parameter symbols while
* parsing function-call constructs. We can't use foreach() because we
* may modify the list ...
*/
nargs = 0;
for (l = list_head(fargs); l != NULL; l = nextl) {
node_n *arg;
oid_t argtype;
arg = lfirst(l);
argtype = expr_type(arg);
nextl = lnext(l);
if (argtype == VOIDOID
&& IS_A(arg, Param)
&& !is_column) {
fargs = list_delete_ptr(fargs, arg);
continue;
}
actual_arg_types[nargs++] = argtype;
}
/*
* Check for named arguments; if there are any, build a list of names.
*
* We allow mixed notation (some named and some not), but only with all
* the named parameters after all the unnamed ones. So the name list
* corresponds to the last N actual parameters and we don't need any extra
* bookkeeping to match things up.
*/
argnames = NIL;
foreach(l, fargs) {
node_n *arg;
arg = lfirst(l);
if (IS_A(arg, NamedArgExpr)) {
named_arg_xp *na = (named_arg_xp *) arg;
struct list_cell *lc;
/* Reject duplicate arg names */
foreach(lc, argnames) {
if (strcmp(na->name, (char *)lfirst(lc)) == 0)
ereport(ERROR, (
errcode(E_SYNTAX_ERROR),
errmsg("argument name \"%s\" used more than once", na->name),
parser_errpos(pstate, na->location)));
}
argnames = lappend(argnames, na->name);
} else {
if (argnames != NIL)
BOOL CDRFilter::AddArrowheadsToPath(DWORD StartArrow, DWORD EndArrow, DocColour *Col, INT32 LineWidth,
LineCapType Cap, JointType Join)
{
if(!IS_A(pMadeNode, NodePath))
return TRUE; // don't apply arrowheads to non path things
NodePath *pPath = (NodePath *)pMadeNode;
// check that the path actaully needs some arrow heads
if(!DoesPathNeedArrowheads(pPath) || (StartArrow == 0 && EndArrow == 0))
return TRUE;
// get pointers to nodes of the arrow heads to copy
NodeRenderableBounded *StartA = 0;
NodeRenderableBounded *EndA = 0;
INT32 StartDistance;
INT32 EndDistance;
if(StartArrow != 0)
{
BOOL NotPresent;
StartA = Arrowheads.GetConvertedNode(StartArrow, &StartDistance, &NotPresent);
if(StartA == 0 && NotPresent == FALSE)
return FALSE; // error occurred
}
if(EndArrow != 0)
{
BOOL NotPresent;
EndA = Arrowheads.GetConvertedNode(EndArrow, &EndDistance, &NotPresent);
if(EndA == 0 && NotPresent == FALSE)
return FALSE; // error occurred
}
// check that enough arrowheads were found to do something with
if(StartA == 0 && EndA == 0)
return TRUE;
// get rid of any dash patterns
DashRec NoDash;
NoDash = SD_SOLID;
SetDashPattern(NoDash);
// get some info about the path
DocCoord *Coords = pPath->InkPath.GetCoordArray();
PathVerb *Verbs = pPath->InkPath.GetVerbArray();
INT32 NCoords = pPath->InkPath.GetNumCoords();
INT32 SubPathStart = -1; // the number of the coord the sub path starts on
INT32 SubPathEnd = -1; // the number of the coord the sub path ends on
// set up a pointers for the nodes we're about to create - it points to the made
// at first, but shuffles on as nodes are copied. You see, we have to copy nodes which
// are attached to something
NodeRenderableBounded *ThisNode = pPath;
// work out the trim distances
double StartTrimDistance;
double EndTrimDistance;
if(StartA != 0)
StartTrimDistance = ((double)LineWidth / (double)cdrfARROWHEAD_LINEWIDTH) * (double)StartDistance;
if(EndA != 0)
EndTrimDistance = ((double)LineWidth / (double)cdrfARROWHEAD_LINEWIDTH) * (double)EndDistance;
// run through all the coords
INT32 c;
for(c = 0; c < NCoords; c++)
{
UINT32 Verb = Verbs[c] & ~PT_CLOSEFIGURE;
BOOL CloseHere = ((Verbs[c] & PT_CLOSEFIGURE) != 0)?TRUE:FALSE;
// if the verb is a close figure, this sub path is close, so we can't add arrowheads
// to it. Invalidate the path start to avoid getting any arrowheads
if(CloseHere)
SubPathStart = -1;
// if we get a new moveto and the sub path start is valid then we have a applying arrowheads
// situation
if((Verb == PT_MOVETO || ((c == (NCoords - 1)) && !CloseHere)) && c != 0)
{
// set the sub path end
if(Verb == PT_MOVETO)
{
// if it's a moveto, then the sub path end was at the previous coord
SubPathEnd = c - 1;
} else {
// if it wasn't, then it's this one (end of path)
SubPathEnd = c;
}
}
// have we got a valid start path marker?
if(SubPathStart != -1 && SubPathEnd != -1)
{
// OK, now we need to trim the sub path
if(StartA != 0)
{
// trim the start of the path if the next element is a line
if((Verbs[SubPathStart + 1] & ~PT_CLOSEFIGURE) == PT_LINETO)
{
double dx, dy;
dx = Coords[SubPathStart + 1].x - Coords[SubPathStart].x;
dy = Coords[SubPathStart + 1].y - Coords[SubPathStart].y;
double len = sqrt((dx * dx) + (dy * dy));
// if the resulting path line leaves enough room, trim it
if((len - StartTrimDistance) >= 32.0)
{
double factor = StartTrimDistance / len;
dx *= factor;
Coords[SubPathStart].x += (INT32)dx;
dy *= factor;
Coords[SubPathStart].y += (INT32)dy;
}
}
// now pop an arrowhead on the resulting point
// first, make a copy of our node
if(!StartA->CopyNode(ThisNode, NEXT))
return FALSE; // error!
ThisNode = (NodeRenderableBounded *)ThisNode->FindNext();
ERROR3IF(ThisNode == 0, "CopyNode returned a zero path but didn't complain");
ERROR3IF(ThisNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)) == FALSE, "copied thing isn't a renderable bounded node");
// transform it
if(!TransformArrowhead(ThisNode, &Coords[SubPathStart], &Coords[SubPathStart + 1],
TRUE, LineWidth, StartDistance))
return FALSE;
// and apply attributes to it
if(!AddAttributesToArrowheadNode(ThisNode, Col, LineWidth, Cap, Join))
return FALSE;
}
// and the same for the end path
if(EndA != 0)
{
if((Verbs[SubPathEnd] & ~PT_CLOSEFIGURE) == PT_LINETO)
{
double dx, dy;
dx = Coords[SubPathEnd].x - Coords[SubPathEnd - 1].x;
dy = Coords[SubPathEnd].y - Coords[SubPathEnd - 1].y;
double len = sqrt((dx * dx) + (dy * dy));
// if the resulting path line leaves enough room, trim it
if((len - EndTrimDistance) >= 32.0)
{
double factor = EndTrimDistance / len;
dx *= factor;
Coords[SubPathEnd].x += (INT32)dx;
dy *= factor;
Coords[SubPathEnd].y += (INT32)dy;
}
}
// now pop an arrowhead on the resulting point
// first, make a copy of our node
if(!EndA->CopyNode(ThisNode, NEXT))
return FALSE; // error!
ThisNode = (NodeRenderableBounded *)ThisNode->FindNext();
ERROR3IF(ThisNode == 0, "CopyNode returned a zero path but didn't complain");
ERROR3IF(ThisNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)) == FALSE, "copied thing isn't a renderable bounded node");
// transform it
if(!TransformArrowhead(ThisNode, &Coords[SubPathEnd], &Coords[SubPathEnd - 1],
FALSE, LineWidth, EndDistance))
return FALSE;
// and apply attributes to it
if(!AddAttributesToArrowheadNode(ThisNode, Col, LineWidth, Cap, Join))
return FALSE;
}
}
// set the new sub path start marker and invalidate the end point marker
if(Verb == PT_MOVETO)
{
SubPathStart = c;
SubPathEnd = -1;
}
}
// ensure that the bounding rectangle is updated
pPath->InvalidateBoundingRect();
// get a new group node
NodeGroup *pGroup = new NodeGroup;
if(pGroup == 0)
return FALSE;
// attach everything to it
pMadeNode->InsertChainSimple(pGroup, FIRSTCHILD);
// and make the made node the group
pMadeNode = pGroup;
return TRUE;
}