unit ZMXcpt19;

(*
  ZMXcpt19.pas - Exception class for ZipMaster
    Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht,
      Eric W. Engler and Chris Vleghert.

	This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).
    updates: http://www.delphizip.org
    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip 

  modified 2009-11-22
---------------------------------------------------------------------------*)

interface

uses
  SysUtils;
       
{$IFNDEF UNICODE}
type
  TZMXArgs = (zxaNoStr, zxaStr, zxa2Str);
{$ENDIF}

type
  EZMException = class(Exception)
{$IFNDEF UNICODE}
  private
    fArgs: TZMXArgs;
    fStr1: String;
    fStr2: string;
{$ENDIF}
  protected
    // We do not always want to see a message after an exception.
    fDisplayMsg: Boolean; 
    // We also save the Resource ID in case the resource is not linked in the application.
    fResIdent: Integer;
    constructor CreateResFmt(Ident: Integer; const Args: array of const);
  public
    constructor CreateDisp(const Message: String; const Display: Boolean);

    constructor CreateResDisp(Ident: Integer; const Display: Boolean);
    constructor CreateResInt(Ident, anInt: Integer);
    constructor CreateResStr(Ident: Integer; const Str1: String);
    constructor CreateRes2Str(Ident: Integer; const Str1, Str2: String); 
{$IFNDEF UNICODE}
    function TheMessage(AsUTF8: boolean): string;
{$ENDIF}

    property ResId: Integer Read fResIdent write fResIdent;
    property DisplayMsg: boolean Read fDisplayMsg;
  end;

type
  EZipMaster = class(EZMException)

  end;


implementation

uses
  ZMMsg19, ZMMsgStr19 {$IFNDEF UNICODE}, ZMUTF819{$ENDIF};

const
  ERRORMSG: String = 'Failed to Locate string';

// allow direct translation for negative error values
function Id(err: integer): integer;
begin
  Result := err;
  if (Result < 0) and (Result >= -TM_SystemError)
    and (Result <= -DT_Language) then
    Result := -Result;
end;

//constructor EZMException.Create(const msg: String);
//begin
//  inherited Create(msg);
//  fDisplayMsg := True;
//  fResIdent   := DS_UnknownError;
//end;

constructor EZMException.CreateDisp(const Message: String; const Display: Boolean);
begin
  inherited Create(Message);
  fDisplayMsg := Display;
  fResIdent   := DS_UnknownError;
{$IFNDEF UNICODE}
  fArgs := zxaNoStr;
{$ENDIF}
end;

constructor EZMException.CreateResFmt(Ident: Integer; const Args: array of const);
begin
//  CreateFmt(Ident, Args);
  inherited Create(ERRORMSG);
  fResIdent := Id(Ident);
  Message := LoadZipStr(fResIdent);
  Message := Format(Message, Args);
  fDisplayMsg := True;   
{$IFNDEF UNICODE}
  fArgs := zxaNoStr;
{$ENDIF}
end;

constructor EZMException.CreateResDisp(Ident: Integer; const Display: Boolean);
begin
  inherited Create(ERRORMSG);
  fResIdent := Id(Ident);
  Message := LoadZipStr(fResIdent);
  fDisplayMsg := Display;  
{$IFNDEF UNICODE}
  fArgs := zxaNoStr;
{$ENDIF}
end;

constructor EZMException.CreateResInt(Ident, anInt: Integer);
begin
  CreateResFmt(Ident, [anInt]);
end;

constructor EZMException.CreateResStr(Ident: Integer; const Str1: String);
begin
  CreateResFmt(Ident, [Str1]); 
{$IFNDEF UNICODE}
  fArgs := zxaStr;
  fStr1 := Str1;
{$ENDIF}
end;

constructor EZMException.CreateRes2Str(Ident: Integer; const Str1, Str2: String);
begin
  CreateResFmt(Ident, [Str1, Str2]);  
{$IFNDEF UNICODE}
  fArgs := zxa2Str;
  fStr1 := Str1;
  fStr2 := Str2;
{$ENDIF}
end;

{$IFNDEF UNICODE}
function EZMException.TheMessage(AsUTF8: boolean): string;
begin
  if not AsUTF8 then
    Result := Message
  else
  begin
    if fArgs <= zxaNoStr then
      Result := StrToUTF8(Message)
    else
    begin
      Result := LoadZipStr(fResIdent);
      if Result <> '' then
      begin
        // we need the format string as UTF8
        Result := StrToUTF8(Result);
        case fArgs of
          zxaStr:Result := Format(Result, [fStr1]);
          zxa2Str:Result := Format(Result, [fStr1, fStr2]);
        end;
      end;
    end;
  end;
end;
{$ENDIF}

end.