Ejemplo n.º 1
0
 public void RestoreRegion(PdnRegion region)
 {
     if (region != null)
     {
         BitmapLayer activeLayer = (BitmapLayer)ActiveLayer;
         activeLayer.Surface.CopySurface(this.ScratchSurface, region);
         activeLayer.Invalidate(region);
     }
 }
Ejemplo n.º 2
0
 public void RestoreSavedRegion()
 {
     if (this.saveRegion != null)
     {
         BitmapLayer activeLayer = (BitmapLayer)ActiveLayer;
         activeLayer.Surface.CopySurface(this.ScratchSurface, this.saveRegion);
         activeLayer.Invalidate(this.saveRegion);
         this.saveRegion.Dispose();
         this.saveRegion = null;
     }
 }
Ejemplo n.º 3
0
        // TODO: add "name" parameter, keep this for legacy and fill it in with "Background"
        //       goal is to put complete burden of loc on the client
        public static BitmapLayer CreateBackgroundLayer(int width, int height)
        {
            // set colors to 0xffffffff
            // note: we use alpha of 255 here so that "invert colors" works as expected
            // that is, for just 1 layer we invert the initial white->black
            // but on subsequent layers we invert transparent white -> transparent black, which shows up as white for the most part
            BitmapLayer layer = new BitmapLayer(width, height, ColorBgra.White);

            layer.Name = PdnResources.GetString("Layer.Background.Name");

            // tag it as a background layer
            layer.properties.isBackground = true;

            return(layer);
        }
