Por donde empezar en Linux y Object Pascal
 

Hola, soy un entregado a Delphi desde su versión 1, (esa versión que se denominó Visual Basic Killer, que años), y antes con Turbo Pascal, durante estos, muchos, años me he peleado con el mundo por no pasar a C o C++, soy un programador de sistemas a quien no le ha hecho falta C para nada, mi frase siempre ha sido la misma "cuando encuentre algo que no sea capaz de hacer en Pascal, me pasaré a C" desde centros de emergencias hasta sistemas de testeo de vehículos han sido implementados en mi Delphi, y todo los equipos que he dirigido se han rendido a Delphi, pero .....

..... siempre he vivido en el mundo Windows, sabía que había una cosa que era Kylix y otra que era Lazarus que en principio funcionaban sobre Linux y que eran muy similares a Delphi, y que siempre tuve como asignatura ponerme con ellas pero nunca llegó el momento. Ahora ha llegado, nos ha surgdo un proyecto que se justifica muy mucho que corra en Linux, y descubro con sorpresa que Kylix no está soportado por Borland- Inprise, y que no hay forma de comprarlo (descargarlo).

Es freePascal una alternativa profesional ? Puedo descargar Kilix desde algún rincon de Internet que no haya sido eliminado por Microsoft ? Dadme una respuesta, sino 20 años de programación Pascal tendrán que rendirse a la tiranía y complejidad de C.

Perdon por la parrafada.

mmmm... segun la version 7 de delphi tiene incorporado a Kylix. Yo la uso pero nunca he investigado eso:p

FreePascal segun se es bastante robusto para proyectos profesionales y Lazarus es la alternativa del IDE de Delphi para FreePascal aunque si lo comparas con Delphi aun -dicen- adolece de muchas cosas, alguno lo compara con delphi3 -que ya era bastante poderoso-

Eso es lo que se. Alguien nos sacara de la duda.

Free Pascal es muy estable. Por lo que leo en su lista de correo hay mucha gente que lo utiliza profesionalmente.

En cuanto a Lazarus, todavía no llega a su primera versión estable (están en la 0.9.2tantos). Es bastante estable, pero todavía ha problemas en algunos aspectos. Esto se debe a que intenta establecer un método común para entornos muy diferentes entre sí (Win32, Cocoa, GTK+, Qt...) y eso cuesta. Aun así ya pueden hacerse muchas cosas.

Yo les daría una oportunidad. Ambos proyectos se lo merecen.

A ver, una pregunta: ¿es posible usar exclusivamente FreePascal para hacer aplicaciones gráficas, o sea, prescindiendo de Lázarus?

// Saludos

No me quise quedar con la duda sobre tu pregunta Roman, baje e instale la version 2.2 de FP y en la carpeta Demos aparecen 4 ejemplos de aplicacion para Windows. Este es el codigo de uno de ellos Hello World.
¡No es nada divertido!

Código Delphi [-]
{
  Copyright (c) 1996 by Charlie Calvert
  Modifications by Florian Klaempfl
  Standard Windows API application written in Object Pascal.
  No VCL code included. This is all done on the Windows API
  level.
}
{$APPTYPE GUI}
{$MODE DELPHI}

program WinHello;
uses
  Strings, Windows;
const
  AppName = 'WinHello';
 
function WindowProc(Window: HWnd; AMessage: UINT; WParam : WPARAM;
                    LParam: LPARAM): LRESULT; stdcall; export;
  var
     dc : hdc;
     ps : paintstruct;
     r : rect;
begin
  WindowProc := 0;
  case AMessage of
    wm_paint:
      begin
         dc:=BeginPaint(Window,@ps);
         GetClientRect(Window,@r);
         DrawText(dc,'Hello world by Free Pascal',-1,@r,
           DT_SINGLELINE or DT_CENTER or DT_VCENTER);
         EndPaint(Window,ps);
         Exit;
      end;
    wm_Destroy:
      begin
         PostQuitMessage(0);
         Exit;
      end;
  end;
  WindowProc := DefWindowProc(Window, AMessage, WParam, LParam);
end;
 
 { Register the Window Class }
function WinRegister: Boolean;
var
  WindowClass: WndClass;
