Board index » delphi » 1600 x 1280 video resolution drivers?

1600 x 1280 video resolution drivers?

In article: <48del9$...@lastactionhero.rs.itd.umich.edu>  spa...@umich.edu

Quote
(Steve Parus) writes:

>I'm considering developing scientific imaging applications for my
>research to deal with large data sets and am wondering if BGI drivers
>exist for 1600 x 1280 (1600 x 1200?) video resolutions ?  Either 16 or
>256 colors is ok.  Is this a VESA mode?  If so, I may be able to put
>the graphics hardware in that resolution and use existing VESA svga
>drivers.

I have developed a graphical port of Turbo Vision that will display on any 256
colour video mode upto and including 1600 x 1200.  If your hardware and VESA
driver supports it, then so will Graphic Vision.  GV does not have as extensive
a library of graphics primatives as the BGI, but it has some things, like >64k
GetImage / PutImage, Windows .BMP file support, mouse support etc.  Using
Graphic Vision will also give your application menus, dialogs, windows etc.

-- Jay

 ------------------------------------------------
| Jason Burgon    EMail ja...@jayman.demon.co.uk |
 ------------------------------------------------

 

Re:1600 x 1280 video resolution drivers?


Quote
Steve Parus (spa...@umich.edu) wrote:

: I'm considering developing scientific imaging applications for my
: research to deal with large data sets and am wondering if BGI drivers
: exist for 1600 x 1280 (1600 x 1200?) video resolutions ?  Either 16 or
: 256 colors is ok.  Is this a VESA mode?  If so, I may be able to put
: the graphics hardware in that resolution and use existing VESA svga
: drivers.

I think that there is a VESA mode for this, test following program to check
VESA modes available on your system :

uses dos, crt;
type
    vesainfo1= record
                     signature                                 : array[1..4] of byte;
                     versionhi, versionlo                      : byte;
                     fabricant                                 : pointer;
                     unused                                    : longint;
                     codes                                     : pointer;
                     bidon                                     : array [1..238] of byte;
               end;
    vesainfo2= record
                     f_mode                                    : word;
                     f_page                                    : array[0..1] of byte;
                     granularite, wsize                        : word;
                     wseg                                      : array[0..1] of word;
                     setpage                                   : pointer;
                     linesize, resx, resy                      : word;
                     matricex, matricey, bitplans, bitperpixel : byte;
                     memblocks, memmodel, blocksize            : byte;
               end;
var vesa1 : vesainfo1;
    compteur : byte;
    vesa2 : vesainfo2;
    regs : registers;
    oct : byte;
    chaine : string;

function intenHex(w: WORD) : string;
CONST
  hexChars: ARRAY [0..$F] OF CHAR =
    '0123456789ABCDEF';
var s : string;
BEGIN
     s:=hexChars[Hi(w) SHR 4]+hexChars[Hi(w) AND $F]+hexChars[Lo(w) SHR 4]+hexChars[Lo(w) AND $F]+'h';
     intenhex:=s;
END;

function ouinon(nb : word) : string;
begin
     if nb=0 then ouinon:='No ' else ouinon:='Yes ';
end;

procedure appelvesa(var regso : registers);
begin
     regso.ah:=$4f;
     intr($10, regso);
end;