Ejemplo n.º 4
0
 protected BitmapLayer(BitmapLayer copyMe)
     : base(copyMe)
 {
     this.surface = copyMe.Surface.Clone();
     this.properties = (BitmapLayerProperties)copyMe.properties.Clone();
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Does the dirty work for a File->Save operation. If any of the "Save Options" in the
        /// DocumentWorkspace are null, this will call DoSaveAs(). If the image has more than 1
        /// layer but the file type they want to save with does not support layers, then it will
        /// ask the user about flattening the image.
        /// </summary>
        /// <param name="tryToFlatten">
        /// If true, will ask the user about flattening if the workspace's saveFileType does not 
        /// support layers and the image has more than 1 layer.
        /// If false, then DoSaveAs will be called and the fileType will be prepopulated with
        /// the .PDN type.
        /// </param>
        /// <returns><b>true</b> if the file was saved, <b>false</b> if the user cancelled</returns>
        protected bool DoSave(bool tryToFlatten)
        {
            using (new PushNullToolMode(this))
            {
                string newFileName;
                FileType newFileType;
                SaveConfigToken newSaveConfigToken;

                GetDocumentSaveOptions(out newFileName, out newFileType, out newSaveConfigToken);

                // if they haven't specified a filename, then revert to "Save As" behavior
                if (newFileName == null)
                {
                    return DoSaveAs();
                }

                // if we have a filename but no file type, try to infer the file type
                if (newFileType == null)
                {
                    FileTypeCollection fileTypes = FileTypes.GetFileTypes();
                    string ext = Path.GetExtension(newFileName);
                    int index = fileTypes.IndexOfExtension(ext);
                    FileType inferredFileType = fileTypes[index];
                    newFileType = inferredFileType;
                }

                // if the image has more than 1 layer but is saving with a file type that
                // does not support layers, then we must ask them if we may flatten the
                // image first
                if (Document.Layers.Count > 1 && !newFileType.SupportsLayers)
                {
                    if (!tryToFlatten)
                    {
                        return DoSaveAs();
                    }
                    else
                    {
                        DialogResult dr = WarnAboutFlattening();

                        if (dr == DialogResult.Yes)
                        {
                            ExecuteFunction(new FlattenFunction());
                        }
                        else
                        {
                            return false;
                        }
                    }
                }

                // get the configuration!
                if (newSaveConfigToken == null)
                {
                    Surface scratch = BorrowScratchSurface(this.GetType().Name + ".DoSave() calling GetSaveConfigToken()");

                    bool result;
                    try
                    {
                        result = GetSaveConfigToken(newFileType, newSaveConfigToken, out newSaveConfigToken, scratch);
                    }

                    finally
                    {
                        ReturnScratchSurface(scratch);
                    }

                    if (!result)
                    {
                        return false;
                    }
                }

                // At this point fileName, fileType, and saveConfigToken must all be non-null

                // if the document supports custom headers, embed a thumbnail in there
                if (newFileType.SupportsCustomHeaders)
                {
                    using (new WaitCursorChanger(this))
                    {
                        Utility.GCFullCollect();
                        const int maxDim = 256;

                        Surface thumb;
                        Surface flattened = BorrowScratchSurface(this.GetType().Name + ".DoSave() preparing embedded thumbnail");

                        try
                        {
                            Document.Flatten(flattened);

                            if (Document.Width > maxDim || Document.Height > maxDim)
                            {
                                int width;
                                int height;

                                if (Document.Width > Document.Height)
                                {
                                    width = maxDim;
                                    height = (Document.Height * maxDim) / Document.Width;
                                }
                                else
                                {
                                    height = maxDim;
                                    width = (Document.Width * maxDim) / Document.Height;
                                }

                                int thumbWidth = Math.Max(1, width);
                                int thumbHeight = Math.Max(1, height);

                                thumb = new Surface(thumbWidth, thumbHeight);
                                thumb.SuperSamplingFitSurface(flattened);
                            }
                            else
                            {
                                thumb = new Surface(flattened.Size);
                                thumb.CopySurface(flattened);
                            }
                        }

                        finally
                        {
                            ReturnScratchSurface(flattened);
                        }

                        Document thumbDoc = new Document(thumb.Width, thumb.Height);
                        BitmapLayer thumbLayer = new BitmapLayer(thumb);
                        BitmapLayer backLayer = new BitmapLayer(thumb.Width, thumb.Height);
                        backLayer.Surface.Clear(ColorBgra.Transparent);
                        thumb.Dispose();
                        thumbDoc.Layers.Add(backLayer);
                        thumbDoc.Layers.Add(thumbLayer);
                        MemoryStream thumbPng = new MemoryStream();
                        PropertyBasedSaveConfigToken pngToken = PdnFileTypes.Png.CreateDefaultSaveConfigToken();
                        PdnFileTypes.Png.Save(thumbDoc, thumbPng, pngToken, null, null, false);
                        byte[] thumbBytes = thumbPng.ToArray();

                        string thumbString = Convert.ToBase64String(thumbBytes, Base64FormattingOptions.None);
                        thumbDoc.Dispose();

                        string thumbXml = "<thumb png=\"" + thumbString + "\" />";
                        Document.CustomHeaders = thumbXml;
                    }
                }

                // save!
                bool success = false;
                Stream stream = null;

                try
                {
                    stream = (Stream)new FileStream(newFileName, FileMode.Create, FileAccess.Write);

                    using (new WaitCursorChanger(this))
                    {
                        Utility.GCFullCollect();

                        SaveProgressDialog sd = new SaveProgressDialog(this);
                        Surface scratch = BorrowScratchSurface(this.GetType().Name + ".DoSave() handing off scratch surface to SaveProgressDialog.Save()");

                        try
                        {
                            sd.Save(stream, Document, newFileType, newSaveConfigToken, scratch);
                        }

                        finally
                        {
                            ReturnScratchSurface(scratch);
                        }

                        success = true;

                        this.lastSaveTime = DateTime.Now;

                        stream.Close();
                        stream = null;
                    }
                }

                catch (UnauthorizedAccessException)
                {
                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.UnauthorizedAccessException"));
                }

                catch (SecurityException)
                {
                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.SecurityException"));
                }

                catch (DirectoryNotFoundException)
                {
                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.DirectoryNotFoundException"));
                }

                catch (IOException)
                {
                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.IOException"));
                }

                catch (OutOfMemoryException)
                {
                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.OutOfMemoryException"));
                }

#if !DEBUG
                catch (Exception)
                {
                    Utility.ErrorBox(this, PdnResources.GetString("SaveImage.Error.Exception"));
                }
#endif

                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                        stream = null;
                    }
                }

                if (success)
                {
                    Shell.AddToRecentDocumentsList(newFileName);
                }
                else
                {
                    return false;
                }

                // reset the dirty bit so they won't be asked to save on quitting
                Document.Dirty = false;

                // some misc. book keeping ...
                AddToMruList();

                // and finally, shout happiness by way of ...
                return true;
            }
        }
