CPP_Builder/Componentes
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First commit 19/07/1998

Browse Source
This commit is contained in:
José David Guillén
2021-09-12 21:54:38 +02:00
commit b0116562cd
106 changed files with 16717 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CDopping/jpg3s/BUILDNO.TXT Normal file
View File

@ -0,0 +1 @@
This is build number 1525

BIN
CDopping/jpg3s/Copia de MWAJPGC3.BPL Normal file
View File

Binary file not shown.

11
CDopping/jpg3s/CrackingLib.txt Normal file
View File

@ -0,0 +1,11 @@
Libreria JPEG3s
// Comprobacion ? IDE FUNCIONANDO ? @4620C
S 7521 6A00 668B0D[C86C4400] B202
R EB...........................
!! Cambiar en el .BPL y .OBJ !!
Nota: Los corchetes indican que ese n<>mero es una referencia
a algo en memoria/c<>digo, lo que significa que con seguridad,
puede no ser el mismo.

530
CDopping/jpg3s/JPEGLIB.HPP Normal file
View File

@ -0,0 +1,530 @@
// Borland C++ Builder
// Copyright (c) 1995, 1998 by Borland International
// All rights reserved
// (DO NOT EDIT: machine generated header) 'jpeglib.pas' rev: 3.00
#ifndef jpeglibHPP
#define jpeglibHPP
#include <SysUtils.hpp>
#include <Dialogs.hpp>
#include <SysInit.hpp>
#include <System.hpp>
//-- user supplied -----------------------------------------------------------
namespace Jpeglib
{
//-- type declarations -------------------------------------------------------
typedef int Int;
typedef int *int_ptr;
typedef int size_t;
typedef Cardinal uInt;
typedef Cardinal *uint_ptr;
typedef short Short;
typedef Word ushort;
typedef int Long;
typedef int int8array[8];
typedef Byte JSAMPLE;
typedef short JCOEF;
typedef short *JCOEF_PTR;
typedef Byte JOCTET;
typedef Byte *JOCTET_PTR;
typedef Byte UINT8;
typedef Word UINT16;
typedef Shortint INT16;
typedef int INT32;
typedef int *INT32PTR;
typedef Cardinal JDIMENSION;
typedef Byte *JSAMPROW;
typedef JSAMPROW *JSAMPARRAY;
typedef JSAMPARRAY *JSAMPIMAGE;
typedef short JBLOCK[64];
typedef JBLOCK *JBLOCKROW;
typedef JBLOCKROW *JBLOCKARRAY;
typedef JBLOCKARRAY *JBLOCKIMAGE;
typedef short *JCOEFPTR;
struct JQUANT_TBL;
typedef JQUANT_TBL *JQUANT_TBL_PTR;
#pragma pack(push, 1)
struct JQUANT_TBL
{
Word quantval[64];
bool sent_table;
} ;
#pragma pack(pop)
struct JHUFF_TBL;
typedef JHUFF_TBL *JHUFF_TBL_PTR;
#pragma pack(push, 1)
struct JHUFF_TBL
{
Byte bits[17];
Byte huffval[256];
bool sent_table;
} ;
#pragma pack(pop)
struct jpeg_component_info;
typedef jpeg_component_info *jpeg_component_info_ptr;
#pragma pack(push, 1)
struct jpeg_component_info
{
int component_id;
int component_index;
int h_samp_factor;
int v_samp_factor;
int quant_tbl_no;
int dc_tbl_no;
int ac_tbl_no;
Cardinal width_in_blocks;
Cardinal height_in_blocks;
int DCT_scaled_size;
Cardinal downsampled_width;
Cardinal downsampled_height;
bool component_needed;
int MCU_width;
int MCU_height;
int MCU_blocks;
int MCU_sample_width;
int last_col_width;
int last_row_height;
JQUANT_TBL *quant_table;
void *dct_table;
} ;
#pragma pack(pop)
struct jpeg_scan_info;
typedef jpeg_scan_info *jpeg_scan_info_ptr;
#pragma pack(push, 1)
struct jpeg_scan_info
{
int comps_in_scan;
int component_index[4];
int Ss;
int Se;
int Ah;
int Al;
} ;
#pragma pack(pop)
enum J_COLOR_SPACE { JCS_UNKNOWN, JCS_GRAYSCALE, JCS_RGB, JCS_YCbCr, JCS_CMYK, JCS_YCCK };
enum J_DCT_METHOD { JDCT_ISLOW, JDCT_IFAST, JDCT_FLOAT };
enum J_DITHER_MODE { JDITHER_NONE, JDITHER_ORDERED, JDITHER_FS };
struct jpeg_error_mgr;
typedef jpeg_error_mgr *jpeg_error_mgr_ptr;
struct jpeg_memory_mgr;
typedef jpeg_memory_mgr *jpeg_memory_mgr_ptr;
struct jpeg_progress_mgr;
typedef jpeg_progress_mgr *jpeg_progress_mgr_ptr;
struct jpeg_destination_mgr;
typedef jpeg_destination_mgr *jpeg_destination_mgr_ptr;
struct jpeg_source_mgr;
typedef jpeg_source_mgr *jpeg_source_mgr_ptr;
struct jpeg_common_struct;
typedef jpeg_common_struct *j_common_ptr;
struct jpeg_compress_struct;
typedef jpeg_compress_struct *j_compress_ptr;
struct jpeg_decompress_struct;
typedef jpeg_decompress_struct *j_decompress_ptr;
#pragma pack(push, 1)
struct jpeg_common_struct
{
System::TObject* UserRef;
jpeg_error_mgr *err;
jpeg_memory_mgr *mem;
jpeg_progress_mgr *progress;
bool is_decompressor;
int global_state;
} ;
#pragma pack(pop)
#pragma pack(push, 1)
struct jpeg_compress_struct
{
jpeg_common_struct common_fields;
jpeg_destination_mgr *dest;
Cardinal image_width;
Cardinal image_height;
int input_components;
J_COLOR_SPACE in_color_space;
double input_gamma;
int data_precision;
int num_components;
J_COLOR_SPACE jpeg_color_space;
jpeg_component_info *comp_info;
JQUANT_TBL *quant_tbl_ptrs[4];
JHUFF_TBL *dc_huff_tbl_ptrs[4];
JHUFF_TBL *ac_huff_tbl_ptrs[4];
Byte arith_dc_L[16];
Byte arith_dc_U[16];
Byte arith_ac_K[16];
int num_scans;
jpeg_scan_info *scan_info;
bool raw_data_in;
bool arith_code;
bool optimize_coding;
bool CCIR601_sampling;
int smoothing_factor;
J_DCT_METHOD dct_method;
Cardinal restart_interval;
int restart_in_rows;
bool write_JFIF_header;
Byte density_unit;
Word X_density;
Word Y_density;
bool write_Adobe_marker;
Cardinal next_scanline;
bool progressive_mode;
int max_h_samp_factor;
int max_v_samp_factor;
Cardinal total_iMCU_rows;
int comps_in_scan;
jpeg_component_info *cur_comp_info[4];
Cardinal MCUs_per_row;
Cardinal MCU_rows_in_scan;
int blocks_in_MCU;
int MCU_membership[10];
int Ss;
int Se;
int Ah;
int Al;
void *master;
void *main;
void *prep;
void *coef;
void *marker;
void *cconvert;
void *downsample;
void *fdct;
void *entropy;
} ;
#pragma pack(pop)
typedef int coef_bits_field[64];
typedef coef_bits_field *coef_bits_ptr;
typedef int coef_bits_ptrfield[4][64];
typedef coef_bits_ptrfield *coef_bits_ptrrow;
typedef Byte range_limit_table[1408];
typedef range_limit_table *range_limit_table_ptr;
#pragma pack(push, 1)
struct jpeg_decompress_struct
{
jpeg_common_struct common_fields;
jpeg_source_mgr *src;
Cardinal image_width;
Cardinal image_height;
int num_components;
J_COLOR_SPACE jpeg_color_space;
J_COLOR_SPACE out_color_space;
Cardinal scale_num;
Cardinal scale_denom;
double output_gamma;
bool buffered_image;
bool raw_data_out;
J_DCT_METHOD dct_method;
bool do_fancy_upsampling;
bool do_block_smoothing;
bool quantize_colors;
J_DITHER_MODE dither_mode;
bool two_pass_quantize;
int desired_number_of_colors;
bool enable_1pass_quant;
bool enable_external_quant;
bool enable_2pass_quant;
Cardinal output_width;
Cardinal output_height;
int out_color_components;
int output_components;
int rec_outbuf_height;
int actual_number_of_colors;
JSAMPROW *colormap;
Cardinal output_scanline;
int input_scan_number;
Cardinal input_iMCU_row;
int output_scan_number;
int output_iMCU_row;
coef_bits_field *coef_bits;
JQUANT_TBL *quant_tbl_ptrs[4];
JHUFF_TBL *dc_huff_tbl_ptrs[4];
JHUFF_TBL *ac_huff_tbl_ptrs[4];
int data_precision;
jpeg_component_info *comp_info;
bool progressive_mode;
bool arith_code;
Byte arith_dc_L[16];
Byte arith_dc_U[16];
Byte arith_ac_K[16];
Cardinal restart_interval;
bool saw_JFIF_marker;
Byte density_unit;
Word X_density;
Word Y_density;
bool saw_Adobe_marker;
Byte Adobe_transform;
bool CCIR601_sampling;
int max_h_samp_factor;
int max_v_samp_factor;
int min_DCT_scaled_size;
Cardinal total_iMCU_rows;
range_limit_table *sample_range_limit;
int comps_in_scan;
jpeg_component_info *cur_comp_info[4];
Cardinal MCUs_per_row;
Cardinal MCU_rows_in_scan;
Cardinal blocks_in_MCU;
int MCU_membership[10];
int Ss;
int Se;
int Ah;
int Al;
int unread_marker;
void *master;
void *main;
void *coef;
void *post;
void *inputctl;
void *marker;
void *entropy;
void *idct;
void *upsample;
void *cconvert;
void *cquantize;
} ;
#pragma pack(pop)
#pragma pack(push, 1)
struct jpeglib__1
{
union
{
char s[80];
int i[8];
};
} ;
#pragma pack(pop)
#pragma pack(push, 1)
struct jpeg_error_mgr
{
void __stdcall (*error_exit)(j_common_ptr cinfo);
void __stdcall (*emit_message)(j_common_ptr cinfo, int msg_level);
void __stdcall (*output_message)(j_common_ptr cinfo);
void __stdcall (*format_message)(j_common_ptr cinfo, char * buffer);
void __stdcall (*reset_error_mgr)(j_common_ptr cinfo);
int msg_code;
jpeglib__1 msg_parm;
int trace_level;
int num_warnings;
void *jpeg_message_table;
int last_jpeg_message;
void *addon_message_table;
int first_addon_message;
int last_addon_message;
} ;
#pragma pack(pop)
#pragma pack(push, 1)
struct jpeg_progress_mgr
{
void __stdcall (*progress_monitor)(j_common_ptr cinfo);
int pass_counter;
int pass_limit;
int completed_passes;
int total_passes;
} ;
#pragma pack(pop)
#pragma pack(push, 1)
struct jpeg_destination_mgr
{
Byte *next_output_byte;
int free_in_buffer;
void __stdcall (*init_destination)(j_compress_ptr cinfo);
bool __stdcall (*empty_output_buffer)(j_compress_ptr cinfo);
void __stdcall (*term_destination)(j_compress_ptr cinfo);
} ;
#pragma pack(pop)
#pragma pack(push, 1)
struct jpeg_source_mgr
{
Byte *next_input_byte;
int bytes_in_buffer;
void __stdcall (*init_source)(j_decompress_ptr cinfo);
bool __stdcall (*fill_input_buffer)(j_decompress_ptr cinfo);
void __stdcall (*skip_input_data)(j_decompress_ptr cinfo, int num_bytes);
bool __stdcall (*resync_to_restart)(j_decompress_ptr cinfo, int desired);
void __stdcall (*term_source)(j_decompress_ptr cinfo);
} ;
#pragma pack(pop)
typedef void *jvirt_sarray_ptr;
typedef void *jvirt_barray_ptr;
#pragma pack(push, 1)
struct jpeg_memory_mgr
{
void * __stdcall (*alloc_small)(j_common_ptr cinfo, int pool_id, int sizeofobject);
void * __stdcall (*alloc_large)(j_common_ptr cinfo, int pool_id, int sizeofobject);
JSAMPARRAY __stdcall (*alloc_sarray)(j_common_ptr cinfo, int pool_id, Cardinal samplesperrow, Cardinal
numrows);
JBLOCKARRAY __stdcall (*alloc_barray)(j_common_ptr cinfo, int pool_id, Cardinal blocksperrow, Cardinal
numrows);
void * __stdcall (*request_virt_sarray)(j_common_ptr cinfo, int pool_id, bool pre_zero, Cardinal samplesperrow
, Cardinal numrows, Cardinal maxaccess);
void * __stdcall (*request_virt_barray)(j_common_ptr cinfo, int pool_id, bool pre_zero, Cardinal blocksperrow
, Cardinal numrows, Cardinal maxaccess);
void __stdcall (*realize_virt_arrays)(j_common_ptr cinfo);
JSAMPARRAY __stdcall (*access_virt_sarray)(j_common_ptr cinfo, void * ptr, Cardinal start_row, Cardinal
num_rows, bool writable);
JBLOCKARRAY __stdcall (*access_virt_barray)(j_common_ptr cinfo, void * ptr, Cardinal start_row, Cardinal
num_rows, bool writable);
void __stdcall (*free_pool)(j_common_ptr cinfo, int pool_id);
void __stdcall (*self_destruct)(j_common_ptr cinfo);
int max_memory_to_use;
} ;
#pragma pack(pop)
typedef bool __stdcall (*jpeg_marker_parser_method)(j_decompress_ptr cinfo);
//-- var, const, procedure ---------------------------------------------------
#define MAX_COMPONENTS (Byte)(10)
#define MAXJSAMPLE (Byte)(255)
#define CENTERJSAMPLE (Byte)(128)
#define JPEG_MAX_DIMENSION (int)(65500)
#define JPEG_LIB_VERSION (Byte)(61)
#define JMSG_STR_PARM_MAX (Byte)(80)
#define JMSG_LENGTH_MAX (Byte)(200)
#define DCTSIZE (Byte)(8)
#define DCTSIZE2 (Byte)(64)
#define NUM_QUANT_TBLS (Byte)(4)
#define NUM_HUFF_TBLS (Byte)(4)
#define NUM_ARITH_TBLS (Byte)(16)
#define MAX_COMPS_IN_SCAN (Byte)(4)
#define MAX_SAMP_FACTOR (Byte)(4)
#define C_MAX_BLOCKS_IN_MCU (Byte)(10)
#define D_MAX_BLOCKS_IN_MCU (Byte)(10)
#define JDCT_DEFAULT (J_DCT_METHOD)(0)
#define JDCT_FASTEST (J_DCT_METHOD)(1)
#define JPOOL_PERMANENT (Byte)(0)
#define JPOOL_IMAGE (Byte)(1)
#define JPOOL_NUMPOOLS (Byte)(2)
#define JPEG_SUSPENDED (Byte)(0)
#define JPEG_HEADER_OK (Byte)(1)
#define JPEG_HEADER_TABLES_ONLY (Byte)(2)
#define JPEG_REACHED_SOS (Byte)(1)
#define JPEG_REACHED_EOI (Byte)(2)
#define JPEG_ROW_COMPLETED (Byte)(3)
#define JPEG_SCAN_COMPLETED (Byte)(4)
#define JPEG_RST0 (Byte)(208)
#define JPEG_EOI (Byte)(217)
#define JPEG_APP0 (Byte)(224)
#define JPEG_COM (Byte)(254)
extern "C" void __stdcall jpeg_destroy_compress(j_compress_ptr cinfo);
extern "C" void __stdcall jpeg_destroy_decompress(j_decompress_ptr cinfo);
extern "C" void __stdcall jpeg_set_defaults(j_compress_ptr cinfo);
extern "C" void __stdcall jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace);
extern "C" void __stdcall jpeg_default_colorspace(j_compress_ptr cinfo);
extern "C" void __stdcall jpeg_set_quality(j_compress_ptr cinfo, int quality, bool force_baseline);
extern "C" void __stdcall jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor, bool force_baseline
);
extern "C" void __stdcall jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl, const uint_ptr basic_table
, int scale_factor, bool force_baseline);
extern "C" int __stdcall jpeg_quality_scaling(int quality);
extern "C" void __stdcall jpeg_simple_progression(j_compress_ptr cinfo);
extern "C" void __stdcall jpeg_suppress_tables(j_compress_ptr cinfo, bool suppress);
extern "C" JQUANT_TBL_PTR __stdcall jpeg_alloc_quant_table(const jpeg_common_struct cinfo);
extern "C" JHUFF_TBL_PTR __stdcall jpeg_alloc_huff_table(const jpeg_common_struct cinfo);
extern "C" void __stdcall jpeg_start_compress(j_compress_ptr cinfo, bool write_all_tables);
extern "C" Cardinal __stdcall jpeg_write_scanlines(j_compress_ptr cinfo, JSAMPARRAY scanlines, Cardinal
num_lines);
extern "C" void __stdcall jpeg_finish_compress(j_compress_ptr cinfo);
extern "C" Cardinal __stdcall jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data, Cardinal num_lines
);
extern "C" void __stdcall jpeg_write_marker(j_compress_ptr cinfo, int marker, const JOCTET_PTR dataptr
, Cardinal datalen);
extern "C" void __stdcall jpeg_write_tables(j_compress_ptr cinfo);
extern "C" int __stdcall jpeg_read_header(j_decompress_ptr cinfo, bool require_image);
extern "C" bool __stdcall jpeg_start_decompress(j_decompress_ptr cinfo);
extern "C" Cardinal __stdcall jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines, Cardinal
max_lines);
extern "C" bool __stdcall jpeg_finish_decompress(j_decompress_ptr cinfo);
extern "C" Cardinal __stdcall jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data, Cardinal max_lines
);
extern "C" bool __stdcall jpeg_has_multiple_scans(j_decompress_ptr cinfo);
extern "C" bool __stdcall jpeg_start_output(j_decompress_ptr cinfo, int scan_number);
extern "C" bool __stdcall jpeg_finish_output(j_decompress_ptr cinfo);
extern "C" bool __stdcall jpeg_input_complete(j_decompress_ptr cinfo);
extern "C" void __stdcall jpeg_new_colormap(j_decompress_ptr cinfo);
extern "C" int __stdcall jpeg_consume_input(j_decompress_ptr cinfo);
extern "C" void __stdcall jpeg_calc_output_dimensions(j_decompress_ptr cinfo);
extern "C" void __stdcall jpeg_set_marker_processor(j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method
routine);
extern "C" void __stdcall jpeg_abort_compress(j_compress_ptr cinfo);
extern "C" void __stdcall jpeg_abort_decompress(j_decompress_ptr cinfo);
extern "C" void __stdcall jpeg_abort(j_common_ptr cinfo);
extern "C" void __stdcall jpeg_destroy(j_common_ptr cinfo);
extern "C" bool __stdcall jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired);
extern "C" jpeg_error_mgr_ptr __stdcall jpeg_std_error(jpeg_error_mgr_ptr err);
extern PACKAGE void __fastcall jpeg_Create_Compress(j_compress_ptr cinfo);
extern PACKAGE void __fastcall jpeg_Create_Decompress(j_decompress_ptr cinfo);
} /* namespace Jpeglib */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Jpeglib;
#endif
//-- end unit ----------------------------------------------------------------
#endif // jpeglib

