sxskinlibrary.pas

skin components for design of your applicastions

 if not FD.SetDoPrepaint then
  begin
   FD.SetDoPrepaint:=FDToAdd.SetDoPrepaint;
   FD.DoPrepaint:=FDToAdd.DoPrepaint;
  end;
end;

procedure SetDefaultFontData(var FD:TSXFontData;Font:TFont);
begin
 if not FD.SetFontName then
  begin
   FD.FontName:=Font.Name;
   FD.SetFontName:=True;
  end;
 if not FD.SetFontSize then
  begin
   FD.FontSize:=Font.Size;
   FD.SetFontSize:=True;
  end;
 if not FD.SetFontStyle then
  begin
   FD.FontStyle:=Font.Style;
   FD.SetFontStyle:=True;
  end;
 if not FD.SetFontColor then
  begin
   FD.FontColor:=Color32(Font.Color);
   FD.SetFontColor:=True;
  end; 
end;

function TryToSetFontDataParameter(const Name,Value:String;var FD:TSXFontData):Boolean;
var C:Integer;
begin
 Result:=False;
 with FD do
  begin
   if Name='FontName' then
    begin
     FontName:=Trim(Value);
     SetFontName:=True;
     Result:=True;
    end else
   if Name='FontSize' then
    begin
     FontSize:=StrToIntDef(Value,0);
     SetFontSize:=True;
     Result:=True;
    end else
   if Name='FontColor' then
    begin
     FontColor:=GetColorFromString(Value);
     SetFontColor:=True;
     Result:=True;
    end else
   if Name='HasTextShadow' then
    begin
     HasShadow:=Value='1';
     SetHasShadow:=True;
     Result:=True;
    end else
   if Name='ShadowColor' then
    begin
     ShadowColor:=GetColorFromString(Value);
     SetShadowColor:=True;
     Result:=True;
    end else
   if Name='SmoothLevel' then
    begin
     SmoothLevel:=StrToIntDef(Value,0);
     SetSmoothLevel:=True;
     Result:=True;
    end else
   if Name='DoPrepaint' then
    begin
     DoPrepaint:=Value='1';
     SetDoPrepaint:=True;
     Result:=True;
    end else
   if Name='FontStyle' then
    begin
     for C:=1 to length(Value) do
      case Value[C] of
       'B','b': FontStyle:=FontStyle+[fsBold];
       'I','i': FontStyle:=FontStyle+[fsItalic];
       'U','u': FontStyle:=FontStyle+[fsUnderline];
       'S','s': FontStyle:=FontStyle+[fsStrikeOut];
      end;
     SetFontStyle:=True;
     Result:=True;
    end;
  end;
end;

function SameFilterData(const Filter1,Filter2:TSXFilterData):Boolean;
begin
 Result:=((Filter1.AType=iftNone) and (Filter2.AType=iftNone)) or
         ((Filter1.AType=Filter2.AType) and (Filter1.Color=Filter2.Color) and
          (Filter1.Color2=Filter2.Color2) and (Filter1.Value=Filter2.Value));
end;

function TryToSetFilterDataParameter(const Name,Value:String;var Filter:TSXFilterData;
           const Prefix:String=''):Boolean;
var AName:String;
begin
 Result:=False;
 if (Prefix<>'') and (Copy(Name,1,length(Prefix))<>Prefix) then exit;
 if Prefix='' then AName:=Name else
  AName:=Copy(Name,length(Prefix)+1,MaxInt);
 if AName='Filter' then
  begin
   Filter.AType:=GetFilterTypeByName(Value);
   Filter.SetAType:=True;
   Result:=True;
  end else
 if (AName='FilterColor') or (AName='FilterColor1') then
  begin
   Filter.Color:=GetColorFromString(Value);
   Filter.SetColor:=True;
   if Filter.AType in [iftLighten,iftLightenHorizG,iftLightenVertG,iftDarken,
    iftDarkenHorizG,iftDarkenVertG] then Filter.Color:=Filter.Color and $00FFFFFF;
   Result:=True;
  end else
 if AName='FilterColor2' then
  begin
   Filter.Color2:=GetColorFromString(Value);
   Filter.SetColor2:=True;
   if Filter.AType in [iftLighten,iftLightenHorizG,iftLightenVertG,iftDarken,
    iftDarkenHorizG,iftDarkenVertG] then Filter.Color2:=Filter.Color2 and $00FFFFFF;
   Result:=True;
  end else
 if AName='FilterValue' then
  begin
   Filter.Value:=StrToIntDef(Value,0);
   Filter.SetValue:=True;
   Result:=True;
  end;