Ejemplo n.º 6
0
        protected void LoadDocumentLayer(Document doc, BytePtr ibuf, int sz, string name)
        {
            BitmapLayer layer;
            Bitmap bmp;
            PDJPG_LayerInfo linf;
            byte[] rgba;
            byte[] norm;
            byte[] spec;
            byte[] luma;
            int xs, ys, ox, oy, ln, fl;
//            int i, j;

            rgba = new byte[4096 * 4096 * 4];
            norm = new byte[4096 * 4096 * 4];
            spec = new byte[4096 * 4096 * 4];
            luma = new byte[4096 * 4096 * 4];

            PDJPG.PDJPG_DecodeComponent(ibuf, sz, rgba, norm, spec, luma, out xs, out ys, out linf);
            fl = linf.flags;

            //PDJPG_DecodeHasComponent()

            ln = doc.Layers.Count;
            //doc.Layers.Insert(ln, null);

            if (true)
            {
                //layer = new BitmapLayer(xs, ys);
                layer = new BitmapLayer(doc.Width, doc.Height);
                layer.Name = name;
                layer.Opacity = linf.alpha;
                layer.Visible = true;

                if((fl&PDJPG.PDJPG_BCSFL_LAYER_HIDDEN)!=0)
                    layer.Visible = false;

                if ((fl & PDJPG.PDJPG_BCSFL_ALPHACYAN) != 0)
                {
                    BlendByteBufferInverseTransparentColor(rgba, xs, ys);
                }

                //bmp = BitmapFromByteBuffer(rgba, xs, ys);
                bmp = BitmapFromByteBuffer(rgba, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy);
                layer.Surface.CopyFromGdipBitmap(bmp, false);
                doc.Layers.Insert(ln++, layer);
            }

            if (PDJPG.PDJPG_DecodeHasComponent(ibuf, sz, "XYZ"))
            {
                //layer = new BitmapLayer(xs, ys);
                layer = new BitmapLayer(doc.Width, doc.Height);
                layer.Name = name + "::Normal";
                layer.Opacity = linf.alpha;
                layer.Visible = false;

                //bmp = BitmapFromByteBufferRGB(norm, xs, ys);
                bmp = BitmapFromByteBufferRGB(norm, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy);
                layer.Surface.CopyFromGdipBitmap(bmp, false);
                doc.Layers.Insert(ln++, layer);
            }

            if (PDJPG.PDJPG_DecodeHasComponent(ibuf, sz, "SpRGB"))
            {
                //layer = new BitmapLayer(xs, ys);
                layer = new BitmapLayer(doc.Width, doc.Height);
                layer.Name = name + "::Specular";
                layer.Opacity = linf.alpha;
                layer.Visible = false;

                //bmp = BitmapFromByteBufferRGB(spec, xs, ys);
                bmp = BitmapFromByteBufferRGB(spec, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy);
                layer.Surface.CopyFromGdipBitmap(bmp, false);
                doc.Layers.Insert(ln++, layer);
            }

            if (PDJPG.PDJPG_DecodeHasComponent(ibuf, sz, "LuRGB"))
            {
                //layer = new BitmapLayer(xs, ys);
                layer = new BitmapLayer(doc.Width, doc.Height);
                layer.Name = name + "::Luma";
                layer.Opacity = linf.alpha;
                layer.Visible = false;

                //bmp = BitmapFromByteBufferRGB(luma, xs, ys);
                bmp = BitmapFromByteBufferRGB(luma, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy);
                layer.Surface.CopyFromGdipBitmap(bmp, false);
                doc.Layers.Insert(ln++, layer);
            }

        }
