sxskinregionmanager.pas

skin components for design of your applicastions

   R.Resized:=False;
   R.Width:=0; R.Height:=0;
   A:=PreloadedRegions.GetRegionIndex(R);
   if A>=0 then
    begin
     R.Resized:=True;
     R.Width:=Width; R.Height:=Height;
     W:=Width; H:=Height;
     if W=0 then W:=PreloadedRegions[A].Width;
     if H=0 then H:=PreloadedRegions[A].Height;
     if Tile then
      begin
       Result:=TileRegion(R.Region,PreloadedRegions[A].Width,PreloadedRegions[A].Height,W,H);
       R.Free;
       exit;
      end;
     B:=GetRegionData(PreloadedRegions[A].Region,0,nil);
     if B>=0 then
      begin
       GetMem(RgnData,B);
       GetRegionData(PreloadedRegions[A].Region,B,RgnData);
       FillChar(XForm,sizeof(XForm),0);
       if PreloadedRegions[A].Width>0 then
        XForm.eM11:=W/PreloadedRegions[A].Width;
       if PreloadedRegions[A].Height>0 then
        XForm.eM22:=H/PreloadedRegions[A].Height;
       R.Region:=ExtCreateRegion(@XForm,B,RgnData^);
       FreeMem(RgnData);
      end;
     Result:=R.Region;
     PreloadedRegions.Add(R);
     exit;
    end;
  end;
 R.Width:=Width;
 R.Height:=Height;
 //
 if SameText(ExtractFileExt(FilePath),'.png') then
  ImageType:=ssitPNG else ImageType:=ssitJPEG;
 B2:=nil; 
 case ImageType of
  ssitJPEG: begin
             JPG:=TJpegImage.Create;
             try
              try
               if ZipFilePath<>'' then
                begin
                 MS:=TMemoryStream.Create;
                 try
                  ZipFile:=GetPreloadedZipFile(SkinLibrary,ZipFilePath);
                  if ZipFile<>nil then
                   begin
                    ZipFile.WriteFileToStream(MS,FilePath);
                    MS.Seek(0,soFromBeginning);
                    if MS.Size>0 then
                     JPG.LoadFromStream(MS);
                   end;
                 finally
                  MS.Free;
                 end;
                end else
               if FileExists(FilePath) then
                JPG.LoadFromFile(FilePath);
              except
              end;
              B2:=TBitmap32.Create;
              B2.Assign(JPG);
             finally
              JPG.Free;
             end;
            end;
  ssitPNG:  begin
             PNG:=TPNGObject.Create;
             try
              try
               if ZipFilePath<>'' then
                begin
                 MS:=TMemoryStream.Create;
                 try
                  ZipFile:=GetPreloadedZipFile(SkinLibrary,ZipFilePath);
                  if ZipFile<>nil then
                   begin
                    ZipFile.WriteFileToStream(MS,FilePath);
                    MS.Seek(0,soFromBeginning);
                    if MS.Size>0 then
                     PNG.LoadFromStream(MS);
                   end;
                 finally
                  MS.Free;
                 end;
                end else
               if FileExists(FilePath) then
                PNG.LoadFromFile(FilePath);
              except
              end;
              B2:=TBitmap32.Create;
              PNGObjectToBitmap32(PNG,B2);
             finally
              PNG.Free;
             end;
            end;
 end;
 if B2=nil then
  begin
   Result:=0;
   exit;
  end;
 if (B2.Width=0) or (B2.Height=0) then
  begin
   Result:=CreateRectRgn(0,0,0,0);
   exit;
  end;
 BmpWidth:=B2.Width;
 BmpHeight:=B2.Height;
 R.Region:=CreateRgnFromBitmap(B2,Color,ColorMask);
 B2.Free;
 //
 if Resized then
  begin
   W:=Width; H:=Height;
   if W=0 then W:=BmpWidth;
   if H=0 then H:=BmpHeight;
   if Tile then
    begin
     Result:=TileRegion(R.Region,BmpWidth,BmpHeight,W,H);
     R.Free;
     exit;
    end;
   if (W<>BmpWidth) or (H<>BmpHeight) then
    begin
     B:=GetRegionData(R.Region,0,nil);
     if B>=0 then
      begin
       GetMem(RgnData,B);
       GetRegionData(R.Region,B,RgnData);
       FillChar(XForm,sizeof(XForm),0);
       if BmpWidth>0 then
        XForm.eM11:=W/BmpWidth;
       if BmpHeight>0 then
        XForm.eM22:=H/BmpHeight;
       DeleteObject(R.Region);
       R.Region:=ExtCreateRegion(@XForm,B,RgnData^);
       FreeMem(RgnData);
      end;
    end;
  end;
 Result:=R.Region;
 if Resized and not SaveResized then
  begin
   R.Region:=0;
   R.Free;
  end else PreloadedRegions.Add(R);
end;

procedure DeletePreloadedRegions(SkinLibrary:TSXSkinCustomLibrary);
var A:Integer;
begin
 for A:=PreloadedRegions.Count-1 downto 0 do
  if PreloadedRegions[A].SkinLibrary=SkinLibrary then
   PreloadedRegions.Delete(A);
end;

function EvaluateRegion(const Region,SkinFilePath:String;ZipFilePath:String;
           Width,Height:Integer;SkinLibrary:TSXSkinLibrary;SaveResized:Boolean;
           AOnGetVariable:TSXOnGetVariable=nil):HRGN;