BIN
CDopping/jpg3s/JPEGLIB.OBJ Normal file
View File

Binary file not shown.

BIN
CDopping/jpg3s/JPEGREG1.DCR Normal file
View File

Binary file not shown.

BIN
CDopping/jpg3s/JPEGREG2.DCR Normal file
View File

Binary file not shown.

BIN
CDopping/jpg3s/JPEG_REG.OBJ Normal file
View File

Binary file not shown.

126
CDopping/jpg3s/LICENCE.TXT Normal file
View File

@ -0,0 +1,126 @@
SHAREWARE LICENCE
LICENCE AGREEMENT
Copyright 1997 McCallum Whyman Associates Limited trading as MWA Software
The copyright in the shareware version of this software ("the
Software") is owned by McCallum Whyman Associates Limited trading
as MWA Software ("the Owner"). You may not load the Software
into any computer or copy it without the licence of the Owner.
The Owner offers you a non-exclusive licence on the terms of this
Agreement.
LICENCE
You are permitted during the Term to:
(1) load the Software and use it only on a single computer (with
a single input terminal) which is under your control;
(2) transfer the Software from one computer to another provided
it is used on only one computer at a time;
(3) make copies of the Software. The copies must reproduce and
include the Owner's copyright notice;
(4) transfer a copy of the Software (complete with all its
associated documentation and this licence) to another person
provided that the Software is not modified in any way and
includes all files as originally supplied and that no charge
is made for the transfer. If any transferee does not accept
such terms then this licence shall automatically terminate.
The transferor does not retain any rights under this
Agreement in respect of the transferred Software or licence.
(5) use the Software as a component of another program provided
that the purpose of using the Software is for evaluation only
and provided that the evaluation is carried out on the same
computer on which the Software is loaded and that such a
program is under no circumstances transferred to another
person.
You are not permitted:
(a) to rent, lease, sub-licence, loan, copy (except as expressly
provided in this Agreement), modify, adapt, merge, translate,
reverse engineer, decompile, disassemble or create derivative
works based on the whole or any part of the Software or its
associated documentation;
(b) except as expressly provided in this Agreement, to use,
reproduce or deal in the Software in any way.
ACCEPTANCE
You shall be deemed to have accepted the terms of this Agreement
by loading the Software into any computer.
TERM
Subject as set out below this licence is effective for a period
of 30 days from the date of first use by you. This Licence will
terminate if you fail to abide by its terms. Upon termination
you agree to destroy all copies of the Software and its
documentation including any Software stored on the hard disk of
any computer under your control.
REGISTRATION
If you wish to licence the Software beyond the period of 30 days
aforesaid then please return the enclosed Licence Registration
Form to the Owner within such period.
OWNERSHIP
The Owner shall at all times retain ownership of the Software as
recorded in the original file set or diskette and all subsequent
copies thereof regardless of form. If the Software was supplied
on diskette, you own only the diskette on which the Software is
recorded. You may retain the diskette on termination provided
the Software has been erased. This Agreement applies to the
grant of the licence only and not to the contract of sale of the
diskette.
WARRANTIES
(1) The express terms of this Agreement are in lieu of all
warranties, conditions, undertakings, terms and obligations
implied by statute, common law, trade usage, course of
dealing or otherwise all of which are hereby excluded to the
fullest extent permitted by law.
(2) The Owner does not warrant that the Software will meet your
requirements or that the operation of the Software will be
uninterrupted or error-free or that defects in the Software
will be corrected. You shall load and use the Software at
your own risk and in no event will the Owner be liable to you
for any loss or damage of any kind (except personal injury or
death resulting from the Owner's negligence) including lost
profits or consequential loss arising from your use of or
inability to use the Software or from errors or deficiencies
in it whether caused by negligence or otherwise.
(3) Any liability of the Owner pursuant to this licence shall be
limited to the purchase price or registration fee paid.
LAW
This Agreement shall be governed by English law.
If you have any questions concerning this Agreement please
write to McCallum Whyman Associates Limited trading as MWA
Software at PO Box 37, Alresford, Hampshire, SO24 9ZF,
England.

87
CDopping/jpg3s/MWADBJPG.HPP Normal file
View File

@ -0,0 +1,87 @@
// Borland C++ Builder
// Copyright (c) 1995, 1998 by Borland International
// All rights reserved
// (DO NOT EDIT: machine generated header) 'mwadbjpg.pas' rev: 3.00
#ifndef mwadbjpgHPP
#define mwadbjpgHPP
#include <Controls.hpp>
#include <mwajpeg.hpp>
#include <Classes.hpp>
#include <ExtCtrls.hpp>
#include <Messages.hpp>
#include <DBTables.hpp>
#include <DBCtrls.hpp>
#include <Db.hpp>
#include <SysInit.hpp>
#include <System.hpp>
//-- user supplied -----------------------------------------------------------
namespace Mwadbjpg
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TDBJPEGImage;
class PASCALIMPLEMENTATION TDBJPEGImage : public Extctrls::TImage
{
typedef Extctrls::TImage inherited;
private:
Dbctrls::TFieldDataLink* FDataLink;
Classes::TNotifyEvent FOldPictureChanged;
bool FAutoDisplay;
bool FLoading;
bool FChanging;
bool FPictureLoaded;
Mwajpeg::TJPEGFileCompressor* FJPEGCompressor;
Mwajpeg::TJPEGFileDecompressor* FJPEGDecompressor;
System::AnsiString __fastcall GetDataField();
Db::TDataSource* __fastcall GetDataSource(void);
Db::TField* __fastcall GetField(void);
bool __fastcall GetReadOnly(void);
Mwajpeg::TJPEGFileDecompressor* __fastcall GetJPEGDecompressor(void);
Mwajpeg::TJPEGFileCompressor* __fastcall GetJPEGCompressor(void);
void __fastcall SetDataField(const System::AnsiString Value);
void __fastcall SetDataSource(Db::TDataSource* Value);
void __fastcall SetReadOnly(bool Value);
void __fastcall ActiveChanged(System::TObject* Sender);
void __fastcall DataChange(System::TObject* Sender);
void __fastcall UpdateData(System::TObject* Sender);
void __fastcall PictureChange(System::TObject* Sender);
MESSAGE void __fastcall WMCut(Messages::TMessage &Message);
MESSAGE void __fastcall WMCopy(Messages::TMessage &Message);
MESSAGE void __fastcall WMPaste(Messages::TMessage &Message);
protected:
virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
);
public:
__fastcall virtual TDBJPEGImage(Classes::TComponent* AOwner);
__fastcall virtual ~TDBJPEGImage(void);
void __fastcall CopyToClipboard(void);
void __fastcall CutToClipboard(void);
void __fastcall PasteFromClipboard(void);
void __fastcall LoadPicture(void);
__property Db::TField* Field = {read=GetField};
__published:
__property bool AutoDisplay = {read=FAutoDisplay, write=FAutoDisplay, default=1};
__property System::AnsiString DataField = {read=GetDataField, write=SetDataField};
__property Db::TDataSource* DataSource = {read=GetDataSource, write=SetDataSource};
__property bool ReadOnly = {read=GetReadOnly, write=SetReadOnly, nodefault};
__property Mwajpeg::TJPEGFileCompressor* JPEGCompressor = {read=FJPEGCompressor, write=FJPEGCompressor
};
__property Mwajpeg::TJPEGFileDecompressor* JPEGDecompressor = {read=FJPEGDecompressor, write=FJPEGDecompressor
};
};
//-- var, const, procedure ---------------------------------------------------
} /* namespace Mwadbjpg */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Mwadbjpg;
#endif
//-- end unit ----------------------------------------------------------------
#endif // mwadbjpg