Ejemplo n.º 7
0
        public void SaveRegion(PdnRegion saveMeRegion, Rectangle saveMeBounds)
        {
            BitmapLayer activeLayer = (BitmapLayer)ActiveLayer;

            if (savedTiles == null)
            {
                savedTiles = new BitVector2D(
                    (activeLayer.Width + saveTileGranularity - 1) / saveTileGranularity,
                    (activeLayer.Height + saveTileGranularity - 1) / saveTileGranularity);

                savedTiles.Clear(false);
            }

            Rectangle regionBounds;

            if (saveMeRegion == null)
            {
                regionBounds = saveMeBounds;
            }
            else
            {
                regionBounds = saveMeRegion.GetBoundsInt();
            }

            Rectangle bounds = Rectangle.Union(regionBounds, saveMeBounds);

            bounds.Intersect(activeLayer.Bounds);

            int leftTile   = bounds.Left / saveTileGranularity;
            int topTile    = bounds.Top / saveTileGranularity;
            int rightTile  = (bounds.Right - 1) / saveTileGranularity;
            int bottomTile = (bounds.Bottom - 1) / saveTileGranularity;

            for (int tileY = topTile; tileY <= bottomTile; ++tileY)
            {
                Rectangle rowAccumBounds = Rectangle.Empty;

                for (int tileX = leftTile; tileX <= rightTile; ++tileX)
                {
                    if (!savedTiles.Get(tileX, tileY))
                    {
                        Rectangle tileBounds = new Rectangle(tileX * saveTileGranularity, tileY * saveTileGranularity,
                                                             saveTileGranularity, saveTileGranularity);

                        tileBounds.Intersect(activeLayer.Bounds);

                        if (rowAccumBounds == Rectangle.Empty)
                        {
                            rowAccumBounds = tileBounds;
                        }
                        else
                        {
                            rowAccumBounds = Rectangle.Union(rowAccumBounds, tileBounds);
                        }

                        savedTiles.Set(tileX, tileY, true);
                    }
                    else
                    {
                        if (rowAccumBounds != Rectangle.Empty)
                        {
                            using (Surface dst = ScratchSurface.CreateWindow(rowAccumBounds),
                                   src = activeLayer.Surface.CreateWindow(rowAccumBounds))
                            {
                                dst.CopySurface(src);
                            }

                            rowAccumBounds = Rectangle.Empty;
                        }
                    }
                }

                if (rowAccumBounds != Rectangle.Empty)
                {
                    using (Surface dst = ScratchSurface.CreateWindow(rowAccumBounds),
                           src = activeLayer.Surface.CreateWindow(rowAccumBounds))
                    {
                        dst.CopySurface(src);
                    }

                    rowAccumBounds = Rectangle.Empty;
                }
            }

            if (this.saveRegion != null)
            {
                this.saveRegion.Dispose();
                this.saveRegion = null;
            }

            if (saveMeRegion != null)
            {
                this.saveRegion = saveMeRegion.Clone();
            }
        }
Ejemplo n.º 8
0
 public static BitmapLayer ResizeLayer(BitmapLayer layer, int width, int height, ResamplingAlgorithm algorithm)
 {
     bool pleaseStop = false;
     return ResizeLayer(layer, width, height, algorithm, 0, null, ref pleaseStop);
 }
Ejemplo n.º 9
0
        private static BitmapLayer ResizeLayer(BitmapLayer layer, int width, int height, ResamplingAlgorithm algorithm,
            int tileCount, Procedure progressCallback, ref bool pleaseStopMonitor)
        {
            Surface surface = new Surface(width, height);
            surface.Clear(ColorBgra.FromBgra(255, 255, 255, 0));

            PaintDotNet.Threading.ThreadPool threadPool = new PaintDotNet.Threading.ThreadPool();
            int rectCount;
            
            if (tileCount == 0)
            {
                rectCount = Processor.LogicalCpuCount;
            }
            else
            {
                rectCount = tileCount;
            }

            Rectangle[] rects = new Rectangle[rectCount];
            Utility.SplitRectangle(surface.Bounds, rects);

            FitSurfaceContext fsc = new FitSurfaceContext(surface, layer.Surface, rects, algorithm);

            if (progressCallback != null)
            {
                fsc.RenderedRect += progressCallback;
            }

            WaitCallback callback = new WaitCallback(fsc.FitSurface);

            for (int i = 0; i < rects.Length; ++i)
            {
                if (pleaseStopMonitor)
                {
                    break;
                }
                else
                {
                    threadPool.QueueUserWorkItem(callback, BoxedConstants.GetInt32(i));
                }
            }

            threadPool.Drain();
            threadPool.DrainExceptions();

            if (pleaseStopMonitor)
            {
                surface.Dispose();
                surface = null;
            }

            BitmapLayer newLayer;

            if (surface == null)
            {
                newLayer = null;
            }
            else
            {
                newLayer = new BitmapLayer(surface, true);
                newLayer.LoadProperties(layer.SaveProperties());
            }

            if (progressCallback != null)
            {
                fsc.RenderedRect -= progressCallback;
            }

            return newLayer;
        }
