Camelot: OpBreakShapes Class Reference

06473 {   
06474     // Obtain the current selections 
06475     SelRange* Selected = GetApplication()->FindSelection();
06476 
06477     NodePath* NewPath;
06478     // Now, because we're going to be doing mad things to the selection, we have to make a list
06479     // of all the selected nodes, so that adding nodes into the tree won't confuse us
06480 
06481     List* NodeList = Selected->MakeListOfNodes();
06482 
06483     NodeListItem* CurItem = (NodeListItem*)(NodeList->GetHead());
06484 
06485     if (!CurItem)
06486         goto FailAndDeleteList;
06487 
06488     while(CurItem)
06489     {
06490         if ((CurItem->pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodePath))   &&  // It's a NodePath  AND
06491             (((NodePath*)(CurItem->pNode))->InkPath.IsComplexPath())            &&  // It's complex     AND
06492             (CurItem->pNode->FindParentOfSelected() == NULL))                       // It's not selected inside
06493         {
06494             // get a pointer to the NodePath
06495             NodePath* ThisPath = (NodePath*)(CurItem->pNode);
06496             
06497             // Start at the very beginning (a very good place to start)
06498             INT32 SubPathIndex = 0;
06499             INT32 NumCoords = ThisPath->InkPath.GetNumCoords();
06500 
06501             while (SubPathIndex < NumCoords)
06502             {
06503                 // Create a new path, copy this subpath into it, and link it into the tree
06504                 // Create the path
06505                 NewPath = new NodePath;
06506                 if (!NewPath)
06507                 {
06508                     goto FailAndDeleteList;
06509                 }
06510                 
06511                 // Initialise the path
06512                 if (!NewPath->SetUpPath(24,12))
06513                 {
06514                     InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK));
06515                     goto FailAndDeleteListAndPath;
06516                 }
06517 
06518                 // Copy all attributes from the original shape to the new path
06519                 Node* pAttr = ThisPath->FindFirstChild();
06520                 while (pAttr != NULL)
06521                 {
06522                     if (pAttr->IsAnAttribute())
06523                     {
06524                         BOOL ok;
06525                         Node* pAttrCopy;
06526                         CALL_WITH_FAIL(pAttr->NodeCopy(&pAttrCopy), this, ok);
06527                         if (!ok) 
06528                         {
06529                             goto FailAndDeleteListAndPath;
06530                         }
06531                         pAttrCopy->AttachNode(NewPath, FIRSTCHILD);
06532                     }
06533                     pAttr = pAttr->FindNext();
06534                 }
06535 
06536                 // Set the filled bit if the original path has the filled bit set
06537                 if (ThisPath->InkPath.IsFilled)
06538                     NewPath->InkPath.IsFilled = TRUE;
06539                 
06540                 // Now copy the current subpath into this object
06541                 // Find the last element in the subpath
06542                 INT32 EndOfSubPath = SubPathIndex;
06543                 ThisPath->InkPath.FindEndOfSubPath(&EndOfSubPath);
06544                 // Skip to the next element (this will give us the number of elements)
06545                 ThisPath->InkPath.FindNext(&EndOfSubPath);
06546 
06547                 // Now EndOfSubPath either points at the start of the next subpath, or 
06548                 // the top of the path (i.e. the first free space).
06549 
06550                 // Now copy it
06551                 if (!(NewPath->InkPath.CopySectionFrom(ThisPath->InkPath, SubPathIndex, EndOfSubPath-SubPathIndex)))
06552                 {
06553                     InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK));
06554                     goto FailAndDeleteListAndPath;
06555                 }
06556                 
06557                 // Set the index to the start of the next subpath
06558                 SubPathIndex = EndOfSubPath;
06559 
06560                 // Now stick it in the tree
06561                 if (!DoInsertNewNode(NewPath, ThisPath, NEXT, TRUE))
06562                 {
06563                     goto FailAndDeleteListAndPath;
06564                 }
06565 
06566                 // And that's it - no need to do anything more, just loop to the next subpath
06567             }
06568 
06569             // Now we've broken up this object, let's hide it
06570             if (!DoHideNode(ThisPath, TRUE))
06571                 goto FailAndDeleteList;
06572 
06573         }
06574         CurItem = (NodeListItem*)(NodeList->GetNext(CurItem));
06575     }
06576     
06577     End();
06578 
06579     // delete the nodelist (and all the list items)
06580     while (!NodeList->IsEmpty())
06581         delete (NodeListItem*)(NodeList->RemoveHead());
06582     delete NodeList;
06583 
06584     return;
06585 
06586 FailAndDeleteListAndPath:
06587 
06588     NewPath->CascadeDelete();
06589     delete NewPath;
06590 
06591 FailAndDeleteList:
06592     while (!NodeList->IsEmpty())
06593         delete (NodeListItem*)(NodeList->RemoveHead());
06594     delete NodeList;
06595     FailAndExecute();
06596     End();
06597     return;
06598 }

Public Member Functions
	OpBreakShapes ()
	OpBreakShapes constructor.
void	Do (OpDescriptor *)
	Performs the Break shapes operation.
virtual BOOL	MayChangeNodeBounds () const
Static Public Member Functions
static BOOL	Init ()
	OpBreakShapes initialiser method.
static OpState	GetState (String_256 , OpDescriptor )
	For finding the OpBreakShapes's state.
OpBreakShapes Class Reference

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation
