static void ObjInitObject(LPOBJECT lpObject, LPFRAME lpFrame, LPMASK lpAlpha, BOOL NoUndo) /************************************************************************/ { PixmapSetup(&lpObject->Pixmap, lpFrame, NoUndo); lpObject->lpAlpha = lpAlpha; lpObject->DataUndoType = 0; lpObject->DataUndoNotRedo = YES; lpObject->DataDirty = NO; lpObject->AlphaUndoType = 0; lpObject->AlphaUndoNotRedo = YES; lpObject->AlphaDirty = NO; lpObject->fBothDirty = NO; lpObject->lpUndoAlpha = NULL; AstralSetRectEmpty(&lpObject->rUndoObject); lpObject->UndoResolution = 0; lpObject->fUndoSelected = NO; lpObject->fTransform = NO; AstralSetRectEmpty(&lpObject->rTransform); lpObject->fPasteIntoMask = NO; lpObject->fUndoDeleted = NO; lpObject->fUndoFailed = NoUndo; lpObject->InitUndoType = 0; lpObject->UndoColorMap = NULL; lpObject->bLocked = NO; lpObject->lpUndoText = NULL; lpObject->lpText = NULL; lpObject->dwObjectID = 0; lpObject->szObjectName[0] = '\0'; }
LOCAL void ZoomBox_OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags) /***********************************************************************/ { BOOL fRButton; POINT pt; if ( !fCapture ) return; fRButton = keyFlags & MK_RBUTTON; if (!fSelection) { if (!IsOnImage(hWnd, x, y)) return; if (fSelection = (abs(StartPoint.x-x) > SMALL_MOVEMENT || abs(StartPoint.y-y) > SMALL_MOVEMENT)) { AstralUpdateWindow(hWnd); AstralSetRectEmpty( &SelectRect ); StartSelection( hWnd, NULL, &SelectRect, SL_BOX|SL_SPECIAL|SL_NOLIMIT, StartPoint, 0L ); } } if (fSelection) { pt.x = x; pt.y = y; UpdateSelection( hWnd, NULL, &SelectRect, SL_BOX|SL_NOLIMIT, pt, CONSTRAINASPECT, lAspectX, lAspectY, MOVEKEY||fRButton,FROMCENTER); } }
//======================================================================= // Gets the max bounds for the poly list. // If there are no polygons or poly list then the rect is empty. //======================================================================= BOOL PolyListGetBounds(LPCPolyList lpList, LPRECT lpRect) //======================================================================= { AstralSetRectEmpty(lpRect); if (lpList) lpList->ForEach1((LPLISTPROC1)poly_get_bounds, (LONG)lpRect); return(TRUE); }
void CImage::GetGroupRect(LPOBJECT lpObject, LPRECT lpRect) { LPOBJECT lpNextObject; AstralSetRectEmpty( lpRect ); lpNextObject = GetBase(); while( lpNextObject = GetSelObject( lpNextObject ) ) { if( lpObject->wGroupID == lpNextObject->wGroupID ) AstralUnionRect( lpRect, lpRect, &lpNextObject->rObject ); } }
BOOL CChromaMask::JoinChromaMask(LPIMAGE lpImage, LPRECT lpUpdateRect) { LPOBJECT lpBase; LPMASK lpMask; RECT rDummy; RECT rMask; BOOL fNewMask = NO; BOOL fCreateMask = NO; UNDO_TYPE Type; AstralSetRectEmpty(lpUpdateRect); if (ImgGetMask(lpImage)) Type = UT_ALPHA; else { fNewMask = TRUE; Type = UT_CREATEMASK; } // get mask, create one if one does not exist lpMask = ImgGetMaskEx(lpImage, iMode==SHAPE_SUBTRACT ? OFF : ON, Control.NoUndo, &fNewMask, lpUpdateRect); if (!lpMask) return(FALSE); // if not new mask and we are allowed to create undo, initialize undo lpBase = ImgGetBase(lpImage); if (!ImgEditInit(lpImage, ET_OBJECT,Type, lpBase)) return(FALSE); EnableMarqueeEx( lpImage, NO ); // add Chroma to mask MaskAddChroma(lpImage, lpMask, &rMask, !fNewMask); AstralUnionRect(lpUpdateRect, lpUpdateRect, &rMask); // if using undo, indicate in-place editing has occurred ImgEditedObject(lpImage, lpBase, IDS_CHROMA_APPLY, fNewMask ? NULL : &rMask); // after subtractive masks we dont know area if (iMode!=SHAPE_ADD) MaskRectUpdate(lpMask, &rDummy); // get area that needs to be redisplayed, may be larger // than rUpdate because of slime if (ImgGetMaskUpdateRect(lpImage, fNewMask, NO, &rMask)) AstralUnionRect(lpUpdateRect, lpUpdateRect, &rMask); EnableMarqueeEx(lpImage, YES); return(TRUE); }
BOOL CImage::GetFloatingObjectsRect( LPRECT lpRect ) { LPOBJECT lpObject; AstralSetRectEmpty( lpRect ); if ( !(lpObject = GetNextObject(GetBase(), YES, NO) )) return( NO ); while ( lpObject ) { AstralUnionRect( lpRect, lpRect, &lpObject->rObject ); lpObject = GetNextObject(lpObject, YES, NO); } return( YES ); }
BOOL CImage::GetSelObjectRect( LPRECT lpRect, BOOL bExcludeBase ) { LPOBJECT lpObject; BOOL bFoundOne; AstralSetRectEmpty( lpRect ); bFoundOne = NO; lpObject = ( bExcludeBase ? GetBase() : NULL ); while ( lpObject = GetSelObject(lpObject) ) { AstralUnionRect( lpRect, lpRect, &lpObject->rObject ); bFoundOne = YES; } return( bFoundOne ); }
//======================================================================= // Geta the bounding rect for all the points in the rect //======================================================================= void CPoly::GetBounds(LPRECT lpBounds) //======================================================================= { int i; AstralSetRectEmpty(lpBounds); for (i=0; i<EntriesUsed;i++) { if (lpPoints[i].x == BEZIER_MARKER) continue; if (lpPoints[i].x < lpBounds->left) lpBounds->left = lpPoints[i].x; if (lpPoints[i].x > lpBounds->right) lpBounds->right = lpPoints[i].x; if (lpPoints[i].y < lpBounds->top) lpBounds->top = lpPoints[i].y; if (lpPoints[i].y > lpBounds->bottom) lpBounds->bottom = lpPoints[i].y; } }
// Gets the current mask if any. // If no mask exists then create one using fOn and fNoUndo. // bCreated is TRUE if a new mask was created. LPMASK CImage::GetMaskEx(BOOL fOn, BOOL fNoUndo, LPINT bCreated, LPRECT lpUpdateRect) { LPMASK lpMask; LPFRAME lpFrame; FRMTYPEINFO TypeInfo; FRMDATATYPE FrameType = FDT_GRAYSCALE; AstralSetRectEmpty(lpUpdateRect); if (lpMask = GetMask()) { if (bCreated) *bCreated = FALSE; return(lpMask); } lpFrame = GetBaseEditFrame(); FrameGetTypeInfo(lpFrame, &TypeInfo); if (TypeInfo.DataType == FDT_LINEART && Mask.OneBitMask) FrameType = FDT_LINEART; if (!(lpMask = MaskCreate(NULL, FrameXSize(lpFrame), FrameYSize(lpFrame), fOn, fNoUndo, FrameType))) { Message( IDS_EMEMALLOC ); return(NULL); } // sync up the resolution of the image data and the mask // don't ever rely on the mask's resolution being correct // cause other size can change the image data resolution // without changing the mask's resolution. Also, there are // other places the mask gets created without syncing up // the resolution. I am doing it here so we can begin // to track it correctly (Ted) FrameSetResolution(AlphaGetEditFrame(lpMask), FrameResolution(lpFrame)); if (bCreated) *bCreated = TRUE; if (!Control.UseMaskAndObjects) GetObjectMarqueeRect(this, lpUpdateRect); SetMask(lpMask); return(lpMask); }
void ImgEditMaskUndo( LPIMAGE lpImage ) /***********************************************************************/ { LPOBJECT lpBase; LPMASK lpMask; RECT rUndo; lpBase = ImgGetBase(lpImage); if (!lpBase->AlphaDirty) return; if (lpBase->fBothDirty) return; AstralSetRectEmpty(&rUndo); if (ImgGetMask(lpImage) && lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { RemoveMaskMarquee(lpImage); ImgGetMaskUpdateRect(lpImage, YES, NO, &rUndo); } ObjEditUndo(lpImage, lpBase, NO, YES); if (lpMask = ImgGetMask(lpImage)) { if (lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { RemoveMaskMarquee(lpImage); ImgGetMaskUpdateRect(lpImage, YES, NO, &rUndo); } else rUndo = lpMask->Pixmap.UndoRect; } if (rUndo.right >= rUndo.left) { OffsetRect(&rUndo, lpBase->rObject.left, lpBase->rObject.top); File2DispRect(&rUndo, &rUndo); AstralToWindowsRect(&rUndo); InvalidateRect(lpImage->hWnd, NULL, NO); } }
void CImage::EditMaskUndo() { LPOBJECT lpBase; LPMASK lpMask; RECT rUndo; lpBase = GetBase(); if (!lpBase->AlphaDirty) return; if (lpBase->fBothDirty) return; AstralSetRectEmpty(&rUndo); if (GetMask() && lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { RemoveMaskMarquee(this); GetMaskUpdateRect(YES, NO, &rUndo); } ObjEditUndo(lpBase, NO, YES); if (lpMask = GetMask()) { if (lpBase->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { RemoveMaskMarquee(this); GetMaskUpdateRect(YES, NO, &rUndo); } else rUndo = lpMask->Pixmap.UndoRect; } if (rUndo.right >= rUndo.left) { OffsetRect(&rUndo, lpBase->rObject.left, lpBase->rObject.top); File2DispRect(GetActiveDoc(), &rUndo, &rUndo); AstralToWindowsRect(&rUndo); InvalidateRect(GetActiveDoc(), NULL, NO); } }
LOCAL STATUS_CODE ApplyMaps(LPIMAGE lpImage, LPMAPS lpMaps, ITEMID idDirty, LPRECT lpUpdateRect, LPUPDATE_TYPE lpUpdateType) /************************************************************************/ { ENGINE Engine; FRMTYPEINFO TypeInfo; LPCOLORMAP lpColorMap; STATUS_CODE StatusCode; AstralSetRectEmpty(lpUpdateRect); *lpUpdateType = UT_NONE; ImgGetTypeInfo(lpImage, &TypeInfo); if (TypeInfo.DataType == FDT_PALETTECOLOR) { lpColorMap = FrameCopyColorMap(TypeInfo.ColorMap); if (!lpColorMap) { Message(IDS_EMEMALLOC); return(SC_MEMERROR); } ApplyMaps24((LPTR)lpColorMap->RGBData, lpColorMap->NumEntries, lpMaps); StatusCode = ApplyColorMap(lpImage, lpColorMap, FALSE, DT_NONE, idDirty); FrameDestroyColorMap(lpColorMap); if (StatusCode == SC_SUCCESS) *lpUpdateType = UT_DATATYPE; } else { SetEngineDef(&Engine); Engine.lpDataProc = (LPDATAPROC)ApplyMapsProc; Engine.lpParam = lpMaps; StatusCode = LineEngineSelObj(lpImage, &Engine, idDirty); if (!AstralIsRectEmpty(&Engine.rUpdate)) { *lpUpdateRect = Engine.rUpdate; *lpUpdateType = UT_AREA; } } return(StatusCode); }
BOOL ZoomPaint( HWND hWnd ) /************************************************************************/ { PAINTSTRUCT ps; HDC hDC; RECT rPaint; LPDISPLAY lpDisplay; LPIMAGE lpImage; hDC = BeginPaint(hWnd, &ps); lpDisplay = (LPDISPLAY)GetDisplayPtr(hWnd); lpImage = (LPIMAGE)GetImagePtr (hWnd); if (lpImage && lpDisplay) { rPaint = ps.rcPaint; AstralToWindowsRect(&rPaint); lpImage->Paint(hWnd,hDC,&rPaint,NULL); // will paint the invert box AstralSetRectEmpty(&lpDisplay->UpdateRect); } EndPaint(hWnd, &ps); return (TRUE); }
void ImgEditUndo( LPIMAGE lpImage, BOOL fEditUndo, BOOL fMaskUndo ) /***********************************************************************/ { RECT rUndo, rUndoMask, rTemp; LPOBJECT lpBase, lpObject, lpNext; BOOL fNewSize, fSetupMiniViews, fRemoveMarquee, fUndoDelete; BOOL fUndoAlpha, fUndoData; int nDeleted; LPMASK lpMask; if (!lpImage) return; // Initialize things for updating the display fNewSize = fSetupMiniViews = fUndoDelete = NO; AstralSetRectEmpty(&rUndo); AstralSetRectEmpty(&rUndoMask); // loop through objects doing undo lpBase = ImgGetBase(lpImage); lpObject = NULL; while (lpObject = ImgGetNextObjectEx(lpImage, lpObject, NO, NO, fEditUndo)) { // See if this is an object we are undoing if (fEditUndo) { // check for special undo processing of a deleted object if (lpObject->fDeleted) { if (Control.UndoObjects && !ImgIsSelectedObject(lpImage, lpBase)) continue; } else if (Control.UndoObjects && !ImgIsSelectedObject(lpImage, lpObject)) continue; } // Only handle mask undo for the base object if (fMaskUndo) { if (lpObject != lpBase || lpObject->fBothDirty || !lpObject->AlphaDirty) continue; } fUndoData = fUndoAlpha = NO; // Do preprocess for doing a data undo if (fEditUndo) { if (lpObject->DataDirty) fUndoData = YES; // See if we need to undo the alpha for this object if ((lpObject != lpBase) && lpObject->lpAlpha && lpObject->AlphaDirty) fUndoAlpha = YES; if (!fUndoData && !fUndoAlpha) continue; // check to see and undoing/redoing deleted objects will change // the select state, if so undraw the object marquee if (lpObject == lpBase && lpObject->DataUndoType & UT_DELETEOBJECTS) { fUndoDelete = YES; fRemoveMarquee = NO; nDeleted = 0; lpNext = lpObject; while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, YES)) { if (lpNext->fUndoDeleted) ++nDeleted; else if (lpNext->fDeleted && lpNext->fSelected) { fRemoveMarquee = YES; break; } } if (ImgGetSelObject(lpImage, NULL) == lpBase && !fRemoveMarquee) { if (ImgCountObjects(lpImage) - nDeleted <= 1) fRemoveMarquee = YES; } if (fRemoveMarquee) RemoveObjectMarqueeEx(lpImage, NO); } } else // fMaskUndo if (!lpObject->AlphaDirty) continue; else fUndoAlpha = YES; // do a preprocess for undoing the mask caused either by // a mask undo or by an edit function that also edits the mask if (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) || fMaskUndo) { if ( lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { // if the undo is going to delete the mask, // we need to undraw the mask if (ImgGetMask(lpImage)) { RemoveMaskMarquee(lpImage); if (ImgGetMaskUpdateRect(lpImage, YES, NO, &rTemp)) AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp); } // if the undo is going to create the mask, // we need to undraw the object marquees if // not in mask and object marquee mode else { if (!Control.UseMaskAndObjects) RemoveObjectMarqueeEx(lpImage, NO); } } } // Actually do the undo ObjEditUndo(lpImage, lpObject, fUndoData, fUndoAlpha); // do a postprocess for undoing the mask if ((lpMask = ImgGetMask(lpImage)) && (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) || fMaskUndo)) { // if the undo is going to add the mask, we need to redraw the mask if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { if (ImgGetMaskUpdateRect(lpImage, YES, NO, &rTemp)) AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp); } else // just redraw the undo area for the mask AstralUnionRect(&rUndoMask, &rUndoMask, &lpMask->Pixmap.UndoRect); } // Setup rectangle for undoing deletion of objects // Handled specially so that moved objects will still undo // and redo properly if (fEditUndo) { if (lpObject == lpBase && lpObject->DataUndoType & UT_DELETEOBJECTS) { lpNext = lpObject; while (lpNext = ImgGetNextObjectEx(lpImage, lpNext, YES, NO, YES)) { if (lpNext->fDeleted || lpNext->fUndoDeleted) AstralUnionRect(&rUndo, &rUndo, &lpNext->rObject); } fSetupMiniViews = YES; } if (lpObject->Pixmap.fNewFrame) { /* if new frame, cause window to be redisplayed */ if (lpObject == lpBase) fNewSize = YES; else { if (!fNewSize) { AstralUnionRect(&rUndo, &rUndo, &lpObject->rObject); AstralUnionRect(&rUndo, &rUndo, &lpObject->rUndoObject); } } } else { AstralSetRectEmpty(&rTemp); if (fUndoData) AstralUnionRect(&rTemp, &rTemp, &lpObject->Pixmap.UndoRect); if (fUndoAlpha) AstralUnionRect(&rTemp, &rTemp, &lpObject->lpAlpha->Pixmap.UndoRect); if (rTemp.right >= rTemp.left) { if (!fNewSize) { OffsetRect(&rTemp, lpObject->rObject.left, lpObject->rObject.top); AstralUnionRect(&rUndo, &rUndo, &rTemp); } } } } } // now redisplay whatever changes are necessary for the undo if (fNewSize) { SetupImagePalette(lpImage, NO, YES); if (lpBase->Pixmap.UndoFrame) { if ((FrameXSize(lpBase->Pixmap.UndoFrame) == FrameXSize(lpBase->Pixmap.EditFrame)) && (FrameYSize(lpBase->Pixmap.UndoFrame) == FrameYSize(lpBase->Pixmap.EditFrame))) fNewSize = NO; } if (fNewSize) UpdateImageSize(); else UpdateImageEx(lpImage, NULL, YES, YES, YES); if ( Tool.hRibbon ) SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L ); } else { if (rUndoMask.right >= rUndoMask.left) { File2DispRect(&rUndoMask, &rUndoMask); AstralToWindowsRect(&rUndoMask); InvalidateRect(lpImage->hWnd, NULL, NO); } if (rUndo.right >= rUndo.left) AnimateUndo( &rUndo ); } if (fUndoDelete) if ( Tool.hRibbon ) SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L ); if (fSetupMiniViews) SetupMiniViews(NULL, NO); }
void CImage::EditUndo( BOOL fEditUndo, BOOL fMaskUndo, LPUPDATE_TYPE lpUpdateType, LPRECT lpUpdateRect) { RECT rUndo, rUndoMask, rTemp; LPOBJECT lpBase, lpObject, lpNext; BOOL fNewSize, fSetupMiniViews, fRemoveMarquee, fUndoDelete, fColorMapChanged; BOOL fUndoAlpha, fUndoData; int nDeleted; LPMASK lpMask; EDIT_TARGET Target; AstralSetRectEmpty(lpUpdateRect); // Initialize things for updating the display fNewSize = fSetupMiniViews = fUndoDelete = fColorMapChanged = NO; AstralSetRectEmpty(&rUndo); AstralSetRectEmpty(&rUndoMask); // loop through objects doing undo lpBase = GetBase(); lpObject = NULL; // get the target of the last edit Target = EditTarget; while (lpObject = GetNextObject(lpObject, NO, NO, fEditUndo)) { // See if this is an object we are undoing if (fEditUndo) { // check for special undo processing of a deleted object if (lpObject->fDeleted) continue; // do no undo processing for a deleted object // { // if (Control.UndoObjects && !IsSelectedObject(lpBase)) // continue; // } else // if target is not the entire image and we are in undo // object mode and the object is not selected then // skip this object if (Target != ET_ALLOBJECTS && Control.UndoObjects && !IsSelectedObject(lpObject)) continue; } // Only handle mask undo for the base object if (fMaskUndo) { if (lpObject != lpBase || lpObject->fBothDirty || !lpObject->AlphaDirty) continue; } fUndoData = fUndoAlpha = NO; // Do preprocess for doing a data undo if (fEditUndo) { if (lpObject->DataDirty) fUndoData = YES; // See if we need to undo the alpha for this object if ((lpObject != lpBase) && lpObject->lpAlpha && lpObject->AlphaDirty) fUndoAlpha = YES; if (!fUndoData && !fUndoAlpha) continue; // check to see and undoing/redoing deleted objects will change // the select state, if so undraw the object marquee if (lpObject == lpBase && lpObject->DataUndoType & UT_DELETEOBJECTS) { fUndoDelete = YES; fRemoveMarquee = NO; nDeleted = 0; lpNext = lpObject; while (lpNext = GetNextObject(lpNext, YES, NO, YES)) { if (lpNext->fUndoDeleted) ++nDeleted; else if (lpNext->fDeleted && lpNext->fSelected) { fRemoveMarquee = YES; break; } } if (GetSelObject(NULL) == lpBase && !fRemoveMarquee) { if (CountObjects() - nDeleted <= 1) fRemoveMarquee = YES; } if (fRemoveMarquee) { GetObjectMarqueeRect(this, &rTemp); AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp); } } } else // fMaskUndo if (!lpObject->AlphaDirty) continue; else fUndoAlpha = YES; // do a preprocess for undoing the mask caused either by // a mask undo or by an edit function that also edits the mask if (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) || fMaskUndo) { if ( lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { // if the undo is going to delete the mask, // we need to undraw the mask if (GetMask()) { GetMaskMarqueeRect(this, &rTemp); AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp); if (GetMaskUpdateRect(YES, NO, &rTemp)) AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp); } // if the undo is going to create the mask, // we need to undraw the object marquees if // not in mask and object marquee mode else { if (!Control.UseMaskAndObjects) { GetObjectMarqueeRect(this, &rTemp); AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp); } } } } // Actually do the undo ObjEditUndo(lpObject, fUndoData, fUndoAlpha); // do a postprocess for undoing the mask if ((lpMask = GetMask()) && (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) || fMaskUndo)) { // if the undo is going to add the mask, we need to redraw the mask if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) ) { if (GetMaskUpdateRect(YES, NO, &rTemp)) AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp); } else // just redraw the undo area for the mask AstralUnionRect(&rUndoMask, &rUndoMask, &lpMask->Pixmap.UndoRect); } // Setup rectangle for undoing deletion of objects // Handled specially so that moved objects will still undo // and redo properly if (fEditUndo) { if (lpObject == lpBase && lpObject->DataUndoType & UT_DELETEOBJECTS) { lpNext = lpObject; while (lpNext = GetNextObject(lpNext, YES, NO, YES)) { if (lpNext->fDeleted || lpNext->fUndoDeleted) AstralUnionRect(&rUndo, &rUndo, &lpNext->rObject); } fSetupMiniViews = YES; } if (lpObject->DataUndoType & UT_COLORMAP) fColorMapChanged = YES; if (lpObject->Pixmap.fNewFrame) { /* if new frame, cause window to be redisplayed */ if (lpObject == lpBase) fNewSize = YES; else { if (!fNewSize) { AstralUnionRect(&rUndo, &rUndo, &lpObject->rObject); AstralUnionRect(&rUndo, &rUndo, &lpObject->rUndoObject); } } } else { AstralSetRectEmpty(&rTemp); if (fUndoData) AstralUnionRect(&rTemp, &rTemp, &lpObject->Pixmap.UndoRect); if (fUndoAlpha) AstralUnionRect(&rTemp, &rTemp, &lpObject->lpAlpha->Pixmap.UndoRect); if (rTemp.right >= rTemp.left) { if (!fNewSize) { OffsetRect(&rTemp, lpObject->rObject.left, lpObject->rObject.top); AstralUnionRect(&rUndo, &rUndo, &rTemp); } } if( lpObject->DataUndoType & UT_OBJECTRECT ) { AstralUnionRect( &rUndo, &rUndo, &lpObject->rObject ); AstralUnionRect( &rUndo, &rUndo, &lpObject->rUndoObject ); } } } } // now redisplay whatever changes are necessary for the undo if (fColorMapChanged) { ImgColorMapChanged(this); *lpUpdateType |= UT_DATATYPE; } if (fNewSize) { *lpUpdateType |= UT_DATATYPE; if (lpBase->Pixmap.UndoFrame) { if ((FrameXSize(lpBase->Pixmap.UndoFrame) == FrameXSize(lpBase->Pixmap.EditFrame)) && (FrameYSize(lpBase->Pixmap.UndoFrame) == FrameYSize(lpBase->Pixmap.EditFrame))) fNewSize = NO; } if (fNewSize) *lpUpdateType |= UT_SIZE; else { int dx, dy; GetInfo(&dx, &dy, NULL, NULL); SetRect(lpUpdateRect, 0, 0, dx-1, dy-1); } } else { if (!AstralIsRectEmpty(lpUpdateRect)) *lpUpdateType |= UT_ACTIVEAREA; if (rUndoMask.right >= rUndoMask.left) { *lpUpdateType |= UT_ACTIVEAREA; AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndoMask); } if (rUndo.right >= rUndo.left) { *lpUpdateType |= UT_AREA; AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndo); } } }
long DoCommand( HWND hWindow, WPARAM wParam, LPARAM lParam ) /***********************************************************************/ { FNAME szFileName; LPFRAME lpFrame; LPOBJECT lpObject, lpBase; RECT rect, rMask, rTemp, rAll; HWND hWnd; STRING szString; int i, idFileType, x, y, dx, dy; BOOL fDoZoom, bPrint, fHasZoom; LPSTR lpszCmdLine; HGLOBAL hMem; ITEMID idDataType; DWORD dwReturn; int NewShape; UINT wID; SoundStartID( wParam, NO/*bLoop*/, NULL/*hInstance*/ ); /* WIN16: ID = wParam ctrl handle = LOWORD(lParam) notify code = HIWORD(lParam) WIN32: ID = LOWORD(wParam) ctrl handle = lParam notify code = HIWORD(wParam) */ #ifdef WIN32 wID = LOWORD(wParam); #else wID = wParam; #endif switch (wID) { case IDM_EXIT: DeactivateTool(); PostMessage( hWndAstral, WM_CLOSE, 0, 0L); Delay (750); break; case IDM_CLOSE: DeactivateTool(); /* Check to see if the image needs to be saved */ if ( !ConfirmClose(NO,NO) ) break; CloseImage( NO, lpImage ); // Close the active image break; case IDM_ABOUT: /* Bring up the modal 'About' dialog box */ AstralDlg( NO|2, hInstAstral, hWindow, IDD_ABOUT, DlgAboutProc); break; case IDM_NEXTPAGE: if ( !lpImage ) break; DeactivateTool(); SendMessage( lpImage->hWnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0L ); break; case IDM_NEW: DeactivateTool(); SoundStartResource( "magic01", NO, NULL ); AstralCursor( IDC_WAIT ); New( Control.NewWidth, Control.NewHeight, Control.NewResolution, Control.NewDepth ); AstralCursor( NULL ); break; case IDM_OPEN: DeactivateTool(); /* Bring up the modal 'File Open' box */ if ( !(dwReturn = DoOpenDlg( hWindow, IDD_OPEN, Save.FileType, szFileName, NO )) ) break; idFileType = LOWORD( dwReturn ); Save.FileType = idFileType; PutDefaultInt( "FileType", idFileType - IDN_TIFF ); AstralImageLoad( idFileType, szFileName, MAYBE, YES ); break; case IDM_ALTOPEN: DeactivateTool(); // Command line sent from a second instance prior to it closing /* If the caller passed in a file name, try to load it or print it */ if ( !(lpszCmdLine = (LPSTR)lParam) ) break; HandleCommandLine( hWindow, lpszCmdLine, &bPrint ); break; case IDM_SAVE: DeactivateTool(); HandleSaveCommand(hWindow, wID, YES); break; case IDM_SAVEAS: DeactivateTool(); HandleSaveCommand(hWindow, wID, YES); break; case IDM_SAVESPECIAL: DeactivateTool(); HandleSaveCommand(hWindow, wID, YES); break; case IDM_SAVEWALLPAPER: DeactivateTool(); SaveWallpaper( "CRAYOLA", NO/*fTiled*/ ); break; case IDM_REVERT: if ( !lpImage ) break; DeactivateTool(); if ( lpImage->fUntitled ) // If the picture doesn't have a name, get out break; if ( ImgChanged(lpImage) ) { /* Check to see if its OK to trash changes */ if ( AstralOKCancel(IDS_OKTOREVERT, (LPSTR)lpImage->CurFile) == IDCANCEL ) break; } lstrcpy( szFileName, lpImage->CurFile ); idFileType = lpImage->FileType; fDoZoom = IsZoomed(lpImage->hWnd); fHasZoom = Window.fHasZoom; CloseImage( NO, lpImage ); // Close the active image if ( !AstralImageLoad( idFileType, szFileName, fDoZoom, YES ) ) break; break; case IDM_RECALLIMAGE0: case IDM_RECALLIMAGE1: case IDM_RECALLIMAGE2: case IDM_RECALLIMAGE3: case IDM_RECALLIMAGE4: case IDM_RECALLIMAGE5: case IDM_RECALLIMAGE6: case IDM_RECALLIMAGE7: case IDM_RECALLIMAGE8: case IDM_RECALLIMAGE9: DeactivateTool(); GetMenuString( GetMenu(hWindow), wID, szFileName, sizeof(szFileName), MF_BYCOMMAND ); i = 0; while ( szFileName[i] && szFileName[i] != ' ' ) i++; // Skip over the numeric id in the string (3. junk.tif) lstrcpy(szString, &szFileName[i+1]); GetRecallFileName(szString); AstralImageLoad( NULL, szString, MAYBE, YES ); break; case IDM_PRINT: if ( !lpImage ) break; DeactivateTool(); AstralCursor( IDC_WAIT ); DoPrintSizeInits(); SoundStartResource( "print", YES, NULL ); PrintFile( hWindow, filename(lpImage->CurFile), YES, lpImage, NULL ); SoundStop(); AstralCursor( NULL ); break; case IDM_PRINTSETUP: /* Bring up the setup dialog box for the active printer */ AstralDlg( NO|2, hInstAstral, hWindow, IDD_PRINTSETUP, DlgPrintSetupProc); break; case IDC_SOUND: SoundToggle(); break; case IDM_UNDO: if ( !lpImage ) break; DeactivateTool(); ImgEditUndo(lpImage, YES, NO); break; case IDM_CUT: case IDM_COPY: if ( !lpImage ) break; DeactivateTool(); // Create the clipboard files from the image ProgressBegin(1, IDS_PROGCOPY); if ( !ImgWriteClipOut( lpImage, NULL, NULL, &rMask, lpImage->DataType ) ) { ProgressEnd(); Message(IDS_EMEMALLOC); break; } ProgressEnd(); OpenClipboard(hWindow); EmptyClipboard(); // Passing a NULL data handle in SetClipboardData() means that // the data will be requested in a WM_RENDERFORMAT message hMem = ConstructObject( lpImage, IsRectEmpty(&rMask)? (LPRECT)NULL : (LPRECT)&rMask ); if ( pOLE ) { // Any data put on before Native will become staticly copied SetClipboardData( pOLE->cfNative, NULL ); SetClipboardData( pOLE->cfOwnerLink, hMem ); } SetClipboardData( CF_DIB, NULL ); if ( Control.DoPicture ) SetClipboardData( CF_METAFILEPICT, NULL ); if ( Control.DoBitmap ) SetClipboardData( CF_BITMAP, NULL ); SetClipboardData( CF_PALETTE, NULL ); SetClipboardData( Control.cfImage, NULL ); if ( pOLE && wID == IDM_COPY && !lpImage->fUntitled ) { // ObjectLink is retrieved during a Paste Link... SetClipboardData( pOLE->cfObjectLink, hMem ); } CloseClipboard(); if ( wID == IDM_COPY ) break; // else fall through to IDM_DELETE case IDM_DELETE: if ( !lpImage ) break; { COLORINFO ColorInfo; DeactivateTool(); ColorInfo.gray = 255; SetColorInfo( &ColorInfo, &ColorInfo, CS_GRAY ); TintFill( lpImage, &ColorInfo, 255, MM_NORMAL, wID == IDM_CUT ? IDS_UNDOCUT : IDS_UNDODELETE ); } break; case IDM_PASTE: if ( !lpImage ) break; case IDM_PASTEASNEW: if ( !OpenClipboard(hWndAstral) ) { Message( IDS_ECLIPOPEN ); break; } if ( !IsClipboardFormatAvailable(CF_DIB) && !IsClipboardFormatAvailable(CF_BITMAP) && !IsClipboardFormatAvailable(Control.cfImage) ) { Message( IDS_ECLIPOPEN ); CloseClipboard(); break; } CloseClipboard(); DeactivateTool(); // First put clipboard contents into a file(s) AstralCursor(IDC_WAIT); if ( !PasteFromClipboard( hWindow, (wID == IDM_PASTE) /*fNeedMask*/ ) ) { AstralCursor(NULL); Message(IDS_EMEMALLOC); break; } if ( wID == IDM_PASTE ) { ProgressBegin(1, IDS_PROGPASTECLIP); TransformObjectsStart( YES/*fNewObject*/ ); if ( ImgCreateClipInObject( lpImage, NO ) ) ; ProgressEnd(); } else if ( wID == IDM_PASTEASNEW ) { if ( lpFrame = AstralFrameLoad( Names.PasteImageFile, -1, &idDataType, &idFileType) ) { if ( NewImageWindow( NULL, // lpOldFrame NULL, // Name lpFrame, // lpNewFrame idFileType, // lpImage->FileType idDataType, // lpImage->DataType FALSE, // New view? IMG_DOCUMENT, // lpImage->DocumentType NULL, // lpImage->ImageName MAYBE ) ) lpImage->fChanged = YES; } } break; case IDM_ESCAPE: if (!lpImage) break; if (lpImage->hWnd == hZoomWindow) break; if ( Tool.bActive && Tool.lpToolProc ) DestroyProc( lpImage->hWnd, 1L ); break; case IDM_SIZEUP: case IDM_SIZEDOWN: if (!Retouch.hBrush) break; SetFocus( hWindow ); // Take focus away from any controls if ( Retouch.BrushShape == IDC_BRUSHCUSTOM ) break; if ( wID == IDM_SIZEUP ) { if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 )) Retouch.BrushSize += 2; else Retouch.BrushSize++; } else { if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 )) Retouch.BrushSize -= 2; else Retouch.BrushSize--; } if ( Retouch.BrushSize < 1 || Retouch.BrushSize > MAX_BRUSH_SIZE ) { Retouch.BrushSize = bound( Retouch.BrushSize, 1,MAX_BRUSH_SIZE); MessageBeep(0); break; } if (lpImage) DisplayBrush(0, 0, 0, OFF); SetMgxBrushSize(Retouch.hBrush, Retouch.BrushSize); if (lpImage && Window.hCursor == Window.hNullCursor) DisplayBrush(lpImage->hWnd, 32767, 32767, ON); if ( Tool.hRibbon ) SetSlide( Tool.hRibbon, IDC_BRUSHSIZE, Retouch.BrushSize ); break; case IDM_SHAPEUP: case IDM_SHAPEDOWN: if (!Retouch.hBrush) break; SetFocus( hWindow ); // Take focus away from any controls NewShape = Retouch.BrushShape; if ( wID == IDM_SHAPEUP ) NewShape++; else NewShape--; if ( NewShape > IDC_BRUSHCUSTOM ) NewShape = IDC_BRUSHCIRCLE; if ( NewShape < IDC_BRUSHCIRCLE ) NewShape = IDC_BRUSHCUSTOM; if (lpImage) DisplayBrush(0, 0, 0, OFF); if (!SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush)) { NewShape = IDC_BRUSHCIRCLE; SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush); } Retouch.BrushShape = NewShape; if (lpImage && Window.hCursor == Window.hNullCursor) DisplayBrush(lpImage->hWnd, 32767, 32767, ON); if ( Tool.hRibbon ) { CheckComboItem( Tool.hRibbon, IDC_BRUSHSHAPE, IDC_BRUSHCIRCLE, IDC_BRUSHCUSTOMNEW, Retouch.BrushShape ); SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L ); } break; case IDM_MOVEUP: case IDM_MOVEDOWN: case IDM_MOVELEFT: case IDM_MOVERIGHT: if (!lpImage) break; lpBase = ImgGetBase(lpImage); if (ImgGetSelObject(lpImage, NULL) == lpBase) break; dx = dy = 0; if (wID == IDM_MOVEUP) --dy; if (wID == IDM_MOVEDOWN) ++dy; if (wID == IDM_MOVELEFT) --dx; if (wID == IDM_MOVERIGHT) ++dx; lpObject = NULL; while (lpObject = ImgGetSelObject(lpImage, lpObject)) { rect = lpObject->rObject; OffsetRect(&rect, dx, dy); if (!AstralIntersectRect(&rTemp, &lpBase->rObject, &rect)) break; } if (lpObject) break; AstralSetRectEmpty(&rAll); lpObject = NULL; while (lpObject = ImgGetSelObject(lpImage, lpObject)) { rect = lpObject->rObject; OffsetRect(&lpObject->rObject, dx, dy); AstralUnionRect(&rAll, &rAll, &lpObject->rObject); if (!lpObject->Pixmap.fNewFrame && EqualRect(&rect, &lpObject->rUndoObject)) lpObject->rUndoObject = lpObject->rObject; UpdateImage(&rect, TRUE); UpdateImage(&lpObject->rObject, TRUE); } if (wID == IDM_MOVEUP) { x = (rAll.left + rAll.right)/2; y = rAll.top; } else if (wID == IDM_MOVEDOWN) { x = (rAll.left + rAll.right)/2; y = rAll.bottom; } else if (wID == IDM_MOVELEFT) { x = rAll.left; y = (rAll.top + rAll.bottom)/2; } else if (wID == IDM_MOVERIGHT) { x = rAll.right; y = (rAll.top + rAll.bottom)/2; } File2Display(&x, &y); AutoScroll(lpImage->hWnd, x, y); AstralUpdateWindow(lpImage->hWnd); DisplayInfo(-1, &rAll); break; case IDM_LASTTOOL: DeactivateTool(); if ( Tool.idLast && (hWnd = AstralDlgGet(IDD_MAIN)) ) SendMessage( hWnd, WM_COMMAND, Tool.idLast, 2L); break; case IDM_PREF: // prevent problems if running animations and they change // the wave mix dll setting in preferences StopAnimation(); AstralDlg( NO|2, hInstAstral, hWindow, IDD_PREF, DlgPrefProc ); break; case IDC_VIEWLAST: // duplicate of function in the view ribbon if ( !lpImage ) break; RevertLastView(); break; // case IDC_VIEWFULL: // duplicate of function in the view ribbon // if ( !lpImage ) // break; // AstralDlg( NO, hInstAstral, hWindow, IDD_VIEWFULL, DlgFullScreenViewProc ); // break; case IDC_VIEWALL: // duplicate of function in the view ribbon if ( !lpImage ) break; ViewAll(); break; case IDC_ZOOMIN: // duplicate of function in the view ribbon if ( !lpImage ) break; if (!lpImage->lpDisplay) break; if (!lpImage->lpDisplay->ViewPercentage) break; x = ( lpImage->lpDisplay->FileRect.left + lpImage->lpDisplay->FileRect.right ) / 2; y = ( lpImage->lpDisplay->FileRect.top + lpImage->lpDisplay->FileRect.bottom ) / 2; SaveLastView(); Zoom(x,y, +100, YES, ( View.ZoomWindow ^ CONTROL ) ); break; case IDC_ZOOMOUT: // duplicate of function in the view ribbon if ( !lpImage ) break; if (!lpImage->lpDisplay) break; if (!lpImage->lpDisplay->ViewPercentage) break; x = ( lpImage->lpDisplay->FileRect.left + lpImage->lpDisplay->FileRect.right ) / 2; y = ( lpImage->lpDisplay->FileRect.top + lpImage->lpDisplay->FileRect.bottom ) / 2; SaveLastView(); Zoom(x,y, -100, YES,( View.ZoomWindow ^ CONTROL ) ); break; case IDM_HELP: Control.Hints = !Control.Hints; PutDefInt (Control.Hints,Control.Hints); break; default: return( FALSE ); } return( TRUE ); }
void VignetteProc( HWND hWindow, UINT msg, int x, int y, UINT32 Option ) /************************************************************************/ { RECT Rect; BOOL fShift; POINT pt; static int Type, Style; static BOOL fConstrain; static RECT SelectRect; int res; FRMDATATYPE type; LPIMAGE lpImage; STRING szString; GRADIENT_PARMS parms; switch (msg) { case WM_CREATE: // The first mouse down message if (!IsOnImage(hWindow, x, y)) break; ImgGetInfo(GetActiveImage(), NULL, NULL, NULL, &type); if (type == FDT_LINEART) { AstralStrEx( IDC_TOOLNAMESTART+IDC_VIGNETTE, szString, sizeof(szString) ); Message(IDS_NOTWITHLINEART, (LPSTR)szString); break; } AstralUpdateWindow(hWindow); Tool.bActive = YES; // SetMaskingState( x, y ); break; case WM_LBUTTONDOWN: Type = Vignette.Gradient; fConstrain = ( Type == IDC_VIGSQUARE || Type == IDC_VIGCIRCLE ); AstralSetRectEmpty( &SelectRect ); if ( Type == IDC_VIGCIRCLE || Type == IDC_VIGELLIPSE ) Style = SL_ELLIPSE; else if ( Type == IDC_VIGRADIAL || Type == IDC_VIGLINEAR ) Style = SL_LINE; else Style = SL_BOX; pt.x = x; pt.y = y; StartSelection( hWindow, NULL, &SelectRect, Style | SL_SPECIAL, pt, 0L ); break; case WM_LBUTTONUP: Tool.bActive = NO; Rect = SelectRect; // make a copy before it gets ordered EndSelection( hWindow, NULL, &SelectRect, Style, YES ); lpImage = (LPIMAGE)GetImagePtr ( hWindow ); res = FrameResolution(ImgGetBaseEditFrame(lpImage)); type = FrameType(ImgGetBaseEditFrame(lpImage)); parms.VigOpacity = Vignette.VigOpacity; parms.VigMergeMode = Vignette.VigMergeMode; parms.iBaseRes = res; parms.x1 = Rect.left; parms.y1 = Rect.top; parms.x2 = Rect.right; parms.y2 = Rect.bottom; GetActiveColorFromType(type, &parms.StartColor); GetAlternateColorFromType(type, &parms.EndColor); parms.Gradient = Vignette.Gradient; parms.RepeatCount = Vignette.RepeatCount; parms.SoftTransition = Vignette.SoftTransition; parms.Midpoint = Vignette.Midpoint; parms.VigColorModel = Vignette.VigColorModel; ProcessCommand(lpImage->lpCmdList, IDS_CMD_GRADIENT, &parms); break; case WM_MOUSEMOVE: // sent when ToolActive is on fShift = SHIFT; pt.x = x; pt.y = y; UpdateSelection( hWindow, NULL, &SelectRect, Style, pt, fConstrain^CONSTRAINASPECT, 1L, 1L, MOVEKEY||Window.fRButtonDown, FROMCENTER); break; case WM_LBUTTONDBLCLK: break; case WM_DESTROY: // The cancel operation message if (!Tool.bActive) break; Tool.bActive = NO; EndSelection( hWindow, NULL, &SelectRect, Style, YES ); break; } }
CImage::CImage( ITEMID idDataType, LPSTR lpFileName, LPCMDLIST lpCommandList, ITEMID idFileType, int DocType, LPSTR lpImageName) { fOwnedByClient = FALSE; fRelease = FALSE; // setup name of image, if no name passed in, setup an untitled image if ( !lpFileName ) { fChanged = TRUE; fUntitled = TRUE; GetUntitledName(CurFile); } else { fChanged = FALSE; fUntitled = FALSE; lstrcpy( CurFile, lpFileName ); } if (lpImageName) lstrcpy(ImageName, lpImageName); else ImageName[0] = '\0'; npix = 0; nlin = 0; FileType = GetPPFileType(CurFile); if (!FileType) FileType = Control.DefaultFileType; DataType = idDataType; UndoDataType = 0; DocumentType = DocType; Element = 0; Compressed = FALSE; UseObjectMarquee = Control.UseObjectMarquee; MarqueeStatus = 0; ObjList.lpHead = ObjList.lpTail = NULL; AltObjList.lpHead = AltObjList.lpTail = NULL; m_ViewMode = VM_NORMAL; lpFastbitsPreview = NULL; AstralSetRectEmpty(&rFastbitsGrid); hPal = NULL; nPaletteEntries = 0; fNoSize = FALSE; lpCmdList = lpCommandList; iUndoCreateMaskDirty = 0; fSaveNoSize = FALSE; lpPaletteLUT = NULL; PaletteType = PT_COLORPALETTE; EditTarget = ET_OBJECT; fDisableUndos = FALSE; hLastBrush = NULL; szLastBrushStyle[0] = '\0'; idLastBrush = 0; dwObjectID = 0; m_cmsXform = NULL; SaveInfo.toRCS = SaveInfo.frRCS = 0; lpClipObject = NULL; m_bDoCmsGamma = FALSE; fMaskCreate = FALSE; fDiscardUndo = FALSE; PtInfo.toRCS = PtInfo.frRCS = 0; m_lpDispObject = NULL; if (lpCmdList) pServerDoc = lpCmdList->pDocument; else pServerDoc = NULL; }
BOOL CImage::CombineObjects(BOOL fNoUndo, BOOL fCreateMask, BOOL fForceIt, ITEMID idDirty, LPRECT lpUpdateRect) { LPOBJECT lpBase, lpObject; int iWidth, iHeight, depth, y, iImageWidth, iImageHeight; LPTR lpDataBuf, lpMaskPtr; RECT rFloaters, rMask, rTemp; BOOL fNewMask; LPMASK lpMask; UNDO_TYPE UndoType; AstralSetRectEmpty(lpUpdateRect); // get rectangle for all floating objects if (!GetFloatingObjectsRect(&rFloaters)) return(FALSE); // Get base object lpBase = GetBase(); // get pixmap information PixmapGetInfo(&lpBase->Pixmap, PMT_EDIT, &iImageWidth, &iImageHeight, &depth, NULL); BoundRect(&rFloaters, 0, 0, iImageWidth-1, iImageHeight-1); iWidth = RectWidth(&rFloaters); iHeight = RectHeight(&rFloaters); // allocate buffer for alpha channel combining if (!(lpDataBuf = Alloc((long)iWidth*depth))) { Message(IDS_EMEMALLOC); return(FALSE); } lpMask = NULL; if (fCreateMask) { lpMask = GetMaskEx(OFF, Control.NoUndo, &fNewMask, &rTemp); AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp); } // do it to it ProgressBegin(lpMask != NULL ? 2 : 1, idDirty-IDS_UNDOFIRST+IDS_PROGFIRST); if (!fNoUndo) { UndoType = UT_DATA|UT_DELETEOBJECTS; if (lpMask) { if (fNewMask) UndoType |= UT_CREATEMASK; else UndoType |= UT_ALPHA; } if (!ImgEditInit(this, ET_OBJECT, UndoType, lpBase)) { if (!fForceIt) { ProgressEnd(); FreeUp(lpDataBuf); return(FALSE); } } } // do it to it ProgressBegin(1, 0); for (y = rFloaters.top; y <= rFloaters.bottom; ++y) { AstralClockCursor(y-rFloaters.top, iHeight, NO); ImgGetLine(this, NULL, rFloaters.left, y, iWidth, lpDataBuf); PixmapWrite(&lpBase->Pixmap, PMT_EDIT, rFloaters.left, y, iWidth, lpDataBuf, iWidth); } ProgressEnd(); if (lpMask && (lpObject = GetNextObject(lpBase, YES, NO))) { ProgressBegin(1, 0); for (y = rFloaters.top; y <= rFloaters.bottom; ++y) { AstralClockCursor(y-rFloaters.top, iHeight, NO); lpMaskPtr = PixmapPtr(&lpMask->Pixmap, PMT_EDIT, rFloaters.left, y, YES); if (!lpMaskPtr) continue; ImgMaskLoad(this, lpObject, NULL, rFloaters.left, y, iWidth, lpDataBuf, NO, CR_OR, 0, 0); CombineData(lpDataBuf, lpMaskPtr, iWidth, NO, CR_OR); } MaskRectUpdate(lpMask, &rMask); ProgressEnd(); } FreeUp(lpDataBuf); GetObjectMarqueeRect(this, &rTemp); AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp); lpObject = lpBase; while (lpObject = GetNextObject(lpObject, YES, NO)) { // always let undo stuff initialize this // lpObject->fUndoDeleted = NO; lpObject->fDeleted = YES; } //DeleteObjects((LPOBJECT)lpBase->lpNext, NO); if (!fNoUndo) ImgEditedObject(this, lpBase, idDirty, &rFloaters); else fChanged = YES; //if ( Tool.hRibbon ) // SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L ); ProgressEnd(); //SetupMiniViews(NULL, NO); return(TRUE); }
//************************************************************************ LOCAL STATUS_CODE ApplyCalibration( LPIMAGE lpImage, ITEMID dirty, LPSTR lpScanMap, LPSTR lpPrintMap, LPRECT lpUpdateRect, LPUPDATE_TYPE lpUpdateType) //************************************************************************ { FNAME szFileName; ENGINE Engine; LPCALMAPS lpMaps; BOOL fScanMap, fPrintMap; FRMTYPEINFO TypeInfo; LPCOLORMAP lpColorMap; STATUS_CODE StatusCode; int i; ASSERT(lpImage); AstralSetRectEmpty(lpUpdateRect); *lpUpdateType = UT_NONE; ImgGetTypeInfo(lpImage, &TypeInfo); lpMaps = (LPCALMAPS)Alloc(sizeof(CALMAPS)); if (!lpMaps) { Message(IDS_EMEMALLOC); return(SC_MEMERROR); } for (i = 0; i < CALSCAN_MAPS; ++i) ResetMap( &lpMaps->ScanMap[i], CALPOINTS, NO ); if (fScanMap = (lstrlen(lpScanMap) != 0)) { if ( LookupExtFileN( lpScanMap, szFileName, IDN_SCANMAP, NO ) ) { // Remember that the maps load in XRGB order if (!LoadMap( &lpMaps->ScanMap[CALSCAN_GRAY], &lpMaps->ScanMap[CALSCAN_RED], &lpMaps->ScanMap[CALSCAN_GREEN], &lpMaps->ScanMap[CALSCAN_BLUE], szFileName )) { FreeUp(lpMaps); return(SC_READERROR); } if (TypeInfo.DataType == FDT_CMYKCOLOR) { // make maps work on cmyk for (i = 0; i < CALSCAN_MAPS; ++i) ReverseMap(&lpMaps->ScanMap[i], FALSE); } } else { fScanMap = NO; } } for (i = 0; i < CAL_MAPS; ++i) ResetMap( &lpMaps->PrintMap[i], CALPOINTS, NO ); if (fPrintMap = (lstrlen(lpPrintMap) != 0)) { if ( LookupExtFileN( lpPrintMap, szFileName, IDN_CALMAP, NO ) ) { // Remember that the maps load in MCMYK order if (!LoadCalMap( &lpMaps->PrintMap[CAL_MASTER], &lpMaps->PrintMap[CAL_CYAN], &lpMaps->PrintMap[CAL_MAGENTA], &lpMaps->PrintMap[CAL_YELLOW], &lpMaps->PrintMap[CAL_BLACK], szFileName )) { FreeUp(lpMaps); return(SC_READERROR); } if (TypeInfo.DataType != FDT_CMYKCOLOR) { // make maps work on rgb for (i = 0; i < CAL_MAPS; ++i) ReverseMap(&lpMaps->PrintMap[i], FALSE); } } else { fPrintMap = NO; lpPrintMap = NULL; } } if (!fScanMap && !fPrintMap) { FreeUp(lpMaps); return(SC_SUCCESS); // user selected no maps??? } switch (TypeInfo.DataType) { case FDT_LINEART: case FDT_GRAYSCALE: MakeFloatMap(&lpMaps->ScanMap[CALSCAN_GRAY], lpMaps->CalPnts); MakeFloatMap(&lpMaps->PrintMap[CAL_BLACK], lpMaps->TmpPnts); MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts); MapCreateLut(lpMaps->CalPnts, lpMaps->Lut[0]); break; case FDT_CMYKCOLOR: for (i = 0; i < 4; ++i) { if (i == 3) // black MakeFloatMap(&lpMaps->ScanMap[CALSCAN_GRAY], lpMaps->CalPnts); else MakeFloatMap(&lpMaps->ScanMap[CALSCAN_RED+i], lpMaps->CalPnts); MakeFloatMap(&lpMaps->PrintMap[CAL_MASTER], lpMaps->TmpPnts); MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts); MakeFloatMap(&lpMaps->PrintMap[CAL_CYAN+i], lpMaps->TmpPnts); MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts); MapCreateLut(lpMaps->CalPnts, lpMaps->Lut[i]); } break; default: case FDT_RGBCOLOR: case FDT_PALETTECOLOR: for (i = 0; i < 3; ++i) { MakeFloatMap(&lpMaps->ScanMap[CALSCAN_RED+i], lpMaps->CalPnts); MakeFloatMap(&lpMaps->PrintMap[CAL_MASTER], lpMaps->TmpPnts); MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts); MakeFloatMap(&lpMaps->PrintMap[CAL_CYAN+i], lpMaps->TmpPnts); MapCombine(lpMaps->CalPnts, lpMaps->TmpPnts); MapCreateLut(lpMaps->CalPnts, lpMaps->Lut[i]); } break; } ImgGetTypeInfo(lpImage, &TypeInfo); if (TypeInfo.DataType == FDT_PALETTECOLOR) { lpColorMap = FrameCopyColorMap(TypeInfo.ColorMap); if (!lpColorMap) { Message(IDS_EMEMALLOC); return(SC_MEMERROR); } LineCalMapProc(0, 0, lpColorMap->NumEntries-1, (LPTR)lpColorMap->RGBData, (LPTR)lpColorMap->RGBData, 3, lpMaps); StatusCode = ApplyColorMap(lpImage, lpColorMap, FALSE, DT_NONE, dirty); FrameDestroyColorMap(lpColorMap); if (StatusCode == SC_SUCCESS) *lpUpdateType = UT_DATATYPE; } else { SetEngineDef(&Engine); Engine.lpDataProc = (LPDATAPROC)LineCalMapProc; Engine.lpParam = lpMaps; StatusCode = LineEngineSelObj(lpImage, &Engine, dirty); if (!AstralIsRectEmpty(&Engine.rUpdate)) { *lpUpdateRect = Engine.rUpdate; *lpUpdateType = UT_AREA; } } FreeUp(lpMaps); return(StatusCode); }