http://www.canaimasoft.com/f90VB/Overview.htm
f90VB is a set of four Fortran libraries that provide the functionality necessary for your Fortran programs to gain access to COM/ActiveX objects. In addition, you can use f90VB to call Visual Basic DLLs from your Fortran applications, or to create Fortran DLLs that are able to handle intrinsic Visual Basic data types (like VB's strings, arrays or variants). f90VB also includes TLView, a professional quality Type Library browser, that can be used as a tool to explore COM/ActiveX objects you are using from your Fortran applications.
Wrapid - generate a GUI for your Fortran programs | Update Link / Bad Link? |
Wrapid is a tool which allows a modern windows user interface to be quickly added to a Fortran program. Usually no changes are required to the existing Fortran code. Submitted Nov 25, 2004 by Ian Hawkins Rating: (1 Ratings) Rate this link Total Visits: 298Updated Nov 29, 2004 | |
The FORTRAN interface | Update Link / Bad Link? |
This section describes the subroutines that can be called from a FORTRAN program to interface with the Graphics Window Manager. All these routines use the inherited status strategy which means that if the STATUS argument is not set to the value SAI__OK on entry the routine will exit without performing any action. If an error occurs during the execution of a routine the STATUS will be set and an error will be reported using the error message service (EMS---SUN/104). Submitted Mar 24, 2000 Rating: (1 Ratings) Rate this link Total Visits: 185 | |
GINO graphics - GINOMENU Studio v2.0 | Update Link / Bad Link? |
GINOMENU Studio is an interactive GUI builder and development environment specifically aimed at the Fortran programmer. Developers can create a graphical user-interface by drag-and-drop methodology without having to write any source code at all. GINOMENU Studio is a self-contained GUI builder that doesn't rely on resources or dialogs having to be created with another application. When the layout is complete, the GUI can be saved as Fortran-77 or Fortran-90 code containing calls to GINOMENU. This code can then be compiled, linked and run from within the Studio to check the final appearance of the application. All common widget types are available in GINOMENU Studio including buttons, check boxes, radio boxes, sliders, status bars, toolbars, text/value entry boxes, text/value arrays, graphics frames, panels and list boxes/combo boxes. The properties of each widget can be changed such as label, name, title-bar, size and colour and GINOMENU Studio includes a full callback editor eroviding a quick and easy way of developing GUI's and at last provides a true 'Visual' Fortran. | |
f90gl: Fortran interface for OpenGL and GLUT | Update Link / Bad Link? |
f90gl is a public domain implementation of the official Fortran 90 bindings for OpenGL. The current version is Version 1.2.1 This version implements the interface for OpenGL 1.2, GLU 1.2, GLUT 3.7, and several extensions. It supports several Unix workstations and Windows 95/98/NT. It is also the Fortran interface for Mesa. Submitted Feb 29, 2000 Rating: N/A Rate this link Total Visits: 70 | |
Fortran Interface | Update Link / Bad Link? |
The Fortran (F77) interface is provided, but certain features have necessarily been omitted (awaiting Fortran 90). The syntax is different since there are no pointers in F77. There are no user-defined types provided in the Fortran interface as Fortran does not provide structures. Once Fortran 90 has been adopted, user-defined types will likely appear in the Fortran interface. Submitted Mar 24, 2000 Rating: N/A Rate this link Total Visits: 60 | |
FORTRAN callable interface | Update Link / Bad Link? |
The FORTRAN callable interface consists of the CZ and XZ packages. Normally, only the XZ package is of concern to the user: any calls to the CZ package being made in a completely transparent manner. The exception to this case is of course when a new application that requires a different server is to be built. Submitted Mar 24, 2000 Rating: N/A Rate this link Total Visits: 35 | |
Fortran 77 Interface | Update Link / Bad Link? |
This chapter describes the Fortran 77 interface with C++. Submitted Mar 29, 2000 Rating: N/A Rate this link Total Visits: 34 | |
Interactive Software Services Ltd. | Update Link / Bad Link? |
This is a UK based software company specializing in the development of user-interface and graphics tools for use with the Fortran programming language. Our products are designed to allow non-specialist programmers, such as scientists and engineers, to add modern user interface and graphics features to their Fortran based software. Submitted Mar 29, 2000 Rating: N/A Rate this link Total Visits: 31Updated Dec 21, 2004 by Sebastian Di Laura | |
C-Fortran Interface | Update Link / Bad Link? |
You may want to assemble programs from a mixture of C and Fortran modules. One reason might be to call Fortran graphics routines from the MONGO or PGPLOT libraries from a C program. Another might be to call a C function that manipulates character strings in some way that is ugly, or impossible, in Fortran. Many Unix compilers have a somewhat standard procedure for mixing C and Fortran modules. The procedures decribed here are specific to the Sun operating system, but may carry over to other flavors of Unix. Submitted Mar 24, 2000 Rating: N/A Rate this link Total Visits: 20 | |
Fortran Interface Primer | Update Link / Bad Link? |
The Fortran interface allows NAO objects to be created, used and deleted from a Fortran program. The Fortran interface is functionally equivalent to the Raw interface, being Stub routines which turn around and call the Raw interface. There are two important issues that arose when we created this interface: how to generate names for the Fortran routines that call the Raw interface, and how to pass objects between C++ and Fortran. These are discussed in some detail below. Submitted Mar 24, 2000 Rating: N/A Rate this link Total Visits: 20 | |
Interfacing with C with Absoft Fortran compilers | Update Link / Bad Link? |
Absoft Fortran 77 and 90 are designed to be fully compatible with the Absoft C/C++ and the Microsoft C/C++ compilers. The linker can be used to freely link C modules with Fortran main programs and vice versa. However, some precautions must be taken to ensure proper interfacing. Data types in arguments and results must be equivalent and some changes to the linking procedure must be made. All of these rules are detailed below. Be sure to follow them closely, or the results will be both unpredictable and invalid. Submitted Mar 29, 2000 Rating: N/A Rate this link Total Visits: 18Updated Jan 09, 2006 by Nicholas Nagle | |
ADOL-F | Update Link / Bad Link? |
ADOL-F is a FORTRAN 90 interface to the ADOL-C library and uses operator overloading for the evaluation of arbitrary order derivatives of vector functions that are defined by computer programs written in FORTRAN 90/77. The package provides various drivers for the derivative evaluation by forward and reverse mode, drivers for common optimization tasks and ODEs. Submitted Feb 29, 2000 Rating: N/A Rate this link Total Visits: 12 | |
The SYSREQ FORTRAN interface | Update Link / Bad Link? |
This routine sends the specified command to the named service via the SYSREQ mechanism. One may also use the routine FMSREQ, which is part of the FATMEN [] and resides in PACKLIB. This routine as the same calling sequence as SYSREQ, but provides automatic protection against network problems (timeouts etc.) with retry were required. Submitted Mar 24, 2000 Rating: N/A Rate this link Total Visits: 9 |
http://www.xeffort.com/xeffort/home.htm
Xeffort library (previously known as XFT) is used for easy building Win32 GUI applications with Compaq and Intel Visual Fortran compilers. It seamlessly integrates with Microsoft Visual Studio (.NET) IDE providing:
• | Application wizard, for quick creating of skeleton MDI, SDI or dialog-based applications |
• | Handler wizard, for creation of prototypes of most-frequently used routines |
• | Online help, which can be run from Visual Studio "Tools" menu |
Xeffort is distributed as free, open source resource.
Currently, Xeffort is available only for Compaq/(Intel) Visual Fortran compiler since it partially depends on some extensions, namely, integer (Cray) pointers and DEC$ metacommands. Your possible effort to port it to other compilers is welcome.
Xeffort can be used in two flavors: "Lite" and "Full". "Lite" version consists of a limited set of modules which present useful functions in any kind of application without additional overhead. Currently, the following modules are provided in "Lite" flavor: XFTGDI, XFTFile, XFTMenu, XFTReg and XFTStrings. These modules can be included into your projects and compiled separately of the rest of Xeffort library.
"Full" version of the package presents a complete framework built on top of Win32 API, and it provides functions able to build an entire GUI application of moderate complexity. However, the open architecture of Xeffort enables that both - "Lite" and "Full" flavors can be used on top of existing code, regardless whether it's a console, QuickWin, dll or Win32 application - in just few steps you're able to bind Xeffort windows with your existing application windows and add new functionality.
Xeffort Full version carries along an independent set of interfaces for Win32 functions and structures so that it is not dependent on DFWIN upgrades throughout CVF development, thus it should work on any CVF version.
Xeffort Full version is most easily used as a static library (Xeffort.lib) along with a set of modules (*.mod). Xeffort Lite modules can be used as separate .f90 files inserted into your projects.
Arjen Markus (7 november 2002) I have written an article on the use of Tcl in a Fortran program. (Fortran Forum, december 2002). Below you will find a fragment of that article, describing a small client-server system for on-line visualisation:
It is meant to demonstrate how easy it is to combine Fortran and Tcl and do novel things with them.
Note: If you are interested in the library, just e-mail me.
To apply Tcl within a program you need to interact with the run-time system, the Tcl interpreter. This is actually a collection of variables and Tcl routines. Most commonly there is only one interpreter, but there are classes of applications where several are used at once, as each may act quite independently, for instance in client/server systems.
I created a small library to facilitate the interaction:
With this library I created a small demonstration program, an almost trivial simulation, that provides on-line visualisation of the results:
! Simple program to show the Ftcl library
!
program calc
use FTCL
implicit none
integer :: i
integer :: nosteps
real :: x
real :: y
real :: dphi
real :: phi
!
! Start the Tcl interpreter, and read the major parameters
!
call ftcl_start( 'calc.tcl' )
call ftcl_get( 'dphi', dphi )
call ftcl_get( 'nosteps', nosteps )
!
! Run the calculation and output the variables
!
do i = 0,nosteps
phi = real(i) * dphi
x = cos( phi )
y = sin( phi )
call ftcl_put( 'x', x )
call ftcl_put( 'y', y )
call ftcl_script( 'transfer' )
enddo
call ftcl_script( 'close_transfer' )
stop
end
The interesting feature here is that the Fortran program does not need to know anything about the output mechanism - this is all put into the Tcl routine transfer.
The script file that is run when initialising the interpreter looks like this:
# Define the routines to send data to the server
#
proc transfer { } {
global channel
global x
global y
puts $channel "$x $y"
flush $channel
}
proc close_transfer { } {
global channel
close $channel
}
#
# SetUp accepts zero or one arguments, if there is no argument,
# use the local host.
#
proc SetUp { {host localhost} } {
global channel
set port 8085
set channel [ socket $host $port ]
}
SetUp
#
# Set the computational parameters
#
set nosteps 100
set dphi 0.1
The routine SetUp sets up a socket connection to the local host (as there is no host name given). The routine transfer writes the values of the variables x and y to the channel and flushes it to make sure the output is available immediately on the receiving side.
The receiving side is a somewhat less simple Tcl script that uses the graphical toolkit, Tk, to display the input (the x and y coordinates) graphically:
#
# SetUp the server side (it needs to "listen" to the port)
#
proc SetUp { } {
set port 8085
set timeout 60000
socket -server [list Accept $timeout] $port
# We run in a graphical (Tk) shell, so an event loop is
# already available: the next statement is not required.
# vwait forever
}
#
# Procedure that accepts the client and sets up the connection
#
proc Accept { timelimit socket ip args } {
fconfigure $socket -block false
fileevent $socket readable [list DrawInput $socket]
}
#
# Draw the input graphically
#
proc DrawInput { socket } {
global xprev yprev
if { ! [eof $socket] } {
gets $socket line
set x [lindex $line 0]
set y [lindex $line 1]
if { $x != "" && $y != "" } {
set xc [expr 100+80*$x]
set yc [expr 100+80*$y]
.c create line $xprev $yprev $xc $yc -fill black
set xprev $xc
set yprev $yc
}
}
}
#
# Main code: create a window in which we can draw and start
# the server .
#
global xprev yprev
set xprev 0.0
set yprev 0.0
canvas .c -background white
pack .c
SetUp
The server's version of SetUp creates a so-called server socket and then enters an event loop (explicitly via the command vwait or automatically because the runtime environment is graphical). The other routines have to do with the handling of incoming requests and incoming data. The result is a very simple picture.
AM Thanks to Clif Flynt this little library is now capable of using Tk within a Fortran program. This means you can build a Fortran program with a very portable GUI ... Just thought to mention this, as the interest in this library has increased a lot over the past couple of months.
AM (2 july 2004) One place to find the library is: http://www.digitalsmarties.com/tcl/ftcl.zip