end;

function SameTransformEffectData(const Effect1,Effect2:TSXTransformEffectData):Boolean;
begin
 Result:=CompareMem(@Effect1,@Effect2,sizeof(TSXTransformEffectData));
end;

function TryToSetTransformEffectDataParameter(const Name,Value:String;
           var Effect:TSXTransformEffectData;const Prefix:String=''):Boolean;
var AName:String;
begin
 Result:=False;
 if (Prefix<>'') and (Copy(Name,1,length(Prefix))<>Prefix) then exit;
 if Prefix='' then AName:=Name else
  AName:=Copy(Name,length(Prefix)+1,MaxInt);
 with Effect do
  begin
   if AName='Transform' then
    begin
     GetTransformEffectByName(Value,Effect);
     Result:=True;
    end else
   if AName='TransformO' then
    begin
     SetOldType:=True;
     OldType:=GetTransformEffectTypeByName(Value);
     Result:=True;
    end else
   if AName='TransformDirO' then
    begin
     SetOldDirection:=True;
     OldDirection:=GetTransformEffectDirectionByName(Value);
     Result:=True;
    end else
   if AName='TransformOutO' then
    begin
     SetOldDirOut:=True;
     OldDirOut:=Value='1';
     Result:=True;
    end else
   if AName='TransformInvertO' then
    begin
     SetOldInverted:=True;
     OldInverted:=Value='1';
     Result:=True;
    end else
   if AName='TransformN' then
    begin
     SetNewType:=True;
     NewType:=GetTransformEffectTypeByName(Value);
     Result:=True;
    end else
   if AName='TransformDirN' then
    begin
     SetNewDirection:=True;
     NewDirection:=GetTransformEffectDirectionByName(Value);
     Result:=True;
    end else
   if AName='TransformOutN' then
    begin
     SetNewDirOut:=True;
     NewDirOut:=Value='1';
     Result:=True;
    end else
   if AName='TransformInvertN' then
    begin
     SetNewInverted:=True;
     NewInverted:=Value='1';
     Result:=True;
    end else
   if AName='TransformOffset' then
    begin
     SetOffset:=True;
     Offset:=StrToIntDef(Value,0);
     Result:=True;
    end else
   if AName='TransformOldOnTop' then
    begin
     SetOldOnTop:=True;
     OldOnTop:=Value='1';
     Result:=True;
    end else
   if AName='TransformDrawCaption' then
    begin
     SetDrawCaption:=True;
     DrawCaption:=Value='1';
     Result:=True;
    end else
   if AName='StepsNum' then
    begin
     SetStepsNum:=True;
     StepsNum:=StrToIntDef(Value,0);
     Result:=True;
    end;
  end;
end;

{ TSXVariableComparer }

function TSXVariableComparer.GetVarListForRect(const S:String):TList;
var R:TRect;
begin
 CurValList:=nil;
 GetRectFromString(S,R,VarListOnGetVariable);
 Result:=CurValList;
end;

function TSXVariableComparer.GetVarListForPoly(const S:String):TList;
var P:TPolygon32;
begin
 CurValList:=nil;
 P:=TPolygon32.Create;
 try
  GetPolygonFromString(S,P,VarListOnGetVariable);
 finally
  P.Free;
 end;
 Result:=CurValList;
end;

{ TSXStdVariableComparer }

function TSXStdVariableComparer.VarListOnGetVariable(const VarName:String;var Error:Boolean):Single;
var CurVarVal:Integer;
begin
 Result:=1234;
 CurVarVal:=-1;
 if VarName='W' then
  CurVarVal:=VARSTD_W else
 if VarName='H' then
  CurVarVal:=VARSTD_H;
 if CurVarVal>=0 then
  begin
   if CurValList=nil then
    CurValList:=TList.Create;
   CurValList.Add(Pointer(CurVarVal));
  end;
end;

function TSXStdVariableComparer.IntOnGetVariable(const VarName:String;var Error:Boolean):Single;
begin
 Result:=0;
 if VarName='W' then
  begin
   Result:=Width; exit;
  end;
 if VarName='H' then
  begin
   Result:=Height; exit;
  end;
 Error:=True;
end;