begin
  WindowClass.Style := cs_hRedraw or cs_vRedraw;
  WindowClass.lpfnWndProc := WndProc(@WindowProc);
  WindowClass.cbClsExtra := 0;
  WindowClass.cbWndExtra := 0;
  WindowClass.hInstance := system.MainInstance;
  WindowClass.hIcon := LoadIcon(0, idi_Application);
  WindowClass.hCursor := LoadCursor(0, idc_Arrow);
  WindowClass.hbrBackground := GetStockObject(WHITE_BRUSH);
  WindowClass.lpszMenuName := nil;
  WindowClass.lpszClassName := AppName;
  Result := RegisterClass(WindowClass) <> 0;
end;
 
 { Create the Window Class }
function WinCreate: HWnd;
var
  hWindow: HWnd;
begin
  hWindow := CreateWindow(AppName, 'Hello world program',
              ws_OverlappedWindow, cw_UseDefault, cw_UseDefault,
              cw_UseDefault, cw_UseDefault, 0, 0, system.MainInstance, nil);
  if hWindow <> 0 then begin
    ShowWindow(hWindow, CmdShow);
    ShowWindow(hWindow, SW_SHOW);
    UpdateWindow(hWindow);
  end;
  Result := hWindow;
end;

var
  AMessage: Msg;
  hWindow: HWnd;
begin
  if not WinRegister then begin
    MessageBox(0, 'Register failed', nil, mb_Ok);
    Exit;
  end;
  hWindow := WinCreate;
  if longint(hWindow) = 0 then begin
    MessageBox(0, 'WinCreate failed', nil, mb_Ok);
    Exit;
  end;
  while GetMessage(@AMessage, 0, 0, 0) do begin
    TranslateMessage(AMessage);
    DispatchMessage(AMessage);
  end;
  Halt(AMessage.wParam);
end.