BIN
CDopping/jpg3s/MWADBJPG.OBJ Normal file
View File

Binary file not shown.

498
CDopping/jpg3s/MWAJPEG.HPP Normal file
View File

@ -0,0 +1,498 @@
// Borland C++ Builder
// Copyright (c) 1995, 1998 by Borland International
// All rights reserved
// (DO NOT EDIT: machine generated header) 'mwajpeg.pas' rev: 3.00
#ifndef mwajpegHPP
#define mwajpegHPP
#include <ExtCtrls.hpp>
#include <Graphics.hpp>
#include <Windows.hpp>
#include <Classes.hpp>
#include <jpeglib.hpp>
#include <SysInit.hpp>
#include <System.hpp>
//-- user supplied -----------------------------------------------------------
namespace Mwajpeg
{
//-- type declarations -------------------------------------------------------
typedef void __fastcall (__closure *TWarningEvent)(const System::AnsiString warning_message);
class DELPHICLASS TJPEGBase;
class PASCALIMPLEMENTATION TJPEGBase : public Classes::TComponent
{
typedef Classes::TComponent inherited;
private:
Jpeglib::jpeg_common_struct *JPEGObject;
bool FInAbort;
bool FInProgress;
bool FAbortRequested;
Classes::TNotifyEvent FOnProgressReport;
TWarningEvent FOnWarning;
int __fastcall GetWarnings(void);
int __fastcall GetTraceLevel(void);
int __fastcall GetPercentDone(void);
void __fastcall SetTraceLevel(int value);
virtual void __fastcall CreateJPEGObject(Jpeglib::jpeg_error_mgr_ptr err) = 0;
protected:
virtual void __fastcall Error(void);
virtual void __fastcall Warning(int msg_level);
virtual void __fastcall DoProgress(void);
int __fastcall Round4(int i);
public:
__fastcall virtual TJPEGBase(Classes::TComponent* AOwner);
__fastcall virtual ~TJPEGBase(void);
virtual void __fastcall Abort(void);
__property int Warnings = {read=GetWarnings, nodefault};
__property int Trace_Level = {read=GetTraceLevel, write=SetTraceLevel, nodefault};
__property int PercentDone = {read=GetPercentDone, nodefault};
__property Classes::TNotifyEvent OnProgressReport = {read=FOnProgressReport, write=FOnProgressReport
};
__property TWarningEvent OnWarning = {read=FOnWarning, write=FOnWarning};
};
enum TBitmapResolution { bmDefault, bm16Colour, bm256Colour, bm24bit };
typedef int TImageSize;
class DELPHICLASS TJPEGCompressor;
class PASCALIMPLEMENTATION TJPEGCompressor : public Mwajpeg::TJPEGBase
{
typedef Mwajpeg::TJPEGBase inherited;
private:
System::AnsiString FComment;
bool FProgressiveJPEG;
bool FWriteAllTables;
int FQuality;
bool FGrayscaleOutput;
Classes::TNotifyEvent FOnWriteMarkers;
Jpeglib::JOCTET_PTR __fastcall GetNextOut(void);
int __fastcall GetFreeIn(void);
void __fastcall SetNextOut(Jpeglib::JOCTET_PTR value);
void __fastcall SetFreeIn(int value);
void __fastcall SetQuality(int Value);
virtual void __fastcall CreateJPEGObject(Jpeglib::jpeg_error_mgr_ptr err);
int __fastcall Getcinfoinput_components(void);
Cardinal __fastcall Getcinfoimage_width(void);
double __fastcall Getcinfoinput_gamma(void);
int __fastcall Getcinfodata_precision(void);
Jpeglib::J_COLOR_SPACE __fastcall Getcinfojpeg_color_space(void);
Jpeglib::J_DCT_METHOD __fastcall Getcinfodct_method(void);
bool __fastcall Getcinfooptimize_coding(void);
Cardinal __fastcall Getcinforestart_interval(void);
int __fastcall Getcinforestart_in_rows(void);
int __fastcall Getcinfosmoothing_factor(void);
bool __fastcall Getcinfowrite_JFIF_header(void);
Byte __fastcall Getcinfodensity_unit(void);
Word __fastcall GetcinfoX_density(void);
Word __fastcall GetcinfoY_Density(void);
bool __fastcall Getcinfowrite_Adobe_marker(void);
Cardinal __fastcall Getcinfoimage_height(void);
void __fastcall Setcinfoinput_components(int Value);
void __fastcall Setcinfoimage_width(Cardinal Value);
void __fastcall Setcinfoinput_gamma(double Value);
void __fastcall Setcinfodata_precision(int Value);
void __fastcall Setcinfojpeg_color_space(Jpeglib::J_COLOR_SPACE Value);
void __fastcall Setcinfodct_method(Jpeglib::J_DCT_METHOD Value);
void __fastcall Setcinfooptimize_coding(bool Value);
void __fastcall Setcinforestart_interval(Cardinal Value);
void __fastcall Setcinforestart_in_rows(int Value);
void __fastcall Setcinfosmoothing_factor(int Value);
void __fastcall Setcinfowrite_JFIF_header(bool Value);
void __fastcall Setcinfodensity_unit(Byte Value);
void __fastcall SetcinfoX_density(Word Value);
void __fastcall SetcinfoY_Density(Word Value);
void __fastcall Setcinfowrite_Adobe_marker(bool Value);
void __fastcall Setcinfoimage_height(Cardinal Value);
protected:
Jpeglib::jpeg_compress_struct cinfo;
virtual void __fastcall InitDestination(void) = 0;
virtual bool __fastcall EmptyOutputBuffer(void) = 0;
virtual void __fastcall TermDestination(void) = 0;
void __fastcall SetColorSpace(Jpeglib::J_COLOR_SPACE value);
void __fastcall Bitmap2DIB(Graphics::TBitmap* Bitmap, TBitmapResolution Resolution, void *BitMapInfo
, void *bits);
void __fastcall GetBitmapInfoHeader(HBITMAP Bitmap, TBitmapResolution Resolution, tagBITMAPINFOHEADER
&BitmapInfoHeader);
void __fastcall GetDIBSizes(HBITMAP Bitmap, TBitmapResolution Resolution, int &InfoHeaderSize, int
&ImageSize);
void __fastcall WriteDIBitmap(const tagBITMAPINFO &BitmapInfo, char * bits);
void __fastcall WriteBitmap(Graphics::TBitmap* bitmap);
void __fastcall WriteStretchedBitmap(Graphics::TBitmap* bitmap, int width, int height);
void __fastcall WriteMetaFile(Graphics::TMetafile* metafile, int width, int height);
__property Jpeglib::JOCTET_PTR next_out = {read=GetNextOut, write=SetNextOut};
__property int free_in = {read=GetFreeIn, write=SetFreeIn, nodefault};
__property int InputComponents = {read=Getcinfoinput_components, write=Setcinfoinput_components, nodefault
};
__property Cardinal ImageWidth = {read=Getcinfoimage_width, write=Setcinfoimage_width, nodefault};
__property Cardinal ImageHeight = {read=Getcinfoimage_height, write=Setcinfoimage_height, nodefault
};
public:
__fastcall virtual TJPEGCompressor(Classes::TComponent* AOwner);
__fastcall virtual ~TJPEGCompressor(void);
void __fastcall AddQuantTable(int which_tbl, const Jpeglib::uint_ptr basic_table, int scale_factor,
bool force_baseline);
void __fastcall WriteMarker(int Marker, const void *buf, int Count);
__property bool GrayscaleOutput = {read=FGrayscaleOutput, write=FGrayscaleOutput, nodefault};
__property System::AnsiString Comment = {read=FComment, write=FComment};
__property int Quality = {read=FQuality, write=SetQuality, default=75};
__property bool ProgressiveJPEG = {read=FProgressiveJPEG, write=FProgressiveJPEG, nodefault};
__property double InputGamma = {read=Getcinfoinput_gamma, write=Setcinfoinput_gamma};
__property int DataPrecision = {read=Getcinfodata_precision, write=Setcinfodata_precision, nodefault
};
__property Jpeglib::J_COLOR_SPACE OutputColorSpace = {read=Getcinfojpeg_color_space, write=Setcinfojpeg_color_space
, nodefault};
__property Jpeglib::J_DCT_METHOD DCTMethod = {read=Getcinfodct_method, write=Setcinfodct_method, nodefault
};
__property bool OptimizeCoding = {read=Getcinfooptimize_coding, write=Setcinfooptimize_coding, nodefault
};
__property Cardinal RestartInterval = {read=Getcinforestart_interval, write=Setcinforestart_interval
, nodefault};
__property int RestartInRows = {read=Getcinforestart_in_rows, write=Setcinforestart_in_rows, nodefault
};
__property int SmoothingFactor = {read=Getcinfosmoothing_factor, write=Setcinfosmoothing_factor, nodefault
};
__property bool WriteJFIFHeader = {read=Getcinfowrite_JFIF_header, write=Setcinfowrite_JFIF_header,
nodefault};
__property Byte DensityUnit = {read=Getcinfodensity_unit, write=Setcinfodensity_unit, nodefault};
__property Word X_Density = {read=GetcinfoX_density, write=SetcinfoX_density, nodefault};
__property Word Y_Density = {read=GetcinfoY_Density, write=SetcinfoY_Density, nodefault};
__property bool WriteAdobeMarker = {read=Getcinfowrite_Adobe_marker, write=Setcinfowrite_Adobe_marker
, nodefault};
__property bool WriteAllTables = {read=FWriteAllTables, write=FWriteAllTables, default=1};
__property Classes::TNotifyEvent OnWriteMarkers = {read=FOnWriteMarkers, write=FOnWriteMarkers};
};
typedef void __fastcall (__closure *TJPEGCommentEvent)(TJPEGBase* sender, char * comment);
typedef void __fastcall (__closure *TJPEGMarkerEvent)(TJPEGBase* sender, int Marker, bool &done);
enum TJPEGOutputType { jp24bit, jp8bit, jp4bit, jpGrayscale };
class DELPHICLASS TJPEGDecompressor;
class PASCALIMPLEMENTATION TJPEGDecompressor : public Mwajpeg::TJPEGBase
{
typedef Mwajpeg::TJPEGBase inherited;
private:
TJPEGCommentEvent FOnJPEGComment;
J_DCT_METHOD FDCT_METHOD;
bool FDoFancyUpSampling;
bool FDoBlockSmoothing;
bool FGrayScaleOutput;
bool FTwoPassQuantize;
J_DITHER_MODE FDitherMode;
int FColoursIn8bitMode;
TJPEGMarkerEvent FOnJPEGMarker;
virtual void __fastcall CreateJPEGObject(Jpeglib::jpeg_error_mgr_ptr err);
Jpeglib::JOCTET_PTR __fastcall GetNextInputByte(void);
int __fastcall GetBytesInBuffer(void);
void __fastcall SetNextInputByte(Jpeglib::JOCTET_PTR value);
void __fastcall SetBytesInBuffer(int value);
bool __fastcall HandleJPEGComment(void);
bool __fastcall HandleAPPMarker(void);
Jpeglib::J_COLOR_SPACE __fastcall Getcinfoout_color_space(void);
Cardinal __fastcall Getcinfoscale_num(void);
Cardinal __fastcall Getcinfoscale_denom(void);
double __fastcall Getcinfooutput_gamma(void);
bool __fastcall Getcinfoquantize_colors(void);
int __fastcall Getcinfodesired_number_of_colors(void);
Jpeglib::JSAMPARRAY __fastcall Getcinfocolormap(void);
int __fastcall Getcinfoactual_number_of_colors(void);
Cardinal __fastcall Getcinfoimage_width(void);
Cardinal __fastcall Getcinfoimage_height(void);
Jpeglib::J_COLOR_SPACE __fastcall Getcinfojpeg_color_space(void);
bool __fastcall Getcinfosaw_JFIF_marker(void);
Byte __fastcall Getcinfodensity_unit(void);
Word __fastcall GetcinfoX_density(void);
Word __fastcall GetcinfoY_density(void);
Byte __fastcall GetcinfoAdobe_transform(void);
bool __fastcall Getcinfoenable_1pass_quant(void);
bool __fastcall Getcinfoenable_external_quant(void);
bool __fastcall Getcinfoenable_2pass_quant(void);
Cardinal __fastcall Getcinfooutput_height(void);
Cardinal __fastcall Getcinfooutput_width(void);
void __fastcall Setcinfoout_color_space(Jpeglib::J_COLOR_SPACE Value);
void __fastcall Setcinfoscale_num(Cardinal Value);
void __fastcall Setcinfoscale_denom(Cardinal Value);
void __fastcall Setcinfooutput_gamma(double Value);
void __fastcall Setcinfoquantize_colors(bool Value);
void __fastcall Setcinfodesired_number_of_colors(int Value);
void __fastcall Setcinfocolormap(Jpeglib::JSAMPARRAY Value);
void __fastcall Setcinfoactual_number_of_colors(int Value);
void __fastcall Setcinfoimage_width(Cardinal Value);
void __fastcall Setcinfoimage_height(Cardinal Value);
void __fastcall Setcinfojpeg_color_space(Jpeglib::J_COLOR_SPACE Value);
void __fastcall Setcinfosaw_JFIF_marker(bool Value);
void __fastcall Setcinfodensity_unit(Byte Value);
void __fastcall SetcinfoX_density(Word Value);
void __fastcall SetcinfoY_density(Word Value);
void __fastcall SetcinfoAdobe_transform(Byte Value);
void __fastcall Setcinfoenable_1pass_quant(bool Value);
void __fastcall Setcinfoenable_external_quant(bool Value);
void __fastcall Setcinfoenable_2pass_quant(bool Value);
void __fastcall Setcinfooutput_height(Cardinal Value);
void __fastcall Setcinfooutput_width(Cardinal Value);
protected:
Jpeglib::jpeg_decompress_struct cinfo;
virtual void __fastcall InitSource(void) = 0;
virtual bool __fastcall FillInputBuffer(void) = 0;
virtual void __fastcall SkipInputBytes(int num_bytes) = 0;
virtual bool __fastcall ResyncToRestart(int desired) = 0;
virtual void __fastcall TermSource(void) = 0;
virtual bool __fastcall DoJPEGComment(char * comment);
void __fastcall ReadDIBitmap(tagBITMAPINFO &BitMapInfo, TJPEGOutputType OutputType, void * bits);
Graphics::TBitmap* __fastcall ReadBitmap(void);
void __fastcall ReadWinBitmap(HBITMAP &Bitmap, HPALETTE &Palette);
virtual void __fastcall ReadHeader(void);
__property Jpeglib::JOCTET_PTR NextInputByte = {read=GetNextInputByte, write=SetNextInputByte};
__property int BytesInBuffer = {read=GetBytesInBuffer, write=SetBytesInBuffer, nodefault};
__property Jpeglib::J_COLOR_SPACE OutputColorSpace = {read=Getcinfoout_color_space, write=Setcinfoout_color_space
, nodefault};
__property Cardinal ScaleNum = {read=Getcinfoscale_num, write=Setcinfoscale_num, nodefault};
__property Cardinal ScaleDenom = {read=Getcinfoscale_denom, write=Setcinfoscale_denom, nodefault};
__property double OutputGamma = {read=Getcinfooutput_gamma, write=Setcinfooutput_gamma};
__property bool QuantizeColors = {read=Getcinfoquantize_colors, write=Setcinfoquantize_colors, nodefault
};
__property int NumColorsDesired = {read=Getcinfodesired_number_of_colors, write=Setcinfodesired_number_of_colors
, nodefault};
__property Jpeglib::JSAMPARRAY ColorMap = {read=Getcinfocolormap, write=Setcinfocolormap};
__property int ActualColorsInMap = {read=Getcinfoactual_number_of_colors, write=Setcinfoactual_number_of_colors
, nodefault};
public:
__fastcall virtual TJPEGDecompressor(Classes::TComponent* AOwner);
__fastcall virtual ~TJPEGDecompressor(void);
int __fastcall GetBitmapInfoSize(TJPEGOutputType OutputType);
int __fastcall GetDIBitsSize(TJPEGOutputType OutputType);
Byte __fastcall GetByte(void);
__property TJPEGCommentEvent OnJPEGComment = {read=FOnJPEGComment, write=FOnJPEGComment};
__property TJPEGMarkerEvent OnJPEGMarker = {read=FOnJPEGMarker, write=FOnJPEGMarker};
__property bool GrayScaleOutput = {read=FGrayScaleOutput, write=FGrayScaleOutput, nodefault};
__property Cardinal Width = {read=Getcinfoimage_width, write=Setcinfoimage_width, nodefault};
__property Cardinal Height = {read=Getcinfoimage_height, write=Setcinfoimage_height, nodefault};
__property Jpeglib::J_COLOR_SPACE ColorSpace = {read=Getcinfojpeg_color_space, write=Setcinfojpeg_color_space
, nodefault};
__property bool JFIFMarkerPresent = {read=Getcinfosaw_JFIF_marker, write=Setcinfosaw_JFIF_marker, nodefault
};
__property Byte DensityUnit = {read=Getcinfodensity_unit, write=Setcinfodensity_unit, nodefault};
__property Word X_Density = {read=GetcinfoX_density, write=SetcinfoX_density, nodefault};
__property Word Y_Density = {read=GetcinfoY_density, write=SetcinfoY_density, nodefault};
__property Byte AdobeTransform = {read=GetcinfoAdobe_transform, write=SetcinfoAdobe_transform, nodefault
};
__property bool TwoPassQuantize = {read=FTwoPassQuantize, write=FTwoPassQuantize, default=1};
__property int ColoursIn8bitMode = {read=FColoursIn8bitMode, write=FColoursIn8bitMode, default=64};
__property Jpeglib::J_DITHER_MODE DitherMode = {read=FDitherMode, write=FDitherMode, default=2};
__property Jpeglib::J_DCT_METHOD DCTMethod = {read=FDCT_METHOD, write=FDCT_METHOD, default=0};
__property bool DoFancyUpSampling = {read=FDoFancyUpSampling, write=FDoFancyUpSampling, default=1};
__property bool DoBlockSmoothing = {read=FDoBlockSmoothing, write=FDoBlockSmoothing, default=1};
__property bool Enable1PassQuant = {read=Getcinfoenable_1pass_quant, write=Setcinfoenable_1pass_quant
, nodefault};
__property bool EnableExternalQuant = {read=Getcinfoenable_external_quant, write=Setcinfoenable_external_quant
, nodefault};
__property bool Enable2PassQuant = {read=Getcinfoenable_2pass_quant, write=Setcinfoenable_2pass_quant
, nodefault};
__property Cardinal OutputHeight = {read=Getcinfooutput_height, write=Setcinfooutput_height, nodefault
};
__property Cardinal OutputWidth = {read=Getcinfooutput_width, write=Setcinfooutput_width, nodefault
};
};
class DELPHICLASS TJPEGStreamCompressor;
class PASCALIMPLEMENTATION TJPEGStreamCompressor : public Mwajpeg::TJPEGCompressor
{
typedef Mwajpeg::TJPEGCompressor inherited;
private:
Classes::TStream* FStream;
void *FBuffer;
int FBufSize;
void __fastcall SetBufSize(int Value);
protected:
virtual void __fastcall InitDestination(void);
virtual bool __fastcall EmptyOutputBuffer(void);
virtual void __fastcall TermDestination(void);
void __fastcall OpenStream(Classes::TStream* Stream);
void __fastcall CloseStream(void);
public:
__fastcall virtual TJPEGStreamCompressor(Classes::TComponent* AOwner);
__fastcall virtual ~TJPEGStreamCompressor(void);
void __fastcall SavePictureToStream(Graphics::TPicture* Picture, Classes::TStream* Stream);
void __fastcall SaveStretchedPictureToStream(Graphics::TPicture* Picture, int width, int height, Classes::TStream*
Stream);
void __fastcall SaveBitMapToStream(Graphics::TBitmap* bitmap, Classes::TStream* Stream);
void __fastcall SaveStretchedBitMapToStream(Graphics::TBitmap* bitmap, int width, int height, Classes::TStream*
Stream);
void __fastcall SaveDIBitmapToStream(Classes::TStream* Stream, const tagBITMAPINFO &BitmapInfo, char *
bits);
void __fastcall SaveMetaFileToStream(Graphics::TMetafile* metafile, Classes::TStream* Stream, int width
, int height);
__property int BufSize = {read=FBufSize, write=SetBufSize, default=4096};
};
class DELPHICLASS TJPEGStreamDecompressor;
class PASCALIMPLEMENTATION TJPEGStreamDecompressor : public Mwajpeg::TJPEGDecompressor
{
typedef Mwajpeg::TJPEGDecompressor inherited;
private:
Classes::TStream* FStream;
char *FBuffer;
int FBufSize;
protected:
virtual void __fastcall InitSource(void);
virtual bool __fastcall FillInputBuffer(void);
virtual void __fastcall SkipInputBytes(int num_bytes);
virtual bool __fastcall ResyncToRestart(int desired);
void __fastcall SetBufSize(int Value);
virtual void __fastcall TermSource(void);
public:
void __fastcall OpenStream(Classes::TStream* Stream);
void __fastcall CloseStream(void);
__fastcall virtual TJPEGStreamDecompressor(Classes::TComponent* AOwner);
__fastcall virtual ~TJPEGStreamDecompressor(void);
void __fastcall ConvertToDIB(Classes::TStream* Source, Classes::TStream* Destination, TJPEGOutputType
OutputType);
void __fastcall LoadPictureFromStream(Graphics::TPicture* Picture, Classes::TStream* Stream);
void __fastcall LoadPictureFromResource(Graphics::TPicture* Picture, int Instance, const System::AnsiString
ResName);
void __fastcall LoadPictureFromResID(Graphics::TPicture* Picture, int Instance, int ResID);
Graphics::TBitmap* __fastcall ReadBitMapFromStream(Classes::TStream* Stream);
void __fastcall ReadDIBitmapFromStream(Classes::TStream* Stream, tagBITMAPINFO &BitMapInfo, TJPEGOutputType
OutputType, int &bits);
__property int BufSize = {read=FBufSize, write=SetBufSize, default=4096};
};
class DELPHICLASS TJPEGFileDecompressor;
class PASCALIMPLEMENTATION TJPEGFileDecompressor : public Mwajpeg::TJPEGStreamDecompressor
{
typedef Mwajpeg::TJPEGStreamDecompressor inherited;
public:
void __fastcall LoadPictureFromFile(Graphics::TPicture* Picture, const System::AnsiString FileName)
;
__published:
__property Warnings ;
__property Trace_Level ;
__property PercentDone ;
__property ColoursIn8bitMode ;
__property GrayScaleOutput ;
__property OnJPEGComment ;
__property OnJPEGMarker ;
__property TwoPassQuantize ;
__property DitherMode ;
__property DCTMethod ;
__property DoFancyUpSampling ;
__property DoBlockSmoothing ;
__property OnProgressReport ;
__property OnWarning ;
public:
/* TJPEGStreamDecompressor.create */ __fastcall virtual TJPEGFileDecompressor(Classes::TComponent*
AOwner) : Mwajpeg::TJPEGStreamDecompressor(AOwner) { }
/* TJPEGStreamDecompressor.Destroy */ __fastcall virtual ~TJPEGFileDecompressor(void) { }
};
class DELPHICLASS TJPEGFileCompressor;
class PASCALIMPLEMENTATION TJPEGFileCompressor : public Mwajpeg::TJPEGStreamCompressor
{
typedef Mwajpeg::TJPEGStreamCompressor inherited;
public:
void __fastcall SavePictureToFile(Graphics::TPicture* Picture, const System::AnsiString FileName);
void __fastcall SaveStretchedPictureToFile(Graphics::TPicture* Picture, int width, int height, const
System::AnsiString FileName);
void __fastcall SaveBitmapToFile(Graphics::TBitmap* bitmap, const System::AnsiString FileName);
void __fastcall SaveStretchedBitmapToFile(Graphics::TBitmap* bitmap, int width, int height, const System::AnsiString
FileName);
void __fastcall SaveMetafileToFile(Graphics::TMetafile* metafile, int width, int height, const System::AnsiString
FileName);
__published:
__property Warnings ;
__property Trace_Level ;
__property PercentDone ;
__property GrayscaleOutput ;
__property Comment ;
__property Quality ;
__property InputGamma ;
__property ProgressiveJPEG ;
__property DCTMethod ;
__property OptimizeCoding ;
__property RestartInterval ;
__property RestartInRows ;
__property SmoothingFactor ;
__property WriteJFIFHeader ;
__property DensityUnit ;
__property X_Density ;
__property Y_Density ;
__property WriteAllTables ;
__property OnProgressReport ;
__property OnWriteMarkers ;
__property OnWarning ;
public:
/* TJPEGStreamCompressor.create */ __fastcall virtual TJPEGFileCompressor(Classes::TComponent* AOwner
) : Mwajpeg::TJPEGStreamCompressor(AOwner) { }
/* TJPEGStreamCompressor.Destroy */ __fastcall virtual ~TJPEGFileCompressor(void) { }
};
class DELPHICLASS TJPEGBitmap;
class PASCALIMPLEMENTATION TJPEGBitmap : public Graphics::TBitmap
{
typedef Graphics::TBitmap inherited;
private:
bool FSaveAsBitmap;
TJPEGStreamDecompressor* FDecompressor;
TJPEGStreamCompressor* FCompressor;
Classes::TNotifyEvent FProgressEvent;
void __fastcall HandleDecompressOnProgress(System::TObject* Sender);
void __fastcall HandleCompressOnProgress(System::TObject* Sender);
public:
virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
virtual void __fastcall SaveToStream(Classes::TStream* Stream);
virtual void __fastcall SaveToFile(const System::AnsiString FileName);
public:
/* TBitmap.Create */ __fastcall virtual TJPEGBitmap(void) : Graphics::TBitmap() { }
/* TBitmap.Destroy */ __fastcall virtual ~TJPEGBitmap(void) { }
};
//-- var, const, procedure ---------------------------------------------------
#define DefaultBufSize (Word)(4096)
#define DefaultQuality (Byte)(75)
#define sJPEGResourceType "JPEG"
#define DefaultColoursIn8bitMode (Byte)(64)
extern PACKAGE bool UseIsIllegal;
extern PACKAGE Graphics::TBitmap* __fastcall ReSizeBitmap(Graphics::TBitmap* bitmap, int width, int
height);
extern PACKAGE Graphics::TBitmap* __fastcall CropBitmap(Graphics::TBitmap* bitmap, int width, int height
, const Windows::TRect &Clip);
extern PACKAGE Graphics::TBitmap* __fastcall MetaToBitmap(Graphics::TMetafile* metafile, int Width,
int Height);
} /* namespace Mwajpeg */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Mwajpeg;
#endif
//-- end unit ----------------------------------------------------------------
#endif // mwajpeg