Ejemplo n.º 10
0
        // TODO: add "name" parameter, keep this for legacy and fill it in with "Background"
        //       goal is to put complete burden of loc on the client
        public static BitmapLayer CreateBackgroundLayer(int width, int height)
        {
            // set colors to 0xffffffff
            // note: we use alpha of 255 here so that "invert colors" works as expected
            // that is, for just 1 layer we invert the initial white->black
            // but on subsequent layers we invert transparent white -> transparent black, which shows up as white for the most part
            BitmapLayer layer = new BitmapLayer(width, height, ColorBgra.White);

            layer.Name = PdnResources.GetString("Layer.Background.Name");

            // tag it as a background layer
            layer.properties.isBackground = true;

            return layer;
        }
Ejemplo n.º 11
0
 protected BitmapLayer(BitmapLayer copyMe)
     : base(copyMe)
 {
     this.surface    = copyMe.Surface.Clone();
     this.properties = (BitmapLayerProperties)copyMe.properties.Clone();
 }
Ejemplo n.º 12
0
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);

            if (!(ActiveLayer is BitmapLayer))
            {
                return;
            }

            Cursor = cursorMouseDown;

            if (IsMouseLeftDown(e))
            {
                this.rendererDst.Visible = false;

                if (IsCtrlDown())
                {
                    GetStaticData().takeFrom = new Point(e.X, e.Y);

                    this.rendererSrc.BrushLocation = new Point(e.X, e.Y);
                    this.rendererSrc.BrushSize = AppEnvironment.PenInfo.Width / 2.0f;
                    this.rendererSrc.Visible = true;
                    GetStaticData().updateSrcPreview = false;

                    GetStaticData().wr = new WeakReference(((BitmapLayer)ActiveLayer));
                    takeFromLayer = (BitmapLayer)(GetStaticData().wr.Target);
                    GetStaticData().lastMoved = Point.Empty;
                    ra = new RenderArgs(((BitmapLayer)ActiveLayer).Surface);
                }
                else
                {
                    GetStaticData().updateSrcPreview = true;

                    // Determine if there is something to work if, if there isn't return
                    if (GetStaticData().takeFrom == Point.Empty)
                    {
                    }
                    else if (!GetStaticData().wr.IsAlive || takeFromLayer == null)
                    {
                        GetStaticData().takeFrom = Point.Empty;
                        GetStaticData().lastMoved = Point.Empty;
                    }
                    // Make sure the layer is still there!
                    else if (takeFromLayer != null && !Document.Layers.Contains(takeFromLayer))
                    {   
                        GetStaticData().takeFrom = Point.Empty;
                        GetStaticData().lastMoved = Point.Empty;
                    }
                    else
                    {
                        this.antialiasing = AppEnvironment.AntiAliasing;
                        this.ra = new RenderArgs(((BitmapLayer)ActiveLayer).Surface);
                        this.ra.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
                        OnMouseMove(e);
                    }
                }
            }
        }
Ejemplo n.º 13
0
        protected override void OnActivate()
        {
            base.OnActivate();
            
            cursorMouseDown = new Cursor(PdnResources.GetResourceStream("Cursors.GenericToolCursorMouseDown.cur"));
            cursorMouseDownSetSource = new Cursor(PdnResources.GetResourceStream("Cursors.CloneStampToolCursorSetSource.cur"));
            cursorMouseUp = new Cursor(PdnResources.GetResourceStream("Cursors.CloneStampToolCursor.cur"));
            this.Cursor = cursorMouseUp;

            this.rendererDst = new BrushPreviewRenderer(this.RendererList);
            this.RendererList.Add(this.rendererDst, false);

            this.rendererSrc = new BrushPreviewRenderer(this.RendererList);
            this.rendererSrc.BrushLocation = GetStaticData().takeFrom;
            this.rendererSrc.BrushSize = AppEnvironment.PenInfo.Width / 2.0f;
            this.rendererSrc.Visible = (GetStaticData().takeFrom != Point.Empty);
            this.RendererList.Add(this.rendererSrc, false);

            if (ActiveLayer != null)
            {
                switchedTo = true;
                historyRects = new Vector<Rectangle>();

                if (GetStaticData().wr != null && GetStaticData().wr.IsAlive)
                {
                    takeFromLayer = (BitmapLayer)GetStaticData().wr.Target;
                }
                else
                {
                    takeFromLayer = null;
                }
            }

            AppEnvironment.PenInfoChanged += new EventHandler(Environment_PenInfoChanged);
        }