¿Y para Linux?, ¿se puede? :(

Si, hay un ejemplo de "hello world" para linux también

Casimiro, aquí encontré un programita para linux, dos botones y dos cajas de texto creo

Código Delphi [-]
{
  Temperature.pas - allow the user to enter temperatures and convert
  them between Fahrenheit and Celsius
}

program temperature;

{$mode objfpc}    // use Delphi 2 extensions

uses
  glib, gdk, gtk, sysutils;

{ Define a record type to represent our app's window and controls. This
  makes it easier to mainpulate it w/o using global variables. }

Type
  TMainWindow = Record
    Window : pGtkWindow;    // top-level window
    hBox,              // main container for controls
    fahBox,            // holds Fahrenheit label and text box
    celBox,            // holds Celsius label and text box
    celButton,          // C to F button
    fahButton,          // F to C button
    celEntry,          // Celsius text box
    fahEntry,          // Fahrenheit text box
    celSlider,          // Celsius slider
    fahSlider,          // Fahrenheit slider
    celLabel,          // label in Celsius box
    fahLabel : pGtkWidget;  // label in Fahrenheit box
    celAdjust,          // range for Celsius slider
    fahAdjust : pGtkObject;  // range for Fahrenheit slider
  end;
  PMainWindow = ^TMainWindow;

procedure quit_app (widget: pGtkWidget; Window: PMainWindow); cdecl;
{ Clean up and shut down GTK+ signal handling. }
begin

  dispose(Window);
  gtk_main_quit;

end;  // procedure quit_app

procedure scale_set_default_values( scale : pGtkScale);
{ Set default values for specified GtkScale widget. }
begin

    gtk_range_set_update_policy (GTK_RANGE (scale),
                                 GTK_UPDATE_CONTINUOUS);
    gtk_scale_set_digits (scale, 1);
    gtk_scale_set_value_pos (scale, GTK_POS_BOTTOM);
    gtk_scale_set_draw_value (scale, TRUE);
  
end;  // procedure scale_set_default_values

function FtoC(tempF: float):float;
{ Convert temp in Fahrenheit to Celsius. }
begin

  Result := (tempF - 32) * (5/9);
  
end;  // function FtoC

function CtoF(tempC: float): float;
{ Convert temp in Celsius to Fahrenheit. }
begin

  Result := (tempC * (9/5) + 32);

end;  // function CtoF

procedure SetSliderValue ( slider : pGtkAdjustment; value : float);
{ Position the specified GtkAdjustment widget to the value. }
begin

  if (value < 0.0) and (value > 100.0) then
    value := 0.0;

  gtk_adjustment_set_value(slider, value);

end;  // procedure SetSliderValue
    
procedure DisplayTemp( temperature : float; entry : pGtkEntry);
{ Put the temperature in the specified text box. }
begin

  gtk_entry_set_text(entry, pchar(Format('%.1f', [temperature])));
  
end;  // procedure DisplayTemp

procedure buttonCtoF(widget: pGtkWidget; Window: PMainWindow); cdecl;
{ C to F button signal handler. Get Cel temp, convert it and display new
  Fah temp. }
var
  textValue: pgchar;
  tempC,
  tempF: float;
begin

  textValue := gtk_entry_get_text(pGtkEntry(Window^.celEntry));
  
  if textValue <>'' then
  begin

    // Wrap StrToFloat in a try-except-end block in case letters were
    // typed into the text box.
    try
    
      tempC := StrToFloat(textValue);
      
    except
    
      on E:EConvertError do
        tempC := 0.0;
        
    end;  // try-except    

    tempF := CtoF(tempC);
  
    DisplayTemp(tempF, pGtkEntry(Window^.fahEntry));
     SetSliderValue(pGtkAdjustment(Window^.fahAdjust), tempF);
  
  end;  // procedure buttonCtoF
  
end;

procedure buttonFtoC(widget: pGtkWidget; Window: PMainWindow); cdecl;
{ F to C button signal handler. Get Fah temp, convert it and display new
  Cel temp. }
var
  textValue: pgchar;
  tempC,
  tempF: float;
begin
  textValue := gtk_entry_get_text(pGtkEntry(Window^.fahEntry));
  
  if textValue <>'' then
  begin

    // Wrap StrToFloat in a try-except-end block in case letters were
    // typed into the text box.
    try
    
      tempF := StrToFloat(textValue);
    
    except
    
    on E:EConvertError do
        tempF := 0.0;
    
    end;  // try-except  
    
    tempC := FtoC(tempF);

    DisplayTemp(tempC, pGtkEntry(Window^.celEntry));
    SetSliderValue(pGtkAdjustment(Window^.celAdjust), tempC);

  end;  // if textValue <> ''
    
end;  // procedure buttonFtoC

procedure FsliderChanged( widget : pGtkWidget; Window : PMainWindow); cdecl;
{ Fahrenheit slider has moved, display new value. }
begin

  DisplayTemp(pGtkAdjustment(Window^.fahAdjust)^.value,
          pGtkEntry(Window^.fahEntry));

end;  // procedure FsliderChanged

procedure CsliderChanged( widget : pGtkWidget; Window : PMainWindow); cdecl;
{ Celsius slider has moved, display new value. }
begin

  DisplayTemp(pGtkAdjustment(Window^.celAdjust)^.value,
          pGtkEntry(Window^.celEntry));

end;  // procedure CsliderChanged

function create_main_window : PMainWindow;
{ Create an instance of the main window and all its controls. }
begin

  Result := New(PMainWindow);
  with Result^ do
  begin

    Window := pGtkWindow(gtk_window_new(GTK_WINDOW_TOPLEVEL));
    gtk_window_set_title(Window, 'Temperature Conversion');

    gtk_signal_connect(pGtkObject(Window), 'destroy',
                       GTK_SIGNAL_FUNC (@quit_app), Result);
    
    hBox := gtk_hbox_new(false, 10);
    gtk_container_add(GTK_CONTAINER(Window), hBox);
    
    // Create vertical sliders whose ranges are controlled by a
    // gtk_adjustment widget, set signal handlers, and add them
    // to the application's window.
    fahAdjust := gtk_adjustment_new(0.0, 0.0, 101.0, 0.5, 10.0, 1.0);

    fahSlider := gtk_vscale_new(GTK_ADJUSTMENT(fahAdjust));

    scale_set_default_values(GTK_SCALE(fahSlider));

    gtk_signal_connect(GTK_OBJECT(fahAdjust), 'value_changed',
                       GTK_SIGNAL_FUNC(@FsliderChanged), Result);
    
    gtk_box_pack_start(pGtkBox(hBox), pGtkWidget(fahSlider),
                       False, False, 0);
  
    // Create a vertical box to hold the Fahrenheit label and text box.
    fahBox := gtk_vbox_new(false, 10);

    gtk_container_add(GTK_CONTAINER(hBox), fahBox);

    fahLabel := gtk_label_new('Fahrenheit');
    
    gtk_box_pack_start(pGtkBox(fahBox), pGtkWidget(fahLabel),
                       False, False, 0);

    fahEntry := gtk_entry_new();
    
    gtk_box_pack_start(pGtkBox(fahBox), pGtkWidget(fahEntry),
                       False, False, 0);
    
    fahButton := gtk_button_new_with_label('--F to C-->');
    
    gtk_signal_connect(pGtkObject(fahButton), 'clicked',
                       GTK_SIGNAL_FUNC(@buttonFtoC), Result);

    gtk_box_pack_start(pGtkBox(fahBox), pGtkWidget(fahButton),
                       False, False, 5);

    // Create a vertical box to hold the Celsius label and text box.
    celBox := gtk_vbox_new(False, 10);
    
    gtk_container_add(GTK_CONTAINER(hBox), celBox);

    celLabel := gtk_label_new('Celsius');
    
    celEntry := gtk_entry_new();
    
    gtk_box_pack_start(pGtkBox(celBox), pGtkWidget(celLabel),
                       False, False, 0);
    
    gtk_box_pack_start(pGtkBox(celBox), pGtkWidget(celEntry),
                       False, False, 0);

    celButton := gtk_button_new_with_label('<--C to F--');
    
    gtk_signal_connect(pGtkObject(celButton), 'clicked',
                       GTK_SIGNAL_FUNC(@buttonCtoF), Result);
    
    gtk_box_pack_start(pGtkBox(celBox), pGtkWidget(celButton),
                       False, False, 5);

    // Finally add the Celsius slider to the application window.
    celAdjust := gtk_adjustment_new(0.0, 0.0, 101.0, 0.5, 10.0, 1.0);
    
    celSlider := gtk_vscale_new(GTK_ADJUSTMENT(celAdjust));
    
    scale_set_default_values(GTK_SCALE(celSlider));
    
    gtk_signal_connect(GTK_OBJECT(celAdjust), 'value_changed',
                       GTK_SIGNAL_FUNC(@CsliderChanged), Result);
    
    gtk_box_pack_start(pGtkBox(hBox), pGtkWidget(celSlider),
                       False, False, 0);

  end;    // with Result^

end;   // function create_main_window

var
  MainWindow : PMainWindow;
  
begin

  // Initialize the GTK+ libraries.
  gtk_init(@argc, @argv);

  // Create and show the application's window.
   MainWindow:=create_main_window;
   gtk_widget_show_all(PGtkWidget(MainWindow^.Window));

  // Start handling signals.
  gtk_main();

end.

Saludos

Se puede. FPC incluye módulos para utilizar GTK+ sin necesidad de un "diseñador". Yo he hecho pruebas, y es algo lioso pero cuando le coges el tranquillo es tan fácil como diseñar páginas web escribiendo el código HTML a mano.

Gracias por las repuestas. Imagino, como mencionan, que es algo lioso, tal como cuando queremos programar en Delphi sin usar la VCL.

Ahora, los ejemplos que vienen con FPC son o bien para Windows o bien para Linux, pero, si no mal entiendo, GTK puede fucionar en Windows también ¿no? ¿Podría, en tal caso, compilarse para uno u otro sistema el mismo código?

// Saludos

Sí, GTK+ funciona igual en cualquier sistema operativo. Para ello hay que descargarse la biblioteca que corresponda e instalarla para que esté disponible.

En el sitio web oficial de GTK+ lo explican, en perfecto inglés. Pulsa en "Download" para ver las versiones disponibles..

Gracias Ñuño; tengo ya instalado el GTK pues lo requiere el GIMP. Entonces, en resumen, aun siendo lioso, ¿es posible hacer una aplicación gráfica multiplataforma, usando sólo FPC y GTK, sin Lázarus?

// Saludos

Respuesta rápida: sí. Un enlace a un tutorial de cómo utilizar GTK+ con Free Pascal. Está en inglés, explica la versión 1 de GTK+ y creo que no está completo, pero sirve como inicio.

Aclaraciones Lazarus/freepascal
 

0.9.5 ya sale la 0.9.6. Se merece que le echen un vistazo, los va a sorprender... ;)

Yo les daría una oportunidad. Ambos proyectos se lo merecen.[/quote]

Al que le interese miren mi otro post sobre Kylix...

Saludos.

--
Donald Shimoda [Team RO]

http://blogs.remobjects.com/blogs/donald

A quien se le puede ocurrir usar algo asi hoy en dia cuando con lazarus pegas los botones en el formulario y compila en 3 segundos? :)

Muchachos, informense, bajense lazarus y pruebenlo. Este ejemplo esta *un tantito* desactualizado. :P

--
Donald Shimoda [Team RO]

http://blogs.remobjects.com/blogs/donald