BIN
CDopping/jpg3s/MWAJPEG.OBJ Normal file
View File

Binary file not shown.

BIN
CDopping/jpg3s/MWAJPGC3.BPL Normal file
View File

Binary file not shown.

16
CDopping/jpg3s/MWAKEY.ASC Normal file
View File

@ -0,0 +1,16 @@
Type Bits/KeyID Date User ID
pub 1024/1028B231 1997/02/17 MWA Software <sales@mwassocs.demon.co.uk>
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: 2.6.3i
mQCNAzMIL8cAAAEEAPStAr1wfLNg9gb/U0siXl9vUDl/CQvPHyNBmNa+D+DCl4W5
QFgxGwVBwXrUMbHY/iwDat1QRgt1KFk4iGpwLXK9IltWhzqk+jHJHEEdS401c1cF
eCcsS2+DZHKbQ/Gk9VsuqZjpH2k4B86S0EPXMXtJDD2oyWl1ieDA0S0QKLIxAAUR
tClNV0EgU29mdHdhcmUgPHNhbGVzQG13YXNzb2NzLmRlbW9uLmNvLnVrPokAlQMF
EDMIL8fgwNEtECiyMQEBcHUEAL/B+MJ6ECnTOSbI5Ui5svpJwWV0PFvxUpS8nHCz
VOA4lk7PasRGljJJrop7W25KG+kkrv/uaUo1X/gsiAczszOxN56cloaWK9lAs7lX
Nvu9uapZDLSHyNlcxFnERRZAgeD0GBTDiMKgM1ZZm9pP3u/naKLf8OYNtOErr82N
Gn/z
=lusp
-----END PGP PUBLIC KEY BLOCK-----

45
CDopping/jpg3s/MWAQRJPG.H Normal file
View File

@ -0,0 +1,45 @@
//---------------------------------------------------------------------------
#ifndef mwaQRjpgH
#define mwaQRjpgH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Controls.hpp>
#include <Classes.hpp>
#include <Forms.hpp>
#include <Qrctrls.hpp>
#include <quickrpt.hpp>
#include <db.hpp>
#include <dbctrls.hpp>
#include "mwajpeg.hpp"
#if __TCPLUSPLUS__ == 0x0520
#define PACKAGE
#pragma link "mwajpeg.obj"
#pragma link "jpeglib.obj"
#endif
//---------------------------------------------------------------------------
class PACKAGE TQRDBJPEGImage : public TQRImage
{
private:
bool FAutoStretch;
Mwajpeg::TJPEGFileDecompressor *FJPEGDecompressor;
System::AnsiString FDataField;
Db::TDataSet *FDataSet;
Mwajpeg::TJPEGFileDecompressor* __fastcall GetJPEGDecompressor(void);
void __fastcall SetDataSet(TDataSet* Value);
protected:
virtual void __fastcall Print(int OfsX, int OfsY);
public:
__fastcall TQRDBJPEGImage(TComponent* Owner);
void __fastcall LoadPicture(void);
virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
__published:
__property Db::TDataSet* DataSet = {read=FDataSet, write=SetDataSet};
__property System::AnsiString DataField = {read=FDataField, write=FDataField};
__property bool AutoStretch = {read=FAutoStretch, write=FAutoStretch, nodefault};
__property Mwajpeg::TJPEGFileDecompressor* JPEGDecompressor = {read=FJPEGDecompressor, write=FJPEGDecompressor};
};
//---------------------------------------------------------------------------
#endif