var     A,B,D:Integer;
       TmpRgn:HRGN;
      TmpRgn2:HRGN;
  ParserState:(psNeedType,
               psNeedRectCoord,
               psNeedEllipseCoord,
               psNeedRoundRectCoord,
               psNeedPolygonCoord,
               psNeedImagePathOffset,
               psNeedImagePath,
               psNeedImageOffsetX,
               psNeedImageOffsetY,
               psNeedImageWidth,
               psNeedImageHeight,
               psNeedImageColor,
               psNeedImageColorMask,
               psNeedBoxTilePathOffset,
               psNeedBoxTilePath,
               psNeedBoxTileRSMOffset,
               psNeedBoxTileRSM,
               psNeedBoxTileOffsetX,
               psNeedBoxTileOffsetY,
               psNeedBoxTileWidth,
               psNeedBoxTileHeight,
               psNeedBoxTileColor,
               psNeedBoxTileColorMask,
               psNeedBoxTileLeft,
               psNeedBoxTileRight,
               psNeedBoxTileTop,
               psNeedBoxTileBottom);
    Operation:(opIntersect,
               opCombine,
               opDifference,
               opExclusiveOr);
      Inverse:Boolean;
   PolyCoords:array of TPoint;
       Coords:array of Integer;
   PolyCoordN:Integer;
     PolyGotX:Boolean;
    CurParamN:Integer;
  ImagePath,S:String;
   ImageWidth:Integer;
  ImageHeight:Integer;
 ImageOffsetX:Integer;
 ImageOffsetY:Integer;
        Color:TColor32;
    ColorMask:TColor32;
       BTLeft:Integer;
      BTRight:Integer;
        BTTop:Integer;
     BTBottom:Integer;
    BTCenterW:Integer;
    BTCenterH:Integer;    
    RSMIsTile:Boolean;

 procedure SetWhatGot;
 var S2:String;
      E:Boolean;
   CM,C:Integer;
     R2:HRGN;
 begin
  if B>A then
   begin
    S2:=Copy(Region,A,B-A);
    case ParserState of
     psNeedType:              begin
                               if S2='Full' then
                                begin
                                 DeleteObject(Result);
                                 Result:=CreateRectRgn(0,0,Width,Height);
                                 exit;
                                end else
                                 begin
                                  Operation:=opCombine;
                                  Inverse:=False;
                                  while S2<>'' do
                                   begin
                                    case S2[1] of
                                     '!',
                                     '~': Inverse:=not Inverse;
                                     '+',
                                     '&': Operation:=opCombine;
                                     '*': Operation:=opIntersect;
                                     '-': Operation:=opDifference;
                                     '^': Operation:=opExclusiveOr;
                                     else break;
                                    end;
                                    Delete(S2,1,1);
                                   end;
                                  if S2='Rect' then
                                   ParserState:=psNeedRectCoord else
                                  if S2='Ellipse' then
                                   ParserState:=psNeedEllipseCoord else
                                  if S2='RoundRect' then
                                   ParserState:=psNeedRoundRectCoord else
                                  if S2='Polygon' then
                                   ParserState:=psNeedPolygonCoord else
                                  if S2='Image' then
                                   begin
                                    ParserState:=psNeedImagePath;
                                    ImageOffsetX:=0;
                                    ImageOffsetY:=0;
                                   end else
                                  if S2='ImageO' then
                                   ParserState:=psNeedImagePathOffset else
                                  if S2='BoxTile' then
                                   begin
                                    ParserState:=psNeedBoxTilePath;
                                    ImageOffsetX:=0;
                                    ImageOffsetY:=0;
                                   end else
                                  if S2='BoxTileO' then
                                   ParserState:=psNeedBoxTilePathOffset;
                                  CurParamN:=1;
                                  PolyCoordN:=0;
                                  PolyGotX:=False;
                                 end;
                              end;
     psNeedRectCoord,
     psNeedEllipseCoord,
     psNeedRoundRectCoord,
     psNeedPolygonCoord:      begin
                               if @AOnGetVariable=nil then
                                D:=StrToIntDef(S2,0) else
                                 begin
                                  E:=False;
                                  D:=round(SXEvalMathString(S2,AOnGetVariable,E));
                                  if E then D:=0;
                                 end;
                               if ParserState=psNeedPolygonCoord then
                                begin
                                 if CurParamN=1 then
                                  begin
                                   PolyCoordN:=D;
                                   SetLength(PolyCoords,D);
                                  end else
                                   begin
                                    if PolyGotX then
                                     PolyCoords[(CurParamN-2) div 2].Y:=D else
                                      PolyCoords[(CurParamN-2) div 2].X:=D;
                                    PolyGotX:=not PolyGotX;
                                   end;
                                 if CurParamN=1+2*PolyCoordN then
                                  begin
                                   ParserState:=psNeedType;
                                   TmpRgn:=CreatePolygonRgn(PolyCoords[0],PolyCoordN,ALTERNATE);
//                                   TmpRgn:=CreateRectRgn(PolyCoords[0].X,PolyCoords[0].Y,PolyCoords[1].X,PolyCoords[1].Y);
                                  end;
                                end else
                               if ParserState=psNeedRectCoord then