function TSXStdVariableComparer.GetValue(VarID:Integer):Integer;
begin
 Result:=0;
 case VarID of
  VARSTD_W: Result:=Width;
  VARSTD_H: Result:=Height;
 end;
end;

procedure TSXStdVariableComparer.SetSize(AWidth,AHeight:Integer);
begin
 Width:=AWidth;
 Height:=AHeight;
end;

procedure TSXStdVariableComparer.GetSize(var AWidth,AHeight:Integer);
begin
 AWidth:=Width;
 AHeight:=Height;
end;

function TSXStdVariableComparer.GetVarValsForVarList(VarList:TList):TList;
var A:Integer;
begin
 if VarList=nil then
  begin
   Result:=nil;
   exit;
  end;
 Result:=TList.Create;
 for A:=0 to VarList.Count-1 do
  Result.Add(Pointer(GetValue(Integer(VarList[A]))));
end;

function TSXStdVariableComparer.Changed(VarList:TList;OldVarVals:TList):Boolean;
var A:Integer;
begin
 Result:=False;
 if VarList=nil then exit;
 for A:=0 to VarList.Count-1 do
  if Integer(OldVarVals[A])<>GetValue(Integer(VarList[A])) then
   begin
    Result:=True;
    exit;
   end;
end;

procedure TSXStdVariableComparer.Update(VarList:TList;VarVals:TList);
var A:Integer;
begin
 if VarList=nil then exit;
 for A:=0 to VarList.Count-1 do
  VarVals[A]:=Pointer(GetValue(Integer(VarList[A])));
end;

procedure TSXStdVariableComparer.DestroyVarList(VarList:TList);
begin
 VarList.Free;
end;

procedure TSXStdVariableComparer.DestroyVarVals(VarList:TList;VarVals:TList);
begin
 VarVals.Free;
end;

constructor TSXStdVariableComparer.Create;
begin
 inherited Create;
 OnGetVariable:=IntOnGetVariable;
end;

{ TSXSkinStyleElement }

procedure TSXSkinStyleElement.Assign(Element:TSXSkinStyleElement);
begin
 Name:=Element.Name;
end;

function TSXSkinStyleElement.GetCopy:TSXSkinStyleElement;
begin
 Result:=TSXSkinStyleElement.Create;
 Result.Assign(Self);
end;

procedure TSXSkinStyleElement.SetProperty(const Name,Value,SkinFilePath:String);
begin
end;

procedure TSXSkinStyleElement.SaveToStream(S:TStream;const RootPath:String);
var AType:TSXSkinStyleElementType;
begin
 if Self is TSXSkinStyleImageElement then AType:=ssetImage else
  if Self is TSXSkinStyleBoxTileElement then AType:=ssetBoxTile else
  if Self is TSXSkinStyleFigureElement then AType:=ssetFigure else
  if Self is TSXSkinStyleTextElement then AType:=ssetText else
  if Self is TSXSkinStyleStyleElement then AType:=ssetStyle else
   AType:=ssetUnknown;
 S.Write(AType,sizeof(AType));  
 SaveString(S,Name);
end;

procedure TSXSkinStyleElement.LoadFromStream(S:TStream;Version:Integer;
           const RootPath,ZipFilePath:String);
begin
 LoadString(S,Name);
end;

{ TSXSkinStyleImageElement }

procedure TSXSkinStyleImageElement.Assign(Element:TSXSkinStyleElement);
begin
 inherited;
 if Element is TSXSkinStyleImageElement then
  begin
   ImageType:=TSXSkinStyleImageElement(Element).ImageType;
   LoadedPath:=TSXSkinStyleImageElement(Element).LoadedPath;
   Path:=TSXSkinStyleImageElement(Element).Path;
   ZipFilePath:=TSXSkinStyleImageElement(Element).ZipFilePath;
   Transparent:=TSXSkinStyleImageElement(Element).Transparent;
   Filter:=TSXSkinStyleImageElement(Element).Filter;
   ResizeMode:=TSXSkinStyleImageElement(Element).ResizeMode;
   StretchFilter:=TSXSkinStyleImageElement(Element).StretchFilter;
   OffsetX:=TSXSkinStyleImageElement(Element).OffsetX;
   OffsetY:=TSXSkinStyleImageElement(Element).OffsetY;
   ResizedWidth:=TSXSkinStyleImageElement(Element).ResizedWidth;
   ResizedHeight:=TSXSkinStyleImageElement(Element).ResizedHeight;
   Centered:=TSXSkinStyleImageElement(E