BIN
CDopping/jpg3s/MWAQRJPG.OBJ Normal file
View File

Binary file not shown.

21
CDopping/jpg3s/MWJPEG.CNT Normal file
View File

@ -0,0 +1,21 @@
:Base mwjpeg.hlp
:Title MWA JPEG Component Library (C++Builder V3.0)
1 Contents
2 About the Component Library=Topic_ABOUTTHECOMPONENTLIBRARY
2 Installation Instructions=Topic_INSTALLATIONINSTRUCTIONS
2 Example Applications=Topic_USINGTHEJPEGDEMOAPPLICATION
2 Classes
3 TJPEGFileCompressor=Topic_TJPEGFileCompressor
3 TJPEGFileDecompressor=Topic_TJPEGFileDecompressor
3 TDBJPEGImage=Topic_TDBJPEGImage
3 TQRDBJPEGImage=Topic_TQRDBJPEGImage
1 Units=Topic_Units
2 Utility Functions
3 ReSizeBitmap=Topic_ResizeBitmap
3 CropBitmap=Topic_CropBitmap
3 MetaToBitmap=Topic_MetaToBitmap
2 Registration
3 Pricing Information=Topic_PRICINGINFORMATION
3 How to Register=Topic_HOWTOREGISTER
3 Secure Registration=Topic_SECUREREGISTRATION
3 Shareware Licence=JPEGLicence

