OpState OpShowGuides::GetState(String_256* pUIDescription, OpDescriptor*)
{
OpState OpSt;
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
OpSt.Ticked = pDocView->GetShowGuidesState();
Spread* pSpread = Document::GetSelectedSpread();
if (pSpread != NULL)
{
// if we have a guide layer, then make the menu item available, if not, grey it
// and give a reason.
if (pSpread->FindFirstGuideLayer() != NULL)
{
OpSt.Greyed = FALSE;
}
else
{
OpSt.Greyed = TRUE;
*pUIDescription = String_256 (_R(IDS_NO_GUIDES));
}
} // if (pSpread != NULL)
return OpSt;
}
void analyze(TTPOutputSet bestFront, TTPOutputSet front) {
vector<vector<double>> solutionFront = convertTTPOutput(front);
vector<vector<double>> trueFront = convertTTPOutput(bestFront);
Hypervolume hv;
double hvValue = hv.hypervolume(solutionFront, trueFront, trueFront[0].size());
Spread spread;
double spreadValue = spread.spread(solutionFront, trueFront, trueFront[0].size());
InvertedGenerationalDistance igd;
double igdValue = igd.invertedGenerationalDistance(solutionFront, trueFront, trueFront[0].size());
Epsilon eps;
double epsValue = eps.epsilon(solutionFront, trueFront, trueFront[0].size());
cout << "hv: " << hvValue << endl;
cout << "spread: " << spreadValue << endl;
cout << "igd: " << igdValue << endl;
cout << "eps: " << epsValue << endl;
}
BOOL ScaleTab::InitSection()
{
TRACEUSER( "Neville", _T("ScaleTab::InitSection\n"));
ERROR2IF(pPrefsDlg == NULL,FALSE,"ScaleTab::InitSection called with no dialog pointer");
// BOOL ReadOk = FALSE; // Flag to say whether the preference value was read ok
// Make sure the information field displaying the name of the current document
// is correct.
String_256 DocumentName(_R(IDT_OPTS_SCALING_INFO));
DocumentName += *GetDocumentName();
pPrefsDlg->SetStringGadgetValue(_R(IDC_OPTS_INFO), DocumentName);
// Section = Scale settings
DocView* pSelectedView = DocView::GetSelected();
// This may now be a valid state so must not error
//ERROR3IF(pSelectedView == NULL,"ScaleTab::InitSection Where's the current view eh?");
if (pSelectedView != NULL)
{
Spread* pSpread = pSelectedView->GetFirstSelectedSpread();
// If no selected spread then use the visible spread
if (pSpread == NULL)
pSpread = pSelectedView->GetVisibleSpread();
// If no selected spread then use the first spread
// Of course, this should not be here but above routines seem to return
// null a bit too often for my liking
if (pSpread == NULL)
{
TRACEUSER( "Neville", _T("ScaleTab::InitSection BODGE! using 1st spread\n"));
Document* pSelectedDoc = Document::GetSelected();
if (pSelectedDoc !=NULL )
pSpread = pSelectedDoc->FindFirstSpread();
}
// Go and get a pointer to the scaling values
if (pSpread != NULL)
{
pDimScale = pSpread->GetPtrDimScale();
if (pDimScale != NULL)
{
// And now show the initial state of the controls given this
// scaling
ShowScaleDetails();
}
}
}
else
{
// If no current view then ensure section is greyed
GreySection();
}
return TRUE;
}
void SelectionState::DeselectAll(BOOL RenderBlobs)
{
// Find the selected objects in the tree;
SelRange* Selected = GetApplication()->FindSelection();
ERROR3IF( Selected==NULL, "Selection object is null in DeselectAll()");
// Get the selected spread
Spread* pSpread = Document::GetSelectedSpread();
ERROR3IF(pSpread == NULL,"NULL selected spread");
// Make sure that we have a spread and a selection
if (pSpread == NULL || Selected == NULL)
return;
// Find first selected node
#if !defined(EXCLUDE_FROM_RALPH)
Node* pFirstSelectedNode = Selected->FindFirst();
// If there is a selection, EOR blobs off, deselect nodes, and inform everybody
if (pFirstSelectedNode != NULL && RenderBlobs)
{
// Go though and render all the EOR blobs off the screen
// Find the Blob Manager
BlobManager* BlobMgr = GetApplication()->GetBlobManager();
ENSURE( BlobMgr!=NULL, "Blob Manager unexpectedly not there.");
// Render all the blobs
BlobMgr->RenderOff(NULL, pFirstSelectedNode->FindParentSpread());
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);
}
#endif
DeselectAll(pSpread->FindFirstChild());
// Selection cache is no longer valid, so update and tell everyone that it has changed
// *Note*, This used to be 'Selected->Update(TRUE)', but I (Will) removed the TRUE, so
// that a message is NOT broadcast. This should only be called from an operation,
// and the op will send a message when it ends.
Selected->Update();
}
void OpShowGuides::Do(OpDescriptor*)
{
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
{
pDocView->SetShowGuidesState(!pDocView->GetShowGuidesState());
Spread* pSpread = Document::GetSelectedSpread();
Document* pDoc = Document::GetSelected();
if (pSpread != NULL && pDoc != NULL)
{
Layer* pLayer = pSpread->FindFirstGuideLayer();
if (pLayer != NULL)
LayerSGallery::ForceRedrawLayer(pDoc,pLayer);
}
BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES));
}
End();
}
BOOL OpNudge::IsNudgeOK(BOOL dx,BOOL dy)
{
// Get the selection
SelRange* pSel = GetApplication()->FindSelection();
ERROR2IF(pSel == NULL,FALSE,"Awooga, NULL sel range");
// Find out the bounding rectangle of the selection
DocRect BoundingRect = pSel->GetBoundingRect();
// Find out the Pasteboard rect
DocRect PasteRect;
Spread* pSpread = pOurDoc->GetSelectedSpread();
if (pSpread==NULL)
PasteRect = BoundingRect;
else
{
// Try to make the pasteboard grow if necessary to include the new object position
// This is very quick if the pasteboard is large enough already.
pSpread->ExpandPasteboardToInclude(BoundingRect);
// And re-read the bounding rectangle of the selection, as the pasteboard resize may have
// caused the origin of our entire coordinate space to have moved! Argh!
BoundingRect = pSel->GetBoundingRect();
// BoundingRect.Translate(dx,dy);
// This is in Document Coords, so we need to convert it
PasteRect = pSpread->GetPasteboardRect();
pSpread->DocCoordToSpreadCoord(&PasteRect);
}
// Assume the nudge will be OK.
BOOL NudgeOK = TRUE;
if (PasteRect.ContainsRect(BoundingRect))
{
// Untranslated bounds fit inside pasteboard rect, so we must complain if the bounds
// do not fit *after* translation
// Translate the bounds by the nudge values
BoundingRect.Translate(dx,dy);
// Do the translated bounds still fit entirely in the pasteboard rect?
NudgeOK = PasteRect.ContainsRect(BoundingRect);
}
else
{
// The original bounds overlap the pasteboard rect, so we must complain if the user
// nudges the bounds completely out of sight
if (PasteRect.IsIntersectedWith(BoundingRect))
{
// The original bounds intersect with the pasteboard rect
BoundingRect.Translate(dx,dy);
// Only allow the nudge if the translated bounds still overlap with the spread.
NudgeOK = PasteRect.IsIntersectedWith(BoundingRect);
}
}
// If the nudge is OK, we may need to scroll the DocView?
/* Jim, 12/9/96 - removed this because we don't want to scroll to show opn nudges
if (NudgeOK)
{
DocCoord Coord(0,0);
// If nudging left or right, pick the min or max X coord
if (dx != 0)
{
if (dx < 0)
Coord.x = BoundingRect.lox;
else
Coord.x = BoundingRect.hix;
}
// If nudging up or down, pick the max or min Y coord
if (dy != 0)
{
if (dy < 0)
Coord.y = BoundingRect.loy;
else
Coord.y = BoundingRect.hiy;
}
// If we have picked a coord, ensure that this coord is visible in the selected spread
// of the selected DocView
if (Coord != DocCoord(0,0))
{
DocView* pDocView = DocView::GetSelected();
if (pDocView != NULL)
pDocView->ScrollToShow(&Coord);
}
}
*/
return NudgeOK;
}
BOOL ScaleTab::CommitSection()
{
TRACEUSER( "Neville", _T("commit Scale section\n"));
ERROR3IF(pPrefsDlg == NULL, "ScaleTab::CommitSection called with no dialog pointer");
BOOL ok = pPrefsDlg->TalkToPage(_R(IDD_OPTSTAB_SCALE)); // The Scale tab identifier
if (!ok)
return TRUE; // Talk to View failed to return now
// Ok has been pressed so take the values from this section of the dialog box
// Takes the values in the dialog and sets the DimScale object accordingly.
BOOL Valid=TRUE; // Flag for validity of value
// BOOL State=FALSE; // Flag for state of button/switch
BOOL SetOk=TRUE; // Preference value set ok
// Section = Scale settings
// Now check that we have the selected view still, just in case it has switched
// without us being told about it or even we have no current document/view.
// This may be a valid state now, so do not complain about it.
DocView* pCurrentView = DocView::GetSelected();
if (pCurrentView != NULL)
{
// Only if there is a current view do we read the values.
String_256 DrawingStr;
String_256 RealStr;
//TCHAR* pDrawingStr = DrawingStr;
//TCHAR* pRealStr = RealStr;
BOOL Active;
// Get the values from the dialog box
Active = pPrefsDlg->GetLongGadgetValue(_R(IDC_OPTS_USESCALEFACTOR),0,1,0, &Valid);
DrawingStr = pPrefsDlg->GetStringGadgetValue(_R(IDC_OPTS_DRAWINGSCALE), &Valid);
RealStr = pPrefsDlg->GetStringGadgetValue(_R(IDC_OPTS_REALSCALE), &Valid);
Spread* pSpread = pCurrentView->GetFirstSelectedSpread();
// If no selected spread then use the visible spread
if (pSpread == NULL)
pSpread = pCurrentView->GetVisibleSpread();
// Only do the chnage if we have a valid spread pointer and we have changed something.
if ( (pSpread != NULL) &&
(
(OldActiveState != Active) ||
(OldDrawingStr != DrawingStr) ||
(OldRealStr != RealStr)
)
)
{
pDimScale = pSpread->GetPtrDimScale();
if (pDimScale != NULL)
{
// Only if active is set do we need to try and set new strings
// and hence a new drawing scale
if (Active)
{
// Dim Scales can only be 32 characters long
String_32 DrawingStr32 = _T("");
String_32 RealStr32 = _T("");
// Check if read in strings are longer than this
if (DrawingStr.Length() > DrawingStr32.MaxLength())
{
InformError(_R(IDE_OPTS_INVALIDDRAWSCALE));
return FALSE;
}
if (RealStr.Length() > RealStr32.MaxLength())
{
InformError(_R(IDE_OPTS_INVALIDREALSCALE));
return FALSE;
}
RealStr32 = RealStr;
DrawingStr32 = DrawingStr;
// Try and set these strings as new drawing and real scales strings
SetOk = pDimScale->SetDrawingScaleStr(DrawingStr32);
if (!SetOk)
{
InformError(_R(IDE_OPTS_INVALIDDRAWSCALE));
return FALSE;
}
SetOk = SetOk && pDimScale->SetRealScaleStr(RealStr32);
if (!SetOk)
{
InformError(_R(IDE_OPTS_INVALIDREALSCALE));
return FALSE;
}
// Now try to convert these into a new scaling factor
if (SetOk)
SetOk = SetOk && pDimScale->SetScaleFactor();
// If we failed in any of the conversions then warn the user and fail
if (!SetOk)
{
InformError(_R(IDE_OPTS_INVALIDSCALING));
return FALSE;
}
}
// Set up a possibly new active state
pDimScale->SetActiveState(Active);
}
// Now tell other users of units/scaling factors that there they are likely
// to need to update any currently displayed units.
Document *pCurrentDoc = (Document *)pSpread->FindOwnerDoc();
BROADCAST_TO_ALL(OptionsChangingMsg(pCurrentDoc, OptionsChangingMsg::NEWUNITS));
// unfortunately pScopeDoc is NULL!, and since pCurrentDoc is calulated I thought it ought to use! - Ed 17/10/95
// BROADCAST_TO_ALL(OptionsChangingMsg(pScopeDocument, OptionsChangingMsg::OptionsState::NEWUNITS));
// Make sure the document is marked as modified.
pCurrentDoc->SetModified(TRUE);
// And note the new states
OldActiveState = Active;
OldDrawingStr = DrawingStr;
OldRealStr = RealStr;
}
}
// else
// ERROR2(FALSE,_R(IDE_OPTS_READPREF_SCALE));
return TRUE;
}
void ExperimentReport::generateQualityIndicators() {
if ((!isSingleObjective_) && (paretoFrontDirectory_.empty())) {
generateReferenceFronts();
}
// TODO: Check if it is possible to use QualityIndicator class instead each independent class.
// Problem: knowing number of objectives of each problem
if (indicatorList_.size() > 0) {
cout << "PF file: " << paretoFrontDirectory_ << endl;
for (int algorithmIndex=0; algorithmIndex<algorithmNameList_.size(); algorithmIndex++) {
string algorithmDirectory;
algorithmDirectory = experimentBaseDirectory_ + "/data/" + algorithmNameList_[algorithmIndex] + "/";
for (int problemIndex=0; problemIndex<problemList_.size(); problemIndex++) {
string problemDirectory = algorithmDirectory + problemList_[problemIndex];
string paretoFrontPath;
if (!isSingleObjective_) {
if (paretoFrontDirectory_.empty()) {
string referenceFrontDirectory = experimentBaseDirectory_ + "/referenceFronts";
paretoFrontPath = referenceFrontDirectory + "/" + problemList_[problemIndex] + ".rf";
} else {
paretoFrontPath = paretoFrontDirectory_ + "/" + paretoFrontFile_[problemIndex];
} // if
} // if
for (int indicatorIndex = 0; indicatorIndex < indicatorList_.size(); indicatorIndex++) {
resetFile(problemDirectory + "/" + indicatorList_[indicatorIndex]);
if (indicatorList_[indicatorIndex].compare("FIT")==0) {
string solutionFrontFile = problemDirectory + "/FUN";
string qualityIndicatorFile = problemDirectory;
Fitness * indicators = new Fitness();
vector< vector<double> > solutionFront =
indicators->utils_->readFront(solutionFrontFile);
qualityIndicatorFile = qualityIndicatorFile + "/FIT";
indicators->fitness(solutionFront, qualityIndicatorFile);
delete indicators;
} else {
for (int numRun=0; numRun<independentRuns_; numRun++) {
stringstream outputParetoFrontFilePath;
outputParetoFrontFilePath << problemDirectory << "/FUN_" << numRun;
string solutionFrontFile = outputParetoFrontFilePath.str();
string qualityIndicatorFile = problemDirectory;
double value;
cout << "ExperimentReport: Quality indicator: " << indicatorList_[indicatorIndex] << endl;
if (indicatorList_[indicatorIndex].compare("HV")==0) {
Hypervolume * indicators = new Hypervolume();
vector< vector<double> > solutionFront =
indicators->utils_->readFront(solutionFrontFile);
vector< vector<double> > trueFront =
indicators->utils_->readFront(paretoFrontPath);
value = indicators->hypervolume(solutionFront, trueFront, trueFront[0].size());
delete indicators;
qualityIndicatorFile = qualityIndicatorFile + "/HV";
}
if (indicatorList_[indicatorIndex].compare("SPREAD")==0) {
Spread * indicators = new Spread();
vector< vector<double> > solutionFront =
indicators->utils_->readFront(solutionFrontFile);
vector< vector<double> > trueFront =
indicators->utils_->readFront(paretoFrontPath);
value = indicators->spread(solutionFront, trueFront, trueFront[0].size());
delete indicators;
qualityIndicatorFile = qualityIndicatorFile + "/SPREAD";
}
if (indicatorList_[indicatorIndex].compare("IGD")==0) {
InvertedGenerationalDistance * indicators = new InvertedGenerationalDistance();
vector< vector<double> > solutionFront =
indicators->utils_->readFront(solutionFrontFile);
vector< vector<double> > trueFront =
indicators->utils_->readFront(paretoFrontPath);
value = indicators->invertedGenerationalDistance(solutionFront, trueFront, trueFront[0].size());
delete indicators;
qualityIndicatorFile = qualityIndicatorFile + "/IGD";
}
if (indicatorList_[indicatorIndex].compare("EPSILON")==0) {
Epsilon * indicators = new Epsilon();
vector< vector<double> > solutionFront =
indicators->utils_->readFront(solutionFrontFile);
vector< vector<double> > trueFront =
indicators->utils_->readFront(paretoFrontPath);
value = indicators->epsilon(solutionFront, trueFront, trueFront[0].size());
delete indicators;
qualityIndicatorFile = qualityIndicatorFile + "/EPSILON";
}
cout << "ExperimentReport: Quality indicator file: " << qualityIndicatorFile << endl;
if (qualityIndicatorFile.compare(problemDirectory)!=0) {
std::fstream out(qualityIndicatorFile.c_str(),
std::ios::out | std::ios::app);
out << value << endl;
out.close();
} // if
} // for
} // if
} // for
} // for
} // for
} // if
} // generateQualityIndicators
void *StartSpreadThread(void *arg)
{
Spread *spread = (Spread *)arg;
spread->SpreadProcess();
return NULL;
}
/********************************************************************************************
> BOOL AIBitmapProcessor::DecodeXI( AI5EPSFilter& filter )
Author: Colin_Barfoot (Xara Group Ltd) <*****@*****.**>
Created: 23/03/00
Returns: TRUE if the definition was processed,
FALSE if not used by this filter..
Purpose: Decodes the EPS XI, bitmap definition in an Illustrator 5 file
The format of the operator is:
[ a b c d tx ty ] llx lly urx ury h w bits ImageType AlphaChannelCount reserved bin-ascii ImageMask XI
********************************************************************************************/
BOOL AIBitmapProcessor::DecodeXI( AI5EPSFilter& filter )
{
// Graeme (18/4/00) - This code isn't very pretty, but it's necessary because of the way
// in which the bitmap is stored. If I try a GetCoordPair () to get the bitmap positions,
// the image will be misrendered because the transformation should take place due to the
// tx and ty components of the matrix. Note also that the bitmap's position in Adobe
// Illustrator is taken from the top left corner, whilst we use the bottom left.
/////////////////
// Get the page origin.
/////////////////
// Graeme (18/4/00) - Declare variables to get the origin of the page within Camelot's
// co-ordinate space.
Document *pDocument = filter.GetDocument ();
Spread *pSpread = pDocument->FindFirstSpread ();
Page *pPage = pSpread->FindFirstPageInSpread ();
DocCoord Origin = pPage->GetPageRect ().lo;
/////////////////
// decode the bitmap parameters
/////////////////
Matrix ImageMatrix;
DocCoord Translation;
INT32 h, w, bits, ImageType, AlphaChannelCount, reserved, bin_ascii, ImageMask;
INT32 llx, lly, urx, ury;
INT32 nLength = 0;
INT32 nLineLength = 0;
INT32 nMaxLineOffset = 0;
INT32 nChannels = 0;
NodeBitmap* pNodeBitmap = NULL;
DocCoord p;
// Graeme (18/4/00) - I've replaced the Pop with PopCoordPair for extracting the
// bounding co-ordinates of the bitmap. This means that they will be scaled up
// into the Xara co-ordinate space. I've also reversed the popping of h and w
// from the stack - their order is incorrect in the AI documentation.
if ( !filter.GetStack().Pop(&ImageMask) ||
!filter.GetStack().Pop(&bin_ascii) ||
!filter.GetStack().Pop(&reserved) ||
!filter.GetStack().Pop(&AlphaChannelCount) ||
!filter.GetStack().Pop(&ImageType) ||
!filter.GetStack().Pop(&bits) ||
!filter.GetStack().Pop(&h) ||
!filter.GetStack().Pop(&w) ||
!filter.GetStack().PopCoord(&ury) ||
!filter.GetStack().PopCoord(&urx) ||
!filter.GetStack().PopCoord(&lly) ||
!filter.GetStack().PopCoord(&llx) ||
!filter.GetStack().Pop( &ImageMatrix, TRUE )
)
goto EPSError;
/////////////////
// create space for the tentative bitmap
/////////////////
///////////////////
// ImageType gives the number of channels per pixel
// bits is the bits per channel
// However we will convert CMYK bitmaps to RGB
///////////////////
switch ( ImageType )
{
case 1: // greyscale
nChannels = 1;
break;
case 3: // rgb
nChannels = 3;
break;
case 4: // CMYK
nChannels = 3;
break;
default: // unknown
goto EPSError;
}
mpNewBitmap = new KernelBitmap( w, h, bits * nChannels, 96 );
if ( !mpNewBitmap )
goto EPSError;
///////////////////
// We can import greyscale bitmaps as well
///////////////////
if ( ImageType == 1 )
mpNewBitmap->SetAsGreyscale();
/////////////////
// get the binary data
/////////////////
nLength = mpNewBitmap->GetActualBitmap()->GetBitmapSize();
nLineLength = mpNewBitmap->GetActualBitmap()->GetScanlineSize();
nMaxLineOffset = (( w * mpNewBitmap->GetActualBitmap()->GetBPP() ) / 8) - 1;
if ( !ReadImageData( filter, ImageType, mpNewBitmap->GetBitmapBits(), nLength, nLineLength, nMaxLineOffset ) )
goto EPSError;
/////////////////////
// insert the image into the document
/////////////////////
// Get a new NodeBitmap object to import into. Don't know what the 12,12 bit does
pNodeBitmap = new NodeBitmap;
if ( !pNodeBitmap || !pNodeBitmap->SetUpPath(12,12) )
goto EPSError;
pNodeBitmap->GetBitmapRef()->Attach( mpNewBitmap, filter.GetDocument() );
/////////////////
// set up the bounds of the shape containing the bitmap
/////////////////
// Graeme (18/4/00) - Adjust the values of lly and ury before they're transformed.
lly -= h * EPSScaleFactor;
ury -= h * EPSScaleFactor;
// Graeme (18/4/00) - Modify the matrix to place the bitmap in the correct place.
ImageMatrix.GetTranslation ( Translation ); // Extract the translation component.
Translation += Origin; // Add the page origin to it.
ImageMatrix.SetTranslation ( Translation ); // And reset the value in the matrix.
// Graeme (17/4/00) - Colin overlooked setting up the bounding parallelogram when he
// wrote this code, and I've just added this.
p.x = llx;
p.y = ury;
ImageMatrix.transform( &p );
pNodeBitmap->InkPath.InsertMoveTo( p );
pNodeBitmap->Parallel [0] = p;
p.x = urx;
p.y = ury;
ImageMatrix.transform( &p );
pNodeBitmap->InkPath.InsertLineTo( p );
pNodeBitmap->Parallel [1] = p;
p.x = urx;
p.y = lly;
ImageMatrix.transform( &p );
pNodeBitmap->InkPath.InsertLineTo( p );
pNodeBitmap->Parallel [2] = p;
p.x = llx;
p.y = lly;
ImageMatrix.transform( &p );
pNodeBitmap->InkPath.InsertLineTo( p );
pNodeBitmap->Parallel [3] = p;
p.x = llx;
p.y = ury;
ImageMatrix.transform( &p );
pNodeBitmap->InkPath.InsertLineTo( p );
pNodeBitmap->InkPath.CloseSubPath();
// Graeme (18/4/00) - It is necessary to set the default attributes up for a
// new node bitmap before inserting it into the tree. Otherwise it's rendered
// as a greyscale image, even if it is colour, because there's a start colour
// value set.
pNodeBitmap->ApplyDefaultBitmapAttrs ( NULL );
filter.AddNewNode( pNodeBitmap );
return TRUE;
EPSError:
if ( mpNewBitmap )
{
delete mpNewBitmap;
mpNewBitmap = 0;
}
return FALSE;
}
/********************************************************************************************
> void OpMoveToLayer::Do(OpDescriptor*)
Author: Simon_Knight (Xara Group Ltd) <*****@*****.**>
Created: 3/5/00
Purpose: This takes the selection and moves it to the active layer. This is a more
powerful operation than the move forward/backward a layer
********************************************************************************************/
void OpMoveToLayer::Do(OpDescriptor*)
{
if (DoStartSelOp(FALSE,TRUE))
{
// get the selection
Range Sel(*(GetApplication()->FindSelection()));
// set the range flags so it includes shadow and bevel manager nodes
RangeControl rg = Sel.GetRangeControlFlags();
rg.PromoteToParent = TRUE;
Sel.Range::SetRangeControl(rg);
// Prepare an ObjChangeParam so we can mark which nodes will allow this op to happen to them
ObjChangeFlags cFlags;
cFlags.MoveNode = TRUE;
ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);
// add items directly after the layer node as its first child
Node * pTail = (Node *) (Document::GetCurrent()->GetInsertionPosition());
AttachNodeDirection TailAttachDirection = PREV;
Spread* pSpread = Document::GetSelectedSpread();
if (!pTail)
{
if (pSpread)
{
pTail = pSpread->FindActiveLayer();
// AttachNodeDirection TailAttachDirection = LASTCHILD; <--- AMB removed this and inserted the next line 2006-04-10 presuming bug
TailAttachDirection = LASTCHILD;
}
else
{
FailAndExecute();
End();
return; // nowhere to put the nodes
}
}
// Mark nodes that will allow this to happen, and error if no nodes will let it happen
if (!Sel.AllowOp(&ObjChange))
{
FailAndExecute();
End();
return; // op not allowed
}
// get a list from which to move the nodes (fixes job #10781 - the re-selection of
// moved nodes caused an infinite loop)
List* pNodeList = Sel.MakeListOfNodes(FALSE);
NodeListItem* CurItem = (NodeListItem*)(pNodeList->GetHead());
while (CurItem)
{
Node* pNode = CurItem->pNode;
// Make sure the current owner Layer is told about the changes
// and given the chance to release any cached info it may be
// holding about the selected object
// (I know that the original position coincides with the destination position
// but this is hte simplest way to get the original parent layer uncached
// and to get a record in the undo history so that the layer cacheing will
// be dealt with properly during gundo/redo)
DoInvalidateNodeRegion((NodeRenderableBounded*) pNode, TRUE, FALSE);
// localise attribs for this node
DoLocaliseForAttrChange((NodeRenderableInk*) pNode, (AttrTypeSet *)NULL, (ObjectSet*) NULL);
DoMoveNode(pNode, pTail, TailAttachDirection);
// factor out common attribs
if (pNode->IsCompound())
DoFactorOutCommonChildAttributes((NodeRenderableInk*) pNode);
else
DoFactorOutAfterAttrChange((NodeRenderableInk*) pNode, (AttrTypeSet *)NULL);
// make the nodes region be redrawn
DoInvalidateNodeRegion((NodeRenderableBounded*) pNode, TRUE, FALSE);
CurItem = (NodeListItem*)(pNodeList->GetNext(CurItem));
}
// delete the the list objects
pNodeList->DeleteAll();
delete pNodeList;
// the selection will have changed - after all we just deleted it
BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED));
GetApplication()->UpdateSelection();
ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this);
UpdateChangedNodes(&ObjChange);
// end the op
End();
// update the bars
DialogBarOp::SetSystemStateChanged();
DialogBarOp::UpdateStateOfAllBars();
}
else
{
// give up and go home
FailAndExecute();
End();
}
}
/********************************************************************************************
> BOOL MakeBitmapFilter::InsertBitmapIntoDocument(UndoableOperation *pOp, KernelBitmap* KernelBmp, Document* DestDoc)
Author: Will_Cowling (Xara Group Ltd) <*****@*****.**>
Created: 11/6/96
Purpose: Exports the current selection as a bitmap, via the virtual fns of the
inherited class.
Returns: TRUE if worked, FALSE if failed.
SeeAlso: GetExportOptions; PrepareToExport; ExportRenderNodes; CleanUpAfterExport;
********************************************************************************************/
BOOL MakeBitmapFilter::InsertBitmapIntoDocument(UndoableOperation *pOp, KernelBitmap* KernelBmp, Document* DestDoc)
{
Spread *pSpread;
DocCoord Origin;
// Remember the selection rect, before we change it
DocRect SelRect = GetApplication()->FindSelection()->GetBoundingRect();
// For now, position Draw objects on 1st page of spread 1
PORTNOTE("spread", "Multi-spread warning!")
pSpread = GetFirstSpread(DestDoc);
Page *pPage = (Page *) pSpread->FindFirstPageInSpread();
ERROR3IF(!pPage->IsKindOf(CC_RUNTIME_CLASS(Page)),
"MakeBitmapFilter::InsertBitmapIntoDocument: Could not find first Page");
// Use bottom left of page as origin
DocRect PageRect = pPage->GetPageRect();
Origin.x = PageRect.lo.x;
Origin.y = PageRect.hi.y;
// Get a new NodeBitmap object to import into.
NodeBitmap *pNodeBitmap = new NodeBitmap;
if ((pNodeBitmap == NULL) || (!pNodeBitmap->SetUpPath(12,12)))
return FALSE;
// Attach the Imported Bitmap to our Node
pNodeBitmap->GetBitmapRef()->Attach(KernelBmp, DestDoc); //GetDocument());
if (pNodeBitmap->GetBitmap() != KernelBmp)
delete KernelBmp; // It didn't use the bitmap we gave it, so we can delete it
// Import worked - try to add the bitmap object into the tree.
// First, set the rectangle to the right size for the bitmap...
BitmapInfo Info;
pNodeBitmap->GetBitmap()->ActualBitmap->GetInfo(&Info);
DocRect BoundsRect;
BoundsRect.lo = Origin;
BoundsRect.hi.x = BoundsRect.lo.x + Info.RecommendedWidth;
BoundsRect.hi.y = BoundsRect.lo.y + Info.RecommendedHeight;
// And set this in our bitmap node
pNodeBitmap->CreateShape(BoundsRect);
// Make sure that there is a layer to put the bitmap onto
if (!MakeSureLayerExists(DestDoc))
{
// There is no layer and one could not be made, so we will have to fail
delete pNodeBitmap;
return FALSE;
}
// Set the default attrs
// This MUST be done before the NodeBitmap is Inserted into the tree
if (!pNodeBitmap->ApplyDefaultBitmapAttrs(pOp))
return FALSE;
// Insert the node, but don't invalidate its region
if (!pOp->DoInsertNewNode(pNodeBitmap, pSpread, FALSE))
{
// It didn't work - delete the sub-tree we just created, and report error.
delete pNodeBitmap;
return FALSE;
}
// bitmap is currently positioned so its bottom left hand
// corner is at the top left of the page
// By default we'll move it down so the top-left of the bitmap is on the top-left of the page
INT32 XTranslate = 0;
INT32 YTranslate = -Info.RecommendedHeight;
ClickModifiers ClickMods = ClickModifiers::GetClickModifiers();
if (ClickMods.Adjust && !SelRect.IsEmpty())
{
// If shift is down, then we'll try and place the bitmap exactly on top of the selection
DocCoord SelectionCentre(SelRect.lo.x + (SelRect.Width()/2), SelRect.lo.y + (SelRect.Height()/2));
XTranslate = SelectionCentre.x - Origin.x - (Info.RecommendedWidth/2);
YTranslate = SelectionCentre.y - Origin.y - (Info.RecommendedHeight/2);
}
else
{
// Otherwise we'll try and centre it within the current view
Spread* pCurrentSpread;
DocCoord ViewCentre;
if (FindCentreInsertionPosition(&pCurrentSpread, &ViewCentre))
{
/* Karim 19/01/2000
* Ensure that the bmp is pixel-aligned as close to the centre as possible.
*
XTranslate = ViewCentre.x - Origin.x - (Info.RecommendedWidth/2);
YTranslate = ViewCentre.y - Origin.y - (Info.RecommendedHeight/2);
/**/
DocCoord PixAlignBmpOrigin( ViewCentre.x - Info.RecommendedWidth/2,
ViewCentre.y - Info.RecommendedHeight/2 );
INT32 FullDPI = GRenderRegion::GetDefaultDPI();
MILLIPOINT PixWidth = (INT32)((IN_MP_VAL / (double)FullDPI) + 0.5);
PixAlignBmpOrigin.x -= PixAlignBmpOrigin.x % PixWidth;
PixAlignBmpOrigin.y -= PixAlignBmpOrigin.y % PixWidth;
XTranslate = PixAlignBmpOrigin.x - Origin.x;
YTranslate = PixAlignBmpOrigin.y - Origin.y;
}
}
Trans2DMatrix Xlate(XTranslate, YTranslate);
pNodeBitmap->Transform(Xlate);
// Ensure Sel Bounds are correct after translation
GetApplication()->UpdateSelection();
return TRUE;
}
BOOL ScreenCamView::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)
{
if (!m_DropFormatOK || pDataObject == NULL)
return FALSE;
// Document* pSelDoc = Document::GetSelected();
Document* pClipDoc = InternalClipboard::Instance();
if (pClipDoc != NULL)
{
Document::SetSelectedViewAndSpread(pClipDoc);
pClipDoc->ResetInsertionPosition();
pClipDoc->SetCurrent();
// If there is *still* a format on the external clip board we like, then it's ok to drop
CLIPFORMAT ClipFormat = ExternalClipboard::GetBestPasteFormat(pDataObject);
ExternalClipboard* pExtClipBoard = ExternalClipboard::GetExternalClipboard();
if (ClipFormat != 0 && pExtClipBoard !=NULL && pExtClipBoard->PrepareForOlePaste(pDataObject))
{
Document::SetSelectedViewAndSpread(GetDocument()->GetKernelDoc(),GetDocViewPtr());
DocView *pDocView = DocView::GetCurrent();
if (pDocView != NULL)
{
// Make the drop point a WinCoord so we can turn it into an oil coord
WinCoord DropPoint(point.x,point.y);
// Turn it into Oil coordinates...
OilCoord OilPos = DropPoint.ToOil(pDocView);
// Find the spread that contains the coord
Spread* pSpread = pDocView->FindEnclosingSpread(OilPos);
if (pSpread != NULL)
{
// First of all convert the OilCoord into device coords
DocCoord Centre = OilPos.ToDoc(pSpread, pDocView);
// Translate the coord to spread coords
pSpread->DocCoordToSpreadCoord(&Centre);
// 'Centre' now contains the centre point for the paste, in spread coords
TRY
{
// Wrap all this in a TRY/CATCH block so that if OLE throws a wobbly, we can
// ensure that the clipboard remains intacted on exit.
// Copy the selection to the drag'n'drop clipboard.
OpDescriptor* pOp = OpDescriptor::FindOpDescriptor(OPTOKEN_PASTE);
ERROR3IF(!pOp, "No paste operation in ScreenCamView::OnDrop");
if (pOp != NULL)
{
Document::SetSelectedViewAndSpread(pClipDoc);
pClipDoc->SetCurrent();
pClipDoc->ResetInsertionPosition();
InsertionNode* pInsertNode = pClipDoc->GetInsertionPosition();
if (pInsertNode != NULL)
{
pInsertNode->UnlinkNodeFromTree();
delete pInsertNode;
pInsertNode = NULL;
}
Document::SetSelectedViewAndSpread(GetDocument()->GetKernelDoc(),GetDocViewPtr());
// create a param object that contains the centre point in the spread at which
// we would like the objects to be pasted
OpParamPasteAtPosition Param(pSpread,Centre);
// Call the paste op via its DoWithParams() funtion
pOp->Invoke(&Param);
}
}
CATCH_ALL(e)
{
if (m_ClipBoardSwapped = FALSE)
{
// TRACEUSER( "Markn", _T("Swapping back to clipboard doc (Catch in ScreenCamView::OnDrop())\n"));
InternalClipboard::Swap();
ExternalClipboard::UpdateSystemClipboard(TRUE);
}
THROW_LAST();
}
END_CATCH_ALL
}
void BitmapEffectAtom::Test2(UndoableOperation * Op)
{
BOOL CarryOn=TRUE;
Range Sel(*(GetApplication()->FindSelection()));
Node* FirstSelectedNode = Sel.FindFirst();
if (FirstSelectedNode != NULL) // No nodes selected so End
{
Node* CurrentNode = FirstSelectedNode;
Node* NextCurrent;
// Do all bitmaps
while ((CurrentNode != NULL) && CarryOn)
{
NextCurrent = Sel.FindNext(CurrentNode);
if ( (CurrentNode->IsSelected()) && (CurrentNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeBitmap)) )
{
KernelBitmap * pBitmap = ((NodeBitmap *)(CurrentNode))->GetBitmap();
BitmapInfo BMInfo;
UINT32 bpp;
pBitmap->ActualBitmap->GetInfo(&BMInfo);
bpp=BMInfo.PixelDepth;
TRACEUSER( "Alex", _T("Bitmap found %d bpp\n"),bpp);
if ((bpp==32) || TRUE)
{
CarryOn = FALSE;
NodeBitmap *pNodeBitmap = new NodeBitmap;
if ((pNodeBitmap == NULL) || (!pNodeBitmap->SetUpPath(12,12)))
return;
Spread *pSpread;
DocCoord Origin;
// For now, position Draw objects on 1st page of spread 1
Node *pNode = (Document::GetSelected())->GetFirstNode()->FindNext()->FindFirstChild();
while ((pNode != NULL) && (!pNode->IsKindOf(CC_RUNTIME_CLASS(Chapter))))
pNode = pNode->FindNext();
ENSURE(pNode->IsKindOf(CC_RUNTIME_CLASS(Chapter)),
"Filter::GetFirstSpread(): Could not find Chapter");
Chapter *pChapter = (Chapter *) pNode;
// pSpread is a child of pChapter
pSpread = (Spread *) pChapter->FindFirstChild();
ENSURE(pSpread->IsKindOf(CC_RUNTIME_CLASS(Spread)),
"Filter::GetFirstSpread(): Could not find Spread");
Page *pPage = (Page *) pSpread->FindFirstPageInSpread();
ENSURE(pPage->IsKindOf(CC_RUNTIME_CLASS(Page)),
"BaseBitmapFilter::DoImport(): Could not find first Page");
// Use bottom left of page as origin
DocRect PageRect = pPage->GetPageRect();
Origin = PageRect.lo;
KernelBitmap* kb = new KernelBitmap(BMInfo.PixelWidth,BMInfo.PixelHeight,32,100);
// Get a new bitmap object for this node.
pNodeBitmap->GetBitmapRef()->Attach(kb);
if (pNodeBitmap->GetBitmap() != kb)
{
// It didn't use the bitmap we gave it, so we can delete it
delete kb;
}
ENSURE(pNodeBitmap->GetBitmap()->ActualBitmap != NULL, "No bitmap object found!");
// Import worked - try to add the bitmap object into the tree.
// First, set the rectangle to the right size for the bitmap...
BitmapInfo Info;
pNodeBitmap->GetBitmap()->ActualBitmap->GetInfo(&Info);
DocRect BoundsRect;
BoundsRect.lo = Origin;
BoundsRect.hi.x = BoundsRect.lo.x + Info.RecommendedWidth;
BoundsRect.hi.y = BoundsRect.lo.y + Info.RecommendedHeight;
// And set this in our bitmap node
pNodeBitmap->CreateShape(BoundsRect);
// Apply some default attrs for the bitmap
// This Must be done before the NodeBitmap is inserted into the tree
if (!pNodeBitmap->ApplyDefaultBitmapAttrs(Op))
{
return;
}
// Insert the node, but don't invalidate its region
if (!Op->DoInsertNewNode(pNodeBitmap, pSpread, FALSE))
{
// It didn't work - delete the sub-tree we just created, and report error.
delete pNodeBitmap;
return;
}
// Invalidate the region
Op->DoInvalidateNodeRegion(pNodeBitmap, TRUE, FALSE);
// Right, now we're going to do some processing...
BitmapEffectBase * pEffect;
pEffect=new /*TestBitmapEffect*/ BitmapEffectSILT;
pEffect->SetParameters();
pEffect->SetSourceImage(pBitmap);
pEffect->UseDestinationBitmap(pNodeBitmap->GetBitmap());
pEffect->Run();
pEffect->UseDestinationBitmap(NULL);
delete(pEffect);
}
}
CurrentNode = NextCurrent;
}
}
// if (CarryOn) BitmapEffectSILT::RunA();
return;
}
void OpAlign::DoWithParam(OpDescriptor* pOp, OpParam* pAlignParam)
{
// DMc alterations so that this works with compound nodes
SelRange Selection(*(GetApplication()->FindSelection()));
RangeControl rg = Selection.GetRangeControlFlags();
rg.PromoteToParent = TRUE;
Selection.Range::SetRangeControl(rg);
DocRect SelRect = Selection.GetBoundingRect();
DocRect TargetRect;
TargetRect.MakeEmpty();
INT32 NumObjs = Selection.Count();
AlignParam* pAlign =(AlignParam*)pAlignParam;
BOOL moved=FALSE; // set to TRUE if any object is moved
BeginSlowJob(-1,FALSE);
BOOL OK=DoStartTransOp(FALSE);
// find parent spread of first object in selection
Node* pFirstNode=NULL;
Spread* pSpread =NULL;
if (OK)
{
pFirstNode=Selection.FindFirst();
if (pFirstNode!=NULL)
pSpread=pFirstNode->FindParentSpread();
OK=(pSpread!=NULL);
if (!OK)
ERROR2RAW("OpAlign::DoWithParam() - could not find parent spread");
}
// Find the size of the target rectangle
if (pAlign->target==ToSelection)
TargetRect=SelRect;
else
{
Page* pPage=pSpread->FindFirstPageInSpread();
while (pPage)
{
DocRect PageRect=pPage->GetPageRect();
if (pAlign->target==ToSpread || SelRect.IsIntersectedWith(PageRect))
TargetRect=TargetRect.Union(PageRect);
pPage=pPage->FindNextPage();
}
}
// allocate all dynamic memory required
Node** pObj=NULL;
ObjInfo* x =NULL;
ObjInfo* y =NULL;
INT32* dx =NULL;
INT32* dy =NULL;
if (OK) ALLOC_WITH_FAIL(pObj,(Node**) CCMalloc(NumObjs*sizeof(Node*)), this);
if (pObj!=NULL) ALLOC_WITH_FAIL(x, (ObjInfo*)CCMalloc(NumObjs*sizeof(ObjInfo)),this);
if ( x!=NULL) ALLOC_WITH_FAIL(y, (ObjInfo*)CCMalloc(NumObjs*sizeof(ObjInfo)),this);
if ( y!=NULL) ALLOC_WITH_FAIL(dx, (INT32*) CCMalloc(NumObjs*sizeof(INT32)), this);
if ( dx!=NULL) ALLOC_WITH_FAIL(dy, (INT32*) CCMalloc(NumObjs*sizeof(INT32)), this);
OK=(dy!=NULL);
// if memory claimed OK and target rect not empty proceed with op
// (ie. do nothing if 'within page(s)' when no object on a page)
DocRect EmptyRect;
if (OK && TargetRect!=EmptyRect)
{
// create an array of pointers to objects (nodes) to be affected
Node* pNode=Selection.FindFirst();
INT32 i=0;
while (pNode!=NULL)
{
if (pNode->IsBounded() && !((NodeRenderableBounded*)pNode)->GetBoundingRect(TRUE).IsEmpty())
pObj[i++]=pNode;
pNode=Selection.FindNext(pNode);
}
NumObjs=i;
// cache x & y info in separate arrays so they can be sorted separately
XLONG SumObjWidths =0;
XLONG SumObjHeights=0;
for (i=0; i<NumObjs; i++)
{
DocRect ObjRect=((NodeRenderableBounded*)pObj[i])->GetBoundingRect();
x[i].i=i;
x[i].lo=ObjRect.lo.x;
x[i].hi=ObjRect.hi.x;
SumObjWidths+=ObjRect.hi.x-ObjRect.lo.x;
y[i].i=i;
y[i].lo=ObjRect.lo.y;
y[i].hi=ObjRect.hi.y;
SumObjHeights+=ObjRect.hi.y-ObjRect.lo.y;
}
// for each object, calculate the x and y displacements independently
AlignOneAxis(pAlign->h,NumObjs,SumObjWidths, TargetRect.lo.x,TargetRect.hi.x,x,dx);
AlignOneAxis(pAlign->v,NumObjs,SumObjHeights,TargetRect.lo.y,TargetRect.hi.y,y,dy);
// apply the x and y displacements simultaneously to each object
for (i=0; i<NumObjs; i++)
if (dx[i]!=0 || dy[i]!=0)
{
moved=TRUE;
Trans2DMatrix* pMatrix=new Trans2DMatrix(dx[i],dy[i]);
DoTransformNode((NodeRenderableInk*)pObj[i],pMatrix);
}
}
// free up any memory which was allocated
CCFree(dx);
CCFree(dy);
CCFree(x);
CCFree(y);
CCFree(pObj);
if (moved)
{
Document::GetSelected()->ForceRedraw(pSpread, TargetRect);
GetApplication()->UpdateSelection();
}
else
FailAndExecute();
End();
EndSlowJob();
}