begin
     clrscr;
     regs.al:=0;
     regs.es:=seg(vesa1);
     regs.di:=ofs(vesa1);
     appelvesa(regs);
     if regs.ax<>$004f then begin
        writeln('No VESA here ...');
        halt(1);
     end;
     writeln('version number : ', vesa1.versionhi, '.', vesa1.versionlo);
     write('Name of manufacturer : ');
     while (mem[seg(vesa1.fabricant^):ofs(vesa1.fabricant^)]<>0) do begin
           write(chr(mem[seg(vesa1.fabricant^):ofs(vesa1.fabricant^)]));
           inc(longint(vesa1.fabricant));
     end;
     writeln;
     compteur:=3;
     while (memw[seg(vesa1.codes^):ofs(vesa1.codes^)]<>$ffff) do begin
           writeln(intenhex(memw[seg(vesa1.codes^):ofs(vesa1.codes^)]));
           inc(compteur);
           if compteur=24 then begin
              readkey;
              compteur:=0;
           end;
           regs.al:=1;
           regs.cx:=memw[seg(vesa1.codes^):ofs(vesa1.codes^)];
           regs.es:=seg(vesa2);
           regs.di:=ofs(vesa2);
           appelvesa(regs);
           chaine:=('    '+ 'activable : '+ ouinon(vesa2.f_mode and 1)+'coulors : '+ ouinon(vesa2.f_mode and 8)+
           'graphic mode : '+ ouinon(vesa2.f_mode and 16));
           writeln(chaine);
           inc(compteur);
           if compteur=24 then begin
              readkey;
              compteur:=0;
           end;
           writeln('    ', '1st window : ', 'available : ', ouinon(vesa2.f_page[0] and
1, 'read pos : ',
           ouinon(vesa2.f_page[0] and 2), 'write pos : ', ouinon(vesa2.f_page[0] and 4));
           inc(compteur);
           if compteur=24 then begin
              readkey;
              compteur:=0;
           end;
           writeln('    ', '2nd window : ', 'available : ', ouinon(vesa2.f_page[1] and 1),
'read pos : ',
           ouinon(vesa2.f_page[1] and 2), 'write pos : ', ouinon(vesa2.f_page[1] and 4));
           inc(compteur);
           if compteur=24 then begin
              readkey;
              compteur:=0;
           end;
           writeln('    ', 'granularity : ', vesa2.granularite, 'Ko window
size : ', vesa2.wsize, 'Ko seg addresse : ',
           intenhex(vesa2.wseg[0]), ' ', intenhex(vesa2.wseg[1]));
           inc(compteur);
           if compteur=24 then begin
              readkey;
              compteur:=0;
           end;
           if (vesa2.f_mode and 2)<>0 then begin
              writeln('    ', 'resx : ', vesa2.resx, 'resy : ', vesa2.resy, 'bits
per pixels : ',
           vesa2.bitperpixel);
           inc(compteur);
           if compteur=24 then begin
              readkey;
              compteur:=0;
           end;
           end;
           inc(longint(vesa1.codes));
           inc(longint(vesa1.codes));
     end;
     readkey;
end.

This will also tell you the mode and the granularity factor of target mode.
If it is available, you can get the mode number, and then use a normal vesa
unit to display proprely (with maybe a little adaptation, due to the size of
each lines) ...
These vesa units were posted on this newsgroup, E-Mail me if you missed them

: spa...@umich.edu

Hope this will help,
                                        F.

--
Fabrice.Pre...@Linux.univ-compiegne.fr
WWW : Http://linux.univ-compiegne.fr/~premel/index.html

Re:1600 x 1280 video resolution drivers?


Quote
Mike McWhinney (elja....@mixcom.com) wrote:

: An alternature would be to use a commercial library such as
: Metagraphics' METAWINDOW.  It is an excellent product, and is

What is the $$$-range for this product.

Where to order it ?

--
=============================================================================
Dipl. Phys. Hans L. Trautenberg                       Universitaet Regensburg
phone (49) 941 949211                                             Flurstr. 14
fax   (49) 941 930792                                            D-92348 Berg
                                                                      Germany
=============================================================================

Re:1600 x 1280 video resolution drivers?


c4140@rphs45 (Hans Trautenberg t2466) wrote:

Quote
>Mike McWhinney (elja....@mixcom.com) wrote:
>: An alternature would be to use a commercial library such as
>: Metagraphics' METAWINDOW.  It is an excellent product, and is

>What is the $$$-range for this product.

MetaWindow is compatible with TP/BP compilers.  The price for
it is somewhere around $200 I think.  

Metagraphics Software Corporation
(408) 438-1550
Order line: (800) 332-1550
Internet: sa...@metagraphics.com

Check out the Programmer's Shop, or Provantage.  They have
discounted prices as opposed to ordering directly from Metagraphics.

Mike McWhinney
Elja, Inc.

Other Threads