BIN
CDopping/jpg3s/MWJPEG.HLP Normal file
View File

Binary file not shown.

304
CDopping/jpg3s/README.TXT Normal file
View File

@ -0,0 +1,304 @@
Readme file for the JPEG Component Library version 1.5
=======================================================
This file contains documentation for the JPEG Component Library by MWA Software.
This version is for Borland C++Builder 3.0. Versions for Delphi 1.0, 2.0, 3.0 and
4.0, and C++Builder 1 are also available. For further information please contact
MWA Software -
mailto:sales@mwassocs.demon.co.uk.
http://www.demon.co.uk/mwa-soft
ONLINE HELP IS ALSO AVAILABLE IN THE FILE mwjpeg.hlp.
This file contains the following information:
1. ABOUT THE COMPONENT LIBRARY
2. INSTALLATION INSTRUCTIONS
3. USING THE JPEG DEMO APPLICATION
4. PRELIMINARY SOFTWARE DOCUMENTATION
5. PRICING INFORMATION
6. HOW TO REGISTRATION
7. SECURE REGISTRATION
1. ABOUT THE COMPONENT LIBRARY
==============================
The JPEG Component Library provides two additional non-visual components for use
under either Delphi 1.0, 2.0, 3.0 and C++Builder 1 and 3. It also provides a Data
Aware JPEG Image component which may be used to save and access JPEG encoded
images in a database blob field. A corresponding printable component is also
provided so that you may print images from a database using Quick Reports.
This file contains the C++Builder 3 version. Please access
http://www.demon.co.uk/mwa-soft for the remaining versions.
The two non-visual components are TJPEGFileCompressor and TJPEGFileDecompressor.
These support compression of images to JPEG Format and decompression respectively.
The data aware component is TDBJPEGImage, and the printable component is
TQRDBJPEGImage.
Simply installing these components JPEG enables the Delphi IDE. The components
register themselves as supporting .jpg files and the JPEG compression format and,
when you come to load an image into a TImage Picture, the JPEG format will be
found amongst the list of supported file formats. An image loaded from a JPEG
source can also be saved back to JPEG. These components support the JPEG File
Interchange Format (JFIF).
These two components also support TImage at run-time too. As at design time, if
TJPEGFileDecompressor is included in your project, then calling
TImage.Picture.LoadFromFile when the file extension is .jpg will automatically
invoke the JPEG decompressor. You can also explicitly call TJPEGFileDecompressor
to load a JPEG image from any file.
TJPEGFileCompressor can be used to save a TImage.Picture in JPEG format, and can
handle pictures that are either bitmaps or metafiles. It can also compress a
device independent bitmap, and change the size of bitmaps before compression.
TDBJPEGImage is linked to a database blob field and also uses
TJPEGFileDecompressor and TJPEGFileCompressor to save and load JPEG encoded images
from the Blob Field. Use of the JPEG compressor and decompressor components can be
implicit if the default parameter settings are sufficient. On the other hand, the
reference may be explicit to copies of these components with non-default parameter
settings. TQRDBJPEGImage can be used to print a JPEG Image using Quick Reports 2.
This software uses original software for JPEG developed by the Independent JPEG
Group (see ftp://ftp.uu.net/graphics/jpeg). The IDG have made available a library
of generic 'C' code supporting JPEG compression and decompression and have
permitted its free use provided the source is acknowledged. The IDG code has been
modified for use with Delphi and MS Windows and is provided as compiled object
files. Optionally, they may be separately compiled into a dll.
An interface to this software is provided by the unit jpeglib.pas. This is
encapsulated as a set of Delphi components in the unit mwajpeg.pas, which also
supports the mapping of the environment independent image format expected by the
IJG code into MS Windows bitmap and metafile formats.
When you purchase a licence to this product, you purchase a licence for the source
code to the mwajpeg and jpeglib units and the right to include binaries derived
from them in your own products without having to pay additional royalties. You
also have a right to freely distribute the mwjpeg and mwjpeg32 dlls (if used), and
copies of the modified 'C' source is also included in the registered version.
Support is also provided by EMail albeit without a guaranteed response time.
2. INSTALLATION INSTRUCTIONS
============================
Installation is straightforward. The JPEG Component Library is distributed in a
.zip archive; separate versions are provided for use with Delphi 1.0, 2.0 and 3.0,
and C++Builder 1 and 3. Make sure you have the correct version and then:
i. Create a new sub-directory in your delphi directory called "jpeg" and copy the
remaining files contained in the .zip file into this new subdirectory. You should
aim to preserve the directory names held in the zip - if you are using pkunzip
them use the -d option when unzipping the files. Note that if you do use a different
directory from that suggested then you will have to modify the demo programs' .mak
files to change the search path for the JPEG components.
iii. Start the C++Builder IDE and choose the Component|Install Packages menu item.
Click on the "Add" button and browse for the mwjpegc3.bpl file you just copied to
the new subdirectory. Click on OK. The package will now be installed. By
default the JPEG components are placed on the "Additional" tab, TDBJPEGImage is on
the Data Controls tab, and TQRDBJPEGImage is on the QReports tab.
iv. You should now add ";$(BCB)\jpeg" to the end of the library path in the
Tools|Environment Options dialog box (it's on the Library tab). This is so that the
jpeg components can be automatically found in any project of yours that uses them.
You should now restart C++Builder before trying to load a JPEG Image at Design
Time.
---------------
The components are now installed. Use the demo application to learn how they are
used.
3. USING THE JPEG DEMO APPLICATION
==================================
Two demo applications are provided. A JPEG Viewer application demonstrates the
opening and saving JPEG image files and conversion to and from bitmap files (.bmp)
and from Windows Metafiles (.wmf). A database application demonstrates use of the
data aware component.
The JPEG Viewer application may be found in the Examples\Viewer subdirectory
created above. To activate, load the jpegdemo.bpr file into the IDE using the
File|Open Project menu item. This provides a simple application that can open and
save .jpg (JPEG), .bmp (Windows Bitmap) and .wmf (Windows metfaile) files, and
copy and paste bitmaps and metafiles to and from the clipboard. To test out,
simply compile and run the application.
To load and view a JPEG file, click on the open button and load the test.jpg file
contained in the subdirectory created above. You can also try saving it to another
file name (you can save it as either a JPEG or a bitmap). You can also use the
demo application to convert windows bitmaps and metafiles to jpegs simply by
opening the file containing them (or pasting from the clipboard) and saving them
as jpegs. The viewer window can also be resized by simply dragging the bottom
right hand corner with the mouse. Saving the image will save it at the new size.
The application also demonstrates a simple method for printing a JPEG Image using
Quick Reports (even with no database).
You can also use the Object Inspector to see the properties published by the two
JPEG components.
The JPEG database application may also be found in the Examples\db subdirectory
created above. To activate, load the DBDemo.bpr file into the IDE using the
File|Open Project menu item. This application is an extension of the Viewer and
presents images held in an example database. The database records may be perused
using the DBNavigator bar provided. It is still possible to save images from the
database record and to replace/insert images from files or the clipboard. The
application also demonstrates how to print a report including JPEG Images.
4. SOFTWARE DOCUMENTATION
=========================
See the online help file "mwjpeg.hlp"
5. PRICING INFORMATION
======================
JPEG Component Library Source Licence 12 pounds sterling (US$20)
US dollar prices are for indicative pricing only and assume an exchange rate of
one pound = $1.66. All prices are VAT exclusive. UK VAT (currently 17.5%) will be
charged for all UK residents and EC residents that are not VAT registered or do
provide a VAT number as proof of registration.
6. HOW TO REGISTER
==================
Registration may be made by FAX, Letter Post or EMail. For FAX and Letter Post
registrations, a Registration Form is provided in the File "regform.txt" for you
to EMail or print out (FAX or letter post), complete, and send to MWA Software.
You can also register using the Compuserve Shareware Registration Service (GO
SWREG). The software is registered under the name "MWA JPEG Component Library".
Visa, Mastercard, Eurocard and JCB are accepted as payment mechanisms.
International money orders in pounds sterling and cheques drawn on UK Bank
Accounts are also accepted. US Dollar denominated checks are also acceptable
provided that an additional 10% is added to the purchase price to allow for the
additional Bank Charge. Please make cheques payable to McCallum Whyman Associates
Ltd.
EMail registrations should be sent to:
Internet: sales@mwassocs.demon.co.uk, or
Compuserve: 100041,315
FAX:
UK: 01962 735581
Int: +44 1962 735581
MWA Software,
P.O.Box 37,
Alresford,
Hants,
SO24 9ZF,
ENGLAND
All registrations are accepted on the basis that the registered user will be
deemed to have accepted and be bound by the licence conditions for the registered
versions of JPEG component library as recorded in the file reg-lnce.txt supplied
with the evaluation version of the software.
7. Secure Registration by EMail
================================
There are two routes by which you can EMail your credit card details to MWA
Software without incurring the risk of sending a credit card number in clear
across the Internet. One route is to use the encryption mechanism provided by
pkzip. The other is to use PGP.
pkzip encryption will generally be good enough to avoid detection by the so called
"sniffer" programs that are understood to monitor EMail communications, looking
for numbers that look like credit cards. However, it is not believe to be good
enough to resist a determined attack by someone who has access to the necessary
skills in cryptography and a powerful enough computer. On the other hand PGP is
understood to offer a very strong level of protection. MWA Software makes no
recommendations as to which is the better approach. It is for you to decide based
on your own location and concerns.
Secure Transmission using pkzip.
================================
pkzip can encrypt files in a .zip archive using a simple password. To register for
the JPEG Component Library by EMail when using pkzip as your encryption engine:
1. Using the file "regform.txt" as a template, complete a registration form for
the JPEG Component Library. Remember to include your credit card details, billing
address and your name as it appears on your credit card.
2. Choose a password. Opening a dictionary at some random page is often a good way
to do this. For example, let's assume that you choose NERVOUS as your password.
3. Compress and encrypt the modified regform.txt using pkzip and the -s option to
encrypt. For example, with NERVOUS as your password, use the command line:
pkzip -sNERVOUS regform regform.txt
This will create regform.zip containing your compressed and encryted registration
details.
4. EMail regform.zip to MWA Software. Your own EMail utility will usually have a
way to send binary attachments to an EMail message. If you do not have such a
capability then you can use the J-Write Text Editor (also available from MWA
Software) to uuencode a binary file into a text form suitable for attaching to an
EMAil message. This feature is available from the File|Merge menu item.
The MWA Software EMail address is sales@mwassocs.demon.co.uk.
Set the subject to "JPEG Registration"
5. Send the password you choose at step 2 in a separate EMail to MWA Software. For
best protection, use our Compuserve EMail address:
100041.315@compuserve.com
Set the subject to "re: JPEG Registration"
Secure Transmission using PGP
=============================
PGP is a powerful data encryption tool that has been made publicly available by
its author "Phillip Zimmermann". It is sufficiently good to attract the attentions
of various government's agency's and you should be aware that in certain countries
the use of such encryption software is a criminal offence. MWA Software only uses
PGP to decrypt registrations and does not send encrypted EMail. Having said that,
the international version of PGP can be obtained from:
http://www.ifi.uio.no/pgp/
The following URL is also a good source of information about PGP, including
information on how to get the more limited US version.
http://www.arc.unm.edu/~drosoff/pgp/pgp.html
To encrypt a registration using PGP, do the following:
1. Using the file "regform.txt" as a template, complete a registration form for
the JPEG Component Library. Remember to include your credit card details, billing
address and your name as it appears on your credit card.
2. Encrypt regform.txt using PGP and the MWA public key. This is provided in the
file "mwakey.asc", which should be in the same archive as this file. This will
typically be performed by the following commands (the ; indicates the start of a
comment):
pgp -ka mwakey.asc ;add MWA key to your public keyring
pgp -ea regform.txt "MWA Software" ;encrypt and encode for EMail
pgp -kr "MWA Software" ;remove the MWA key from your keyring
The above will have created the encrypted file "regform.pgp". This is a text file
and may be sent as part of a normal EMail to MWA Software:
sales@mwassocs.demon.co.uk
Set the subject to "JPEG Registration"
If you have any reason to doubt the validity of the MWA key, request an up-to-date
version by EMail to the above address, with a subject of "Key Verification
Request".
Thank you for registering forthe JPEG Component Library.

42
CDopping/jpg3s/REGFORM.TXT Normal file
View File

@ -0,0 +1,42 @@
Registration Form for JPEG Component Library
============================================
PLEASE SUPPLY ONE LICENCE FOR :
JPEG Component Library Source Licence 12 pounds sterling (US$20)
US dollar prices are for indicative pricing only and assume an exchange rate of
one pound = $1.66. All credit cards will be billed in pounds and converted to your
local currency by the credit company at current market rates. All prices are VAT
exclusive. UK VAT (currently 17.5%) will be charged for all UK residents and EC
residents that are not VAT registered or do not provide a VAT number as proof of
registration.
PLEASE CHARGE MY CREDIT CARD FOR THE FULL PURCHASE PRICE INCLUDING VAT WHERE
APPLICABLE AS FOLLOWS:
Credit Card No:
Expiry Date:
Name as it appears on credit card:
Billing Address:
EMail Address:
All registrations are accepted on the basis that the registered user will be
deemed to have accepted and be bound by the licence conditions for the registered
versions of the JPEG component library as recorded in the on-line
help file supplied with the evaluation version of the software.
EMail registrations should be sent to:
Internet: sales@mwassocs.demon.co.uk, or
Compuserve: 100041,315
FAX:
UK: 01962 735581
Int: +44 1962 735581
MWA Software,
P.O.Box 37,
Alresford,
Hants,
SO24 9ZF,
ENGLAND

81
CDopping/jpg3s/WHATS.NEW Normal file
View File

@ -0,0 +1,81 @@
JPEG Component Library Version 1.5 Release Notes
================================================
This is version 1.5 of MWA Software's popular JPEG Component Library.
New in this release:
1. This release is primarily for Delphi 4 support and to ensure a common
software base is maintained.
2. Two new methods "LoadPictureFromResource" and "LoadPictureFromResID"
are provided so that JPEG images can be packaged with a program as
resources and then loaded at run-time. This can save considerable space
compared with loading an image into TImage at run-time. See the help for
information on how to use this feature and the Viewer Demo application,
which includes a JPEG resource in its about box.
3. The Delphi 3 version should now install into the IDE without
generating a "A Device Attached to the System is not Working" error
message. This was due to the components having been compiled on a system
with Quick Reports Professional installed. This error message was
experienced by users that used the standard version shipped by Borland.
New features in Version 1.4:
1. Support for C++Builder 3.0. The component library now also supports
C++Builder 3.0. The functionality is identical to the other versions
and a common source base is still maintained.
2. No DLL required for Delphi 3, and all versions of C++Builder.
Version 1.3 required a separate dll for the JPEG compression software.
This is no longer true for Delphi 3 and C++Builder. By default the
JPEG software is linked into your program - dll support is still
available as a command line option.
3. Dynamic dll loading. The Delphi 1 and Delphi 2 versions now load
the JPEG dll dynamically. This enables a more meaningful error message
to be returned if the library cannot be found. The version 1.3 static
load is still available as an option.
4. A new visual component - TDBJPEGImage has been provided. This is a
data aware descendant of TImage that stores images in a database blob
field using JPEG compression.
5. Quick Reports support: with Quick Reports version 1, the
TDBJPEGImage may be included on a report. For version 2, a new
component TQRJPEGImage is provided so that you can print JPEG images
direct from a database.
Bug Fixes:
---------
1. Parameters to TStream.Seek in TJPEGCompressor.SkipInputBytes now
the correct way round :( Why didn't Borland make the "ORigin"
parameter an enumerated type then this typo would have been a compile
time error!
2. The error code returned from PlayEnhMetaFile is now returned in the
error messsage
3. The decompressor now has a property (ColoursIn8bitMode) that allows
the user to specify the actual numbers of discrete colours in the
image when decoding to a 256 colour image. This used to be 256.
However, a lower number can avoid a colour cast especially with Blank
and White images encoded as full colour images. The default is now 64.
4. When the buffer size is changed the buffer will now be freed and
reallocated.
5. An event handler for warning messages has been added.
6. You should now be able to correctly save JPEG images when working
in the IDE and want to save an image as a JPEG at design time (but
only when the image was loaded from a JPEG source - the IDE cannot be
used to convert JPEG's to bitmaps, but it can be used to convert from
JPEGs to bitmaps.
7. OnProgressReport now spelt correctly! Note that uses upgrading from
earlier versions will experience an error message when loading
projects that use the JPEG Component Library reporting that the mis-
spelt property name cannot be found. Ignore this error and manually
direct the "OnProgressReport" to its event handler.

BIN
CDopping/jpg3s/mwjpeg.GID Normal file
View File

Binary file not shown.