void OpException::Do(OpDescriptor* WhichOp)
{
if (WhichOp->Token == String( OPTOKEN_EXCEPTION_PTR) )
GlobalByte = *lpByte;
else if (WhichOp->Token == String( OPTOKEN_EXCEPTION_INT ) )
iZero[1] = 1 / iZero[0];
else if (WhichOp->Token == String( OPTOKEN_EXCEPTION_DBL ) )
dZero[1] = 1 / dZero[0];
else
{
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
{
pDocView->ForceRedraw(); // posts the paint message
CWindowID pWnd = DocView::GetCurrentRenderWindow();
if (pWnd)
{
// Set trap for later
RenderTrap = TRUE;
// Now do the paint
TRACE( _T("Into update explosion\n"));
pWnd->Update(); // do the paint
TRACE( _T("Out of update explosion\n"));
}
}
}
}
void OpPush::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
{
DocView* pDocView = DocView::GetSelected();
ENSURE( pDocView != NULL, "OpPush::DragPointerMove - DocView was NULL" );
if (pDocView==NULL)
return;
// Declare a few WorkCoords we will need
WorkCoord ScrollOffsets;
WorkCoord Change;
WorkCoord MoveClick = pDocView->GetClickWorkCoord();
// How Much has it changed
Change.x = AnchorPoint.x - MoveClick.x;
Change.y = AnchorPoint.y - MoveClick.y;
// Find the Scroll Offsets and change them
ScrollOffsets = pDocView->GetScrollOffsets();
ScrollOffsets.x += Change.x;
ScrollOffsets.y += Change.y;
// Make sure the ScrollOffsets are valid and then set them
if ( ScrollOffsets.x < 0 ) ScrollOffsets.x = 0;
if ( ScrollOffsets.y > 0 ) ScrollOffsets.y = 0;
pDocView->SetScrollOffsets( ScrollOffsets, TRUE );
}
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;
}
BOOL ThumbnailFilterPNG::DoExport(Operation* pOp, CCLexFile* pFile, PathName* pPath,
Document* TheDocument, BOOL ShowOptions)
{
// set ourselves up - this flags the BaseBitmapFilter to do resizing, which needs to be
// done there because of Accusoft.
SetPreviewBitmap(TRUE);
// create a new view for the document
DocView *pView = new DocView(TheDocument);
if (pView && pView->Init())
{
// set the view as current, but remember the last current one
View *pOldView = View::GetCurrent();
pView->SetCurrent();
// Export the thumbnail to the file by doing what our base class does
BOOL ok = PNGFilter::DoExport(pOp, pFile, pPath, TheDocument, TRUE);
// restore the last view
if (pOldView != NULL)
pOldView->SetCurrent();
else
View::SetNoCurrent();
// delete our view
delete pView;
return ok;
}
else
return FALSE; // view creation failed
}
void PreviewEditorWindow::onWindowResize()
{
Window::onWindowResize();
DocView* view = UIContext::instance()->activeView();
if (view)
updateUsingEditor(view->editor());
}
/********************************************************************************************
> BOOL MakeBitmapFilter::FindCentreInsertionPosition(Spread** Spread, DocCoord* Position)
Author: Will_Cowling (Xara Group Ltd) <*****@*****.**> (from Simon)
Created: 12/6/96
Inputs: -
Outputs: Spread: The spread to place the clipboard objects on
Position:The centre of the view (Spread coords)
Purpose: Finds the centre insertion position for clipboard objects
********************************************************************************************/
BOOL MakeBitmapFilter::FindCentreInsertionPosition(Spread** Spread, DocCoord* Position)
{
// ---------------------------------------------------------------------------------
// Find out which spread is in the centre of the view
// this is the spread that the pasted objects will be placed on
// Obtain the current DocView
DocView* CurDocView = DocView::GetCurrent();
ENSURE(CurDocView != NULL, "The current DocView is NULL");
if (CurDocView == NULL)
return FALSE; // No DocView
// Get the view rect
WorkRect WrkViewRect = CurDocView->GetViewRect();
if (WrkViewRect.IsEmpty() || (!WrkViewRect.IsValid()) )
return FALSE; // Defensive
// Determine the centre of the view
WorkCoord WrkCentreOfView;
WrkCentreOfView.x = WrkViewRect.lox + (WrkViewRect.Width()/2);
WrkCentreOfView.y = WrkViewRect.loy + (WrkViewRect.Height()/2);
// FindEnclosing spread requires an OilCoord
OilCoord OilCentreOfView = WrkCentreOfView.ToOil(CurDocView->GetScrollOffsets());
// Find out which spread to insert the pasteboard objects onto
(*Spread) = CurDocView->FindEnclosingSpread(OilCentreOfView);
if ((*Spread) == NULL)
return FALSE; // There is no spread
// Phew
// ---------------------------------------------------------------------------------
// Now lets find the spread coordinate of the centre of the view
DocRect DocViewRect = CurDocView->GetDocViewRect(*Spread);
if ( DocViewRect.IsEmpty() || (!DocViewRect.IsValid()) )
{
ERROR3("DocViewRect is invalid");
return FALSE; // Defensive
}
// Find the centre of the DocViewRect
DocCoord DocCentreOfView;
DocCentreOfView.x = DocViewRect.lox + (DocViewRect.Width()/2);
DocCentreOfView.y = DocViewRect.loy + (DocViewRect.Height()/2);
// --------------------------------------------------------------------------------
// Now convert from DocCoords to spread coords
DocRect PhysSpreadRect = (*Spread)->GetPasteboardRect();
(*Position).x = DocCentreOfView.x - PhysSpreadRect.lo.x;
(*Position).y = DocCentreOfView.y - PhysSpreadRect.lo.y;
return TRUE;
}
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 OpSnapToGuides::Do(OpDescriptor*)
{
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
pDocView->SetSnapToGuidesState(!pDocView->GetSnapToGuidesState());
End();
}
OpState OpShowGrid::GetState(String_256*, OpDescriptor*)
{
OpState OpSt;
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
OpSt.Ticked = pDocView->GetShowGridState();
return OpSt;
}
OpState OpSnapToObjects::GetState(String_256*, OpDescriptor*)
{
OpState OpSt;
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
OpSt.Ticked = pDocView->GetSnapToObjectsState();
return OpSt;
}
KernelBitmap* SGNameDrag::MakeImage(UINT32 nDepth)
{
// If there's no current View, or no Spread, then fail.
DocView* pView = DocView::GetCurrent();
if (pView == 0) return 0;
Spread* pSpread = pView->FindEnclosingSpread(OilCoord(0, 0));
if (pSpread == 0) return 0;
// Create a device context for the display.
CDC sdc;
sdc.CreateDC("DISPLAY", 0, 0, 0);
// Calculate the size of the rendering and set up the rendering matrix etc.
Matrix matConvert;
FIXED16 fxScale = 1;
INT32 nSel = NameGallery::Instance()->GetSelectedItemCount();
DocRect drClip(0, 0, SG_DefaultNameText, nSel * SG_DefaultSmallIcon);
// Work out the destination bitmap's characteristics.
double dpi = (double) GetDeviceCaps(sdc.m_hDC, LOGPIXELSX);
if (nDepth == 0)
nDepth = GetDeviceCaps(sdc.m_hDC, BITSPIXEL) * GetDeviceCaps(sdc.m_hDC, PLANES);
// Create a render region with the given properties of the display etc.
GRenderBitmap* pRenderer = new GRenderBitmap(drClip, matConvert, fxScale, nDepth, dpi);
ERRORIF(pRenderer == 0, _R(IDE_NOMORE_MEMORY), 0);
pRenderer->AttachDevice(pView, &sdc, pSpread);
pRenderer->StartRender();
pRenderer->SaveContext();
// Blank the background.
pRenderer->SetLineWidth(0);
pRenderer->SetLineColour(COLOUR_WHITE);
pRenderer->SetFillColour(COLOUR_WHITE);
pRenderer->DrawRect(&drClip);
// Render the item's name.
DocColour dcText(COLOUR_BLACK), dcBack(COLOUR_WHITE);
pRenderer->SetFixedSystemTextColours(&dcText, &dcBack);
String_256 strName;
m_pSourceItem->GetNameText(&strName);
pRenderer->DrawFixedSystemText(&strName, drClip);
// Create a kernel bitmap from the OIL bitmap and return it.
pRenderer->RestoreContext();
pRenderer->StopRender();
OILBitmap* pOilMaskBmp = pRenderer->ExtractBitmap();
delete pRenderer;
KernelBitmap* pkb = new KernelBitmap(pOilMaskBmp, TRUE);
ERRORIF(pkb == 0, _R(IDE_NOMORE_MEMORY), 0);
return pkb;
}
void OpShowGrid::Do(OpDescriptor*)
{
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
{
if (Tool::GetCurrentID() != TOOLID_GRID)
NodeGrid::ForceRedrawAllGrids();
pDocView->SetShowGridState(!pDocView->GetShowGridState());
}
End();
}
gfx::Point MoveThing::getDelta(Context* context) const
{
gfx::Point delta(0, 0);
DocView* view = static_cast<UIContext*>(context)->activeView();
if (!view)
return delta;
DocumentPreferences& docPref = Preferences::instance().document(view->document());
Editor* editor = view->editor();
gfx::Rect vp = view->viewWidget()->viewportBounds();
gfx::Rect gridBounds = docPref.grid.bounds();
int pixels = 0;
switch (units) {
case Pixel:
pixels = 1;
break;
case TileWidth:
pixels = gridBounds.w;
break;
case TileHeight:
pixels = gridBounds.h;
break;
case ZoomedPixel:
pixels = editor->zoom().apply(1);
break;
case ZoomedTileWidth:
pixels = editor->zoom().apply(gridBounds.w);
break;
case ZoomedTileHeight:
pixels = editor->zoom().apply(gridBounds.h);
break;
case ViewportWidth:
pixels = vp.h;
break;
case ViewportHeight:
pixels = vp.w;
break;
}
switch (direction) {
case Left: delta.x = -quantity * pixels; break;
case Right: delta.x = +quantity * pixels; break;
case Up: delta.y = -quantity * pixels; break;
case Down: delta.y = +quantity * pixels; break;
}
return delta;
}
KernelBitmap* GalleryLineDragInfo::GetSolidDragMask()
{
// Note we abuse this call (like our base class abuses this call) to create the bitmap
// itself. We don't use DragMask itself anymore (i.e. it stays NULL)
if (!DragMask && !TheBitmap)
{
DocView *View = DocView::GetCurrent();
if (View == NULL)
{
return NULL;
}
Spread *pSpread = View->FindEnclosingSpread(OilCoord(0,0));
if (pSpread == NULL)
{
return NULL;
}
// Find the size of the rendered item.
DocRect ClipRegion(0,0, 750*100, 750*50);
// ClipRegion.lo.x = ClipRegion.lo.y = 0;
// SourceItem->GetSize(c_eLineAttrDragTextPos, &ClipRegion.hi.x, &ClipRegion.hi.y);
Matrix ConvertMatrix;
FIXED16 ViewScale = 1;
wxScreenDC DisplayDC;
double dpi = (double) OSRenderRegion::GetFixedDCPPI(DisplayDC).GetWidth();
GRenderBitmap* pMaskRegion = new GRenderBitmap(ClipRegion, ConvertMatrix, ViewScale,
32, dpi);
pMaskRegion->SetDoCompression(TRUE); // misnamed call to indicate we want transparency
pMaskRegion->AttachDevice(View, &DisplayDC, pSpread);
// Make a Mask Bitmap
pMaskRegion->StartRender();
SourceItem->Render(pMaskRegion, ClipRegion, c_eLineAttrDragTextPos);
pMaskRegion->StopRender();
OILBitmap* pOilMaskBmp = pMaskRegion->ExtractBitmap();
TheBitmap = new KernelBitmap(pOilMaskBmp, TRUE);
delete pMaskRegion;
}
return BitmapDragInformation::GetSolidDragMask();
}
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();
}
void OpSnapToObjects::Do(OpDescriptor*)
{
DocView *pDocView = DocView::GetSelected();
if (pDocView != NULL)
{
// Find out the new value for the magnetic snapping
BOOL NewState = !pDocView->GetSnapToObjectsState();
pDocView->SetSnapToObjectsState(NewState);
// update all slider controls that show the view quality
OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_SNAPTOOBJECTS);
if (pOpDesc!=NULL)
{
// Found the opdescriptor. Now find all the gadgets associated with it
List Gadgets;
if (pOpDesc->BuildGadgetList(&Gadgets))
{
// Found some. Set the controls position according to the quality
GadgetListItem* pGadgetItem = (GadgetListItem*) Gadgets.GetHead();
while (pGadgetItem!=NULL)
{
// Set the sliders position
pGadgetItem->pDialogOp->SetLongGadgetValue(pGadgetItem->gidGadgetID, NewState, FALSE);
// go find the next gadget
pGadgetItem = (GadgetListItem*) Gadgets.GetNext(pGadgetItem);
}
// Clean out the list
Gadgets.DeleteAll();
}
}
}
End();
}
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 ScreenCamView::OnSize( wxSizeEvent &event )
{
// This is called early, so if pDocView is null do nothing
if( NULL == pDocView )
return;
SetCurrentStates();
Document* pCurDoc = Document::GetCurrent();
DocView* pCurView = DocView::GetCurrent();
// these lines are here to stop very strange things happening on exit under Win32s
// when this fn gets called when it really shouldn't. I would like to really know
// just what on earth os going on under Win32s but it iss something strange in message
// handling as far as I can tell.
wxSize size( event.GetSize() );
// Check for irrelevant or potty messages.
if (size.x <= 0 || size.y <= 0)
{
// TRACEUSER( "JustinF", _T("Strange size msg in ScreenView::OnSize(0x%X, %d, %d)\n"),
// nType, cx, cy);
return;
}
// Handle OLE 2.0 in-place activation stuff.
#if (_OLE_VER >= 0x200)
if(GetDocument())
{
COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
if (pActiveItem) pActiveItem->SetItemRects();
}
#endif
if (Status->ScrollersVisible)
{
PORTNOTETRACE( "other", "ScreenCamView::OnSize - Removed scroller usage" );
#if !defined(EXCLUDE_FROM_XARALX)
// Resize and reposition the proportional scrollers.
wxRect hrect, vrect;
HScrollBar->CalcPosFromParentClient(&hrect);
UINT32 RulerWidth = OILRuler::GetWidth();
//if rulers are switched on the scroll bars are made
// smaller to accomodate them
if (Status->RulersVisible)
hrect.left += RulerWidth;
if (RULER_BORDERS)
hrect.left-=2;
HScrollBar->MoveWindow(&hrect, TRUE);
VScrollBar->CalcPosFromParentClient(&vrect);
if (Status->RulersVisible)
vrect.top += RulerWidth;
if (RULER_BORDERS)
vrect.top-=2;
VScrollBar->MoveWindow(&vrect, TRUE);
// Reposition the corner window at the bottom-right.
Corner->MoveWindow(vrect.left, hrect.top, vrect.Width(), hrect.Height());
// Resize/reposition the rendering window.
CurrentSize.left = CurrentSize.top = 0;
CurrentSize.right = cx - vrect.Width() + 1;
CurrentSize.bottom = cy - hrect.Height() + 1;
#endif
}
else
{
CurrentSize.x = CurrentSize.y = 0;
CurrentSize.width = size.x;
CurrentSize.height = size.y;
}
if (Status->RulersVisible)
{
PORTNOTETRACE( "other", "ScreenCamView::OnSize - Removed scroller / ruler usage" );
#if !defined(EXCLUDE_FROM_XARALX)
wxRect hRect, vRect, oRect;
HRuler->CalcPosFromParentClient(&hRect);
HRuler->MoveWindow(&hRect, TRUE);
HRuler->PositionLegend();
CurrentSize.top = 0 + hRect.Height() ;
VRuler->CalcPosFromParentClient(&vRect);
VRuler->MoveWindow(&vRect, TRUE);
CurrentSize.left = 0 + vRect.Width();
OGadget->CalcPosFromParentClient(&oRect);
OGadget->MoveWindow(&oRect, TRUE);
if (RULER_BORDERS)
{
CurrentSize.top --;
CurrentSize.left--;
}
#endif
}
PORTNOTE( "other", "ScreenCamView::OnSize - Removed RenderWindow usage -not sure if needed" )
#ifndef EXCLUDE_FROM_XARALX
RenderWindow->MoveWindow(&CurrentSize, TRUE);
#endif
// Update the rest of the window placement information.
UpdateViewPosition();
// Calculate the work area, page & line sizes etc etc.
FIXED16 PixelWidth, PixelHeight;
pDocView->GetPixelSize(&PixelWidth, &PixelHeight);
PORTNOTE( "other", "ScreenCamView::OnSize - Removed scroller usage" )
#if !defined(EXCLUDE_FROM_XARALX)
XLONG x1 = CurrentSize.GetWidth() * PixelWidth;
XLONG x2 = CurrentSize.GetHeight() * PixelHeight;
HScrollBar->SetPageSize(x1);
VScrollBar->SetPageSize(x2);
HScrollBar->SetLineSize(x1 / xlong(10) + xlong(1));
VScrollBar->SetLineSize(x2 / xlong(10) + xlong(1));
#endif
SetWorkAreaExtent(Status->WorkAreaExtent, FALSE);
// Make sure the scroll offsets are valid - if we resize the bottom of the window
// when at the extreme bottom of the view, then the scroll offsets should be
// changed - we use the scrollers' own integrity checks to do this automatically.
// Don't do this until the setup flag is TRUE, so we don't overwrite scroll offsets
// that have been reloaded.
if (fSetupDone)
{
WorkCoord CurrScrollPos;
GetScrollOffset(&CurrScrollPos);
SetScrollOffset(CurrScrollPos, TRUE);
}
// Inform the associated DocView object that something has happened.
pDocView->ViewStateChanged();
pCurDoc->SetCurrent();
pCurView->SetCurrent();
}
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
}
