Random thoughts on coding & technology

Scripting Language with Thundax P-Zaggy

2012-01-15T02:09:00.001+01:00

In this article I will show you the approach taken to solve a common problem: Creating your own Scripting Language using a compiler. Sometimes we need to create our own language and to achieve that we either can create from scratch a lexical analyser in a high level language or use an open source automatic generator of lexical analysers. As I do not want to spent too much time in this task, I obviously chose the second one using an easy approach using JFLEX and CUP. There are many to choose from, e.g. Antlr, JavaCC, SableCC, Coco/R, BYacc/J, Beaver, etc. but I like the way Cup/Jflex work together. Jflex will automatically generate the finite automata of the lexical analyser through the regular expressions that define the tokens from a language. CUP is a system written in Java used to generate LALR syntax analysers. Cup file will contain the syntax definition of the language (Grammar) using a notation similar to BNF (Backus-Naur).

This approach will allow me to create a small compiler which will contain a lexical analyser, a syntax analyser and a semantic analyser without having to add extra workload to my simple Language builder. Cup/Jflex compiler will handle whether the language is well defined or not and in my Delphi project I only have a dummy function that will run if the previous compiler returns 0 errors.

I have also taken advantage of the SynEdit multi-line edit control to enhance the visualization of the simple Scripting Language. The exposed example is pretty basic and it will help to keep the grammar out of the Delphi code. I have tried other Delphi alternatives like GOLD parser and Coco/R but I did not get the expected results. So, If you have any better idea, please do let me know!.

This example will allow the user to define the graph by calling the layout object and connecting one node from another using a numeric description. In left side figure you can actually see the basics of the language and its definition. It invokes the layout object and then it generates a connection from the node(1) to node(2) and it ends the sentence with ";" character. There is no need to define the nodes as if a node does not exist it will be automatically created. The compiler created will manage all kind of errors and warnings and it will inform the user about them. Check that it will inform whether you are committing a lexical error (non recognized symbols, etc) and syntax error (bad composed expressions) through an Error or a semantic error (duplicated lines) through a warning.

A most developed example is shown in the following figure:

Once the language is free of errors, the generator is enabled and P-Zaggy can build the graph using the instructions previously defined and analysed by the external compiler. Note that to be able to check the language you must have installed Java.

The following graph have been created using the basic language:

As you can see it is faster than placing all the objects with the mouse and we can use external tools to generate the script and then check them with the compiler.

Here you can get the latest version of the app:

Thundax P-Zaggy v1.2.0 build 278.

Jflex regular expressions:

<YYINITIAL>layout {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.layout, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>node  {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.node, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>\( {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.OpenBracket, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>\)  {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.CloseBracket, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>tonode {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.tonode, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>parameters  {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.parameters, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>\. {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.dot, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>\; {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.endSentence, new sToken(pos - yytext().length(), yyline, yytext()));
}
<YYINITIAL>[0-9]+ {
  if (CUP$parser$actions.verbose)
    System.out.println(yytext());
  pos += yytext().length();
  return new Symbol(sym.INTEGER, new sToken(pos - yytext().length(), yyline, yytext()));
}

[ \t\r\n]+  { pos = 1; }
[a-z]+          {
  System.out.println("ERROR at line "+(Integer.valueOf(yyline)+1) + ": '" +yytext() + "' not recognized");
  pos += yytext().length();
  return new Symbol(sym.ff, new sToken(pos - yytext().length(), yyline, yytext())); }
.   {
  System.out.println("ERROR at line "+(Integer.valueOf(yyline)+1) + ": '" +yytext() + "' not recognized");
  pos += yytext().length();
  return new Symbol(sym.ff, new sToken(pos - yytext().length(), yyline, yytext()));
}

Cup grammar:

terminal        sToken  layout, node, OpenBracket, CloseBracket, tonode, parameters, dot, endSentence, ff;

terminal  sToken          INTEGER, ITEM, QUOTE;

non terminal  scriptClass graphLine;
non terminal    sToken          itemBracket, itemReturned;

graphLine ::=  layout : t1
   dot : t2
   node : t3
   itemBracket : e1
   dot : t6
   tonode : t7
   itemBracket : e2
          endSentence : t10
          graphLine
                        {:
    scriptLines.AddTokens(e1, e2);
    RESULT = scriptLines; :}
          | error;

itemBracket ::= OpenBracket : t4
   itemReturned : e1
   CloseBracket : t5 {: RESULT = (sToken)e1; :}
                        | error;

itemReturned ::= INTEGER : e1 {: RESULT = (sToken)e1; :}
                 | error;

Related links:

The rules of a creator’s life (the secret formula)

2012-01-02T12:44:00.001+01:00

(source creativesomething.net). Rules created by Tanner Christensen of Creative Something showcases a recipe for success.

Finite automata to Regular Grammar with Thundax P-Zaggy

2011-12-30T19:00:00.000+01:00

Moving ahead with FA, now we can generate the right-linear grammar that corresponds to the finite automata generated. The system is pretty simple and basically what the algorithm does is to go recursively through every state and to store the production (A → bC) using the info from the transition and both states.

P-Zaggy will use description text to assign unique variable names to each state. Each transition in the graph matches a production in the right-linear grammar. For example (right side image), the transition from “A” to “B” along the transition “a” matches the production “A → aB”. This production will be automatically added into the production list in the "Finite Automaton (simulation)" tab. To generate the full grammar, just open your finite automata and press "Get grammar" button to get the linear grammar. Now as any final state carries the production to λ, λ symbol has been added to the system as empty string.

In the following image you will see a general example with the automatically generated grammar:

Example with λ string:

Demo video:

Get the latest version from here:

Thundax P-Zaggy v1.20 build 208. (Executable)

Looking back/ahead:

This would be the last post of the year 2011 and I'm taking this moment to review all the good stuff I have been publishing in my blog, from the physics engine to different code snippets and all of them with the help of a big an bright Delphi community. I always find difficult to get round to writing more often but I always have my notebook with me and every time and idea pops out I am there to catch it. I have an endless list of really interesting stuff I would like to tackle and I hope next year would be more fruitful as there are less than 50 articles for this year (even though the visits have been increased to almost 6K per month wow!, I am grateful for that!). I am also blissfully happy for putting grain of salt in the community as I have widely used the knowledge of others and it is great to pay back.

Next year I will be implementing different algorithms and I will be focusing on grammars, compilers and AI as I am very keen on those subjects and as you already know I like a lot visual stuff (And everything or almost everything with my loved Delphi). I'm preparing a roadmap about different utilities I have in mind and stay tuned for new and very interesting stuff!.

Happy new year 2012!.

Jordi Corbilla

Related links:

Finite Automata with Thundax P-Zaggy part II

2011-12-29T19:53:00.003+01:00

Going on with the further enhancement of P-Zaggy (part I) to use its graph creation capability to run and simulate DFA, I have released a new version (v1.2.0 build 180) which allows you to check a bunch of strings in batch. One the DFA is defined, we can easily test our input strings by adding them into the list and the application will check every item and it will populate the status with "accepted/rejected" message. This version still only works with one char regular expressions (^[A-Z]$) so more complex expressions (^[A-Z]+$) will be used but not correctly adapted.

Examples:

Related links:

Regular expressions.

Finite Automata with Thundax P-Zaggy part I

2011-12-29T03:25:00.000+01:00

I have moved forward the development of Thundax P-Zaggy with the addition of a Finite Automata builder and simulator. "A deterministic finite automaton (DFA) also known as deterministic finite state machine is a finite state machine that accepts/rejects finite strings of symbols and only produces a unique computation (or run) of the automaton for each input string. (wikipedia)". Building the automata with P-Zaggy is quite simple, so let's start by building a DFA for the following language:

L = {ba | abⁿa, n > 0}.

As it is shown in the previous image, the DFA would be as follows:

With the tool we would be able to create our diagrams placing the states and transitions. Once the diagram is set up, all transitions need to have the transition string to change the ongoing state and initial and final states need to be selected (using right click and selecting "Mark as Start Node" for Initial state and "Mark as End Node" for Final state).

We can start the simulation with very simple steps. Firstly, select the tab called "Finite Automaton (simulation)" and enter the test input string to test. Then press start button to internally initialize the graph as a DFA and press step to process every character of the input string while the diagram is changing states and showing you which is the actual state and whether the string is being accepted or rejected. To set up a single loop transition, select the node and with right click select "Set connector loop" and add text for the transition.

In this beta version, we can also use Regular Expressions in our transitions thanks to the widespread use of regular expressions inside Delphi XE.

From the same screen we can test our regular expressions and check whether if they match or not. There are still some issues to tackle like "empty string" and other considerations that I would be delving into detail in the following days. I am also working on a Layered-Tree-Draw Algorithm using Reingold-Tilford Algorithm and the enhancement of the better recognition of more complex regular expressions.

Have a look at this preview of the functioning of the graph, it is really worth it:

Stay tuned and give P-Zaggy a try from here:

Thundax P-Zaggy v1.2.0 build 155. (there are two examples included).

Related links:

Install multiple instances of the same Delphi application service

2011-12-10T01:46:00.001+01:00

In this article you will find an example on How to install multiple instances of the same Delphi application service under Windows. This topic was raised a few years ago in StackOverflow and I have decided to give more details about how to use multiple instances of the same service.

The service needs to be unique in name and the best way to sort this out is using a parameter to describe the service in a unique way. The service itself will use this parameter to compose its name even though it is using the same executable. In this example I will identify the services when installing the service using the command line with the following instruction: "myService /install Param1". Param1 will be used to compose the internal service name as myServiceParam1. If we want to use another instance, just install a second service with a different param name as: myService /install Param2.

To achieve this is pretty simple, just create the service using your Delphi XE and then create the methods ServiceBeforeUninstall and ServiceCreate:

unit uService;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs, WinSvc;

type
  TServiceExample = class(TService)
    procedure ServiceCreate(Sender: TObject);
    procedure ServiceBeforeUninstall(Sender: TService);
  private
    FDescription: String;
    FPreviousName: String;
    FPreviusDisplayName: string;
  public
    function GetServiceController: TServiceController; override;
    { Public declarations }
  end;

var
  ServiceExample: TServiceExample;

implementation

uses
  ComObj;

{$R *.DFM}

procedure ServiceController(CtrlCode: DWORD); stdcall;
begin
  ServiceExample.Controller(CtrlCode);
end;

function TServiceExample.GetServiceController: TServiceController;
begin
  Result := ServiceController;
end;

procedure TServiceExample.ServiceBeforeUninstall(Sender: TService);
begin
  Name := FPreviousName + FDescription;
  DisplayName := FPreviusDisplayName + FDescription;
end;

procedure TServiceExample.ServiceCreate(Sender: TObject);
begin
  FDescription := System.ParamStr(2);
  FPreviousName := Name;
  FPreviusDisplayName := DisplayName;
  Name := Name + FDescription;
  DisplayName := DisplayName + FDescription;
end;

end.

Notice the System.ParamStr(2) that will use the second parameter which was input from the command line. The first parameter is the /install command needed to install the service.

After the execution of the following commands:

myService /install Param1
myService /install Param2

You will see two installed services using the same executable:

To uninstall them, use the opposite command:

myService /uninstall Param1

myService /uninstall Param2

But this is not ending here. Now the services are installed, but neither the service name is set nor the description. To achieve this, we need to use the ChangeServiceConfig functions from WinSvc - Service Control Manager unit.

Have a look at the complete source code:

unit uService;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs, WinSvc;

type
  TServiceExample = class(TService)
    procedure ServiceCreate(Sender: TObject);
    procedure ServiceBeforeUninstall(Sender: TService);
    procedure ServiceAfterInstall(Sender: TService);
  private
    FDescription: String;
    FPreviousName: String;
    FPreviusDisplayName: string;
  public
    function GetServiceController: TServiceController; override;
    { Public declarations }
  end;

type
  SERVICE_DESCRIPTION = packed record
    lpDescription: PChar;
  end;

  PSERVICE_DESCRIPTION = ^SERVICE_DESCRIPTION;

var
  ServiceExample: TServiceExample;

const
  SERVICE_CONFIG_DESCRIPTION = 1;

function ChangeServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD; lpInfo: Pointer): BOOL; stdcall; external 'advapi32.dll' name 'ChangeServiceConfig2W';

implementation

uses
  ComObj;
{$R *.DFM}

procedure ServiceController(CtrlCode: DWORD); stdcall;
begin
  ServiceExample.Controller(CtrlCode);
end;

function TServiceExample.GetServiceController: TServiceController;
begin
  Result := ServiceController;
end;

procedure TServiceExample.ServiceAfterInstall(Sender: TService);
var
  SvcMgr, Svc: SC_HANDLE;
  desc: SERVICE_DESCRIPTION;
begin
  SvcMgr := OpenSCManager(nil, nil, SC_MANAGER_ALL_ACCESS);
  if SvcMgr = 0 then
    Exit;
  try
    Svc := OpenService(SvcMgr, PChar(Name), SERVICE_ALL_ACCESS);
    if Svc = 0 then
      RaiseLastOSError;
    try
      desc.lpDescription := PWideChar(ParamStr(0) + ' ' + FDescription);
      ChangeServiceConfig( Svc, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,SERVICE_NO_CHANGE, desc.lpDescription, nil, nil, nil, nil, nil, nil);
      desc.lpDescription := PWideChar('Service Example with Params = ' + FDescription);
      ChangeServiceConfig2(Svc, SERVICE_CONFIG_DESCRIPTION, @desc.lpDescription);
    finally
      CloseServiceHandle(Svc);
    end;
  finally
    CloseServiceHandle(SvcMgr);
  end;
end;

procedure TServiceExample.ServiceBeforeUninstall(Sender: TService);
begin
  Name := FPreviousName + FDescription;
  DisplayName := FPreviusDisplayName + FDescription;
end;

procedure TServiceExample.ServiceCreate(Sender: TObject);
begin
  FDescription := System.ParamStr(2);
  FPreviousName := Name;
  FPreviusDisplayName := DisplayName;
  Name := Name + FDescription;
  DisplayName := DisplayName + FDescription;
end;

end.

This solution is using the example provided by koochangmin on his Delphi blog. If you have a closer look at the ServiceAfterInstall method, you will find the composition of the name and description which will be used to populate the values in the service:

That is the way the service needs to be created in order to let the application use the parameters in runtime.

If you have any problem uninstalling the services, just use the SC command to delete the service:

sc delete ServiceExampleParam1

Related links:

Google and Facebook "Secrets" unveiled

2011-11-07T19:38:00.000+01:00

Here you can see an interesting video from one of the TED talks this year in which we can see how the information is filtered and presented according to our surfing (using algorithmic and personalized filters). It gives interesting reflections.

Enjoy the video!.

Monitoring Desktop Heap Memory and troubleshooting issues (part II)

2011-10-17T21:07:00.002+02:00

Now that we know what Desktop Heap Memory is and How works (Monitoring Desktop Heap Memory and troubleshooting issues (part I)), we can extend this functionality and retrieve the Heap size from our Delphi app and even better, create a new desktop with a specified heap size.

To achieve this I am going to use the public API functions introduced in Windows Vista: CreateDesktopEx, which allows the caller to specify the size of desktop heap.And, GetUserObjectInformation that includes a flag for retrieving the desktop heap size (UOI_HEAPSIZE).

Get Heap Size:

To get the heap size, we just need to invoke the GetUserObjectInformation using the UOI_HEAPSIZE flag:

procedure GetHeapSizeClick();
var
  HDesktop: HDESK;
  UHeapSize: ULong;
  tempDword: DWORD;
begin
  HDesktop := OpenInputDesktop(0, False, DESKTOP_CREATEMENU or
    DESKTOP_CREATEWINDOW or DESKTOP_ENUMERATE or DESKTOP_HOOKCONTROL or
    DESKTOP_WRITEOBJECTS or DESKTOP_READOBJECTS or DESKTOP_SWITCHDESKTOP or
    GENERIC_WRITE);

  GetUserObjectInformation(HDesktop, UOI_HEAPSIZE, @UHeapSize, SizeOf(UHeapSize), tempDword);
  OutputDebugString(PChar('UOI_HEAPSIZE ' + Inttostr(UHeapSize)));
  CloseDesktop(HDesktop);
end;

The output of the string is as follows:
Debug Output: UOI_HEAPSIZE 12288 Process Project1.exe (4224)

Where the value highlighted in bold, is the predefined size of your heap in the SubSystems\Windows registry key.

Create a new desktop with a specific heap size:

Using the CreateDesktopEx or CreateDesktopExW (Unicode):

var
  HDesktopglobal: HDESK;

procedure CreateDesktop();
var
  UHeapSize: ULong;
  tempDword: DWORD;
begin
  try
    HDesktopglobal := CreateDesktopExW('Z', nil, nil, DF_ALLOWOTHERACCOUNTHOOK, GENERIC_ALL, nil, 3052, nil);
  except
    on e: exception do
      ShowMessage(SysErrorMessage(GetLastError));
  end;
  if HDesktopglobal <> 0 then
  begin
    GetUserObjectInformation(HDesktopglobal, UOI_HEAPSIZE, @UHeapSize, SizeOf(UHeapSize), tempDword);
    OutputDebugString(PChar('UOI_HEAPSIZE ' + Inttostr(UHeapSize)));
  end;
end;

procedure CloseDesk();
begin
  CloseDesktop(HDesktopglobal);
end;

We can check the result with dheapmon tool:

With more details using dheapmon -v and the looking for 'Z' desktop.

The output of the string is as follows:

Debug Output: UOI_HEAPSIZE 3052 Process Project1.exe (364)

Remember that the Desktop needs to be closed.

Related links:

Open a list of URLs

2011-10-16T03:05:00.002+02:00

Going on with my previous entries, in this post I am releasing a little tool to open a web browser (in this case google chrome) and populate it with a list of stored URLs. This tool would be the culmination of the articles: My first Google Chrome extension (Get all URLs from Google Chrome tabs) and Get Chrome active tab URL using Delphi. And as you know, I love automating and when I am surfing the internet I like keeping track of my URLs and being able to retrieving and saving them easily.

You can download the tool from here. The tool only needs the path to your browser (in my case google chrome) and a list of pre-saved urls (for example the output list from my chrome extension).

The tool looks like this:

And it uses the ShellExecute function from ShellAPI.

Enjoy it!.

Related Links:

Open browser.

Monitoring Desktop Heap Memory and troubleshooting issues (part I)

2011-10-16T02:48:00.000+02:00

This article wants to put together a series of interesting articles to monitor the desktop heap memory and finally put forward a little in-house tool to monitor the output of Desktop Heap Information Monitor Tool v8.1 from AireSoft using the algorithm from "capturing output capture" from one of my previous posts.

Installing "Desktop Heap Information Monitor Tool v8.1:
To correctly install the tool (dheapdmp.zip), go to AireSoft web page and follow the installation steps from the web. If an error pops up, follow the guidelines from the following links:
- dheapInst - driver installation error occurred (2).
- dheapinst - Driver Installation error occured (124).

If it helps, I got the error "Driver Installation error occured (124)" and I fixed it by changing the compatibility of dheapinst to Windows Server 2003 SP1.

Once installed, if we run dheapmon -l to install the monitor and then again dheapmon, we will see the heap memory information:

More about "Desktop heap memory":

The Desktop Heap Monitor is a tool that examines usage of desktop heap.

WIN32 subsystem has internal heap area known as "desktop heap." When you run a large number of Windows-based programs, "Out Of Memory" error messages appear when you attempt to start new programs or try to use programs that are already running, even though you still have plenty of physical and pagefile memory available.

This behavior can occur if the desktop heap in the WIN32 subsystem is depleted. To fix this problem follow the next workaround :
- http://support.microsoft.com/kb/126962/

source: Microsoft.

Increasing "Desktop heap memory":

To increase desktop heap memory, we can use the tool "Microsoft Fix It 50496" that will increase the parameters automatically. If you want to fix it manually, you just need to go to the following registry path and tweak it:
- HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\SubSystems

Where the default values for my windows vista are:

%SystemRoot%\system32\csrss.exe

ObjectDirectory=\Windows

SharedSection=1024,12288,512

Windows=On

SubSystemType=Windows

ServerDll=basesrv,1

ServerDll=winsrv:UserServerDllInitialization,3

ServerDll=winsrv:ConServerDllInitialization,2

ProfileControl=Off

MaxRequestThreads=16

The first SharedSection value (1024) defines the heap size common to all desktops. This includes the global handle table.

The second SharedSection value (12288) controls the size of the desktop heap that is associated with an interactive window station (used for Windows objects). This static value is used to prevent ill- behaved applications from consuming too many resources. Because the desktop heap is mapped into each process' address space, this value should not be set to an arbitrarily high value (as it would decrease performance), but should only be increased sufficiently to allow all the desired applications to run.

The third SharedSection value (512) controls the size of the desktop heap for each desktop that is associated with a "non-interactive" window station.

source : microsoft.

Monitoring Desktop Heap Memory:
As it is quite difficult to monitor, I have developed a little tool that you can download from here, to log every change on the table result.

Just point the tool to the dheapmon executable and press start. Every 10s the output will be scanned and displayed into the component, taking into account the previous value, and if a change occurs it will be displayed in another colour.

Final notes:
Desktop Heap memory is related to "Out of Memory" issues and this article will help you to work with this parameter and how to deal with it and monitor it.

Stay tuned for Part 2, where I will go further with Desktop heap memory using Delphi.

Jordi Corbilla.

Related links:

My tribute to a man who was a unique genius, Steve Jobs

2011-10-08T23:59:00.000+02:00

Steve Jobs was a unique creative genius whose life was far too brief. Source: macworld.co.uk.

Get Chrome active tab URL using Delphi

2011-09-18T16:17:00.000+02:00

After developing my first Chrome extension to retrieve all URLs from Google chrome, I have been trying to reproduce the same behaviour using Delphi, but it was impossible. Chrome is still adding some new features and extending their extensions for developers. For example, others navigators such as Internet Explorer and Firefox they have a DDE extension to retrieve some of the properties but not available for Chrome.

The best way I found was using FindWindow and SendMessage windows functions to get the text from the tab and get tue URL. It's not a win solution but will help you to retrieve the URL of the active page without copy-paste action, just by switching to the next tab and retrieving data from the tool.

The basic code to achieve this is the following one:

function GetChromeActiveTabURL(Wnd: HWnd; Param: LParam): Bool; stdcall;
var
  urls: TStrings;
  hWndMainWindow, hWndTab: HWND;
  Buffer : array[0..255] of Char;
  res : boolean;
begin
  res := true;
  urls := TStrings(Param);
  SendMessage(Wnd, WM_GETTEXT, Length(Buffer), integer(@Buffer[0]));
  hWndMainWindow := FindWindow('Chrome_WidgetWin_0', Buffer);
  application.ProcessMessages;
  if hWndMainWindow <> 0 then
  begin
    hWndTab := FindWindowEx(hWndMainWindow, 0, 'Chrome_AutocompleteEditView', nil);
    if hWndTab <> 0 then
    begin
      SendMessage(hWndTab, WM_GETTEXT, Length(Buffer), integer(@Buffer));
      urls.Add(Buffer);
      res := false;
    end;
  end;
  Result := res;
end;

procedure TUrlChrome.GetUrl(Sender: TObject);
var
  Urls: TStringList;
begin
  Urls := TStringList.Create;
  try
    EnumWindows(@GetChromeActiveTabURL, LParam(Urls));
    Memo1.Lines.AddStrings(Urls);
  finally
    FreeAndNil(Urls);
  end;
end;

To get the class name window, we can use Winspector to inspect chrome and get the names for the main window and for the tabs:

Chrome_WidgetWin_0:

Chrome_AutocompleteEditView:

And you can get the tool from here: ThundaxChromeURL.

I'm not proud of this solution, but at least it will work for current versions of Chrome. I also recommend to give a go to my chrome extension (It's not been published into Chrome market, it turns out that you have to pay a $5.00 fee), that is much better than the tool as it's able to get all urls.

Related links:

My first Google Chrome extension (Get all URLs from Google Chrome tabs)

2011-09-17T21:45:00.001+02:00

As a good internet researcher I always have hundreds of tabs opened in my Chrome navigator and sometimes I find a bit of chore to copy and paste all the URL that I have done a research on and that any other day I would be using again. So, that's my extension about, to display in a pop up window all the url's from all tabs to then copy them without problems (the correct name would be [search purposes] -> Get all URLs from Google Chrome tabs).

I have been struggling to write a little tool using Delphi, but it only works with Internet explorer and Mozilla firefox, so I thought it could be great to give chrome extensions a try.

It is quite easy to develop and debug using all the development tools available from the navigator itself. As in the following example, I have opened 3 new tabs with the www.google.es URL, and if we click the extension button, will get a pop up list with the URLs from all tabs:

The source code is as follows:

manifest.json:

{
  "name": "Get All URL's Extension by Jordi Corbilla",
  "version": "1.0",
  "description": "Extension to display all the URL's from all TABs.",
  "browser_action": {
    "default_icon": "icon.ico",
    "popup": "urlList.html"
  },
  "permissions": [
    "tabs"
  ],
  "icons" : {

    "48" : "icon.ico",


    "128" : "icon.ico"


  }
}

urlList.html:

<!DOCTYPE>
<!--
 * Copyright (c) 2011 Jordi Corbilla. All rights reserved.  
-->
<html>
  <head>
    <script>
      chrome.tabs.getAllInWindow(null, function(tabs) {
        tabs.forEach(function(tab){
          myFunction(tab.url);	
        });
      });

      function myFunction(tablink) {
        console.log(tablink);
        var oNewNode = document.createElement("LI");
        urlList.appendChild(oNewNode);
        oNewNode.innerText=tablink;  
      }
</script>
</head>
  <body>
    <div>URL List</div>
    <ul ID = urlList>
    </ul>
  </body>
</html>

You can download the extension from here: URLJCExtension.zip. To install, you only need to unzip the file and then go to chrome://extensions/, expand developer mode and load my extension (from the unzipped folder):

As the extension uses the console log method, you can see all the links in the console (just for debug purposes, but it's really good to have a go on it).

Just right click on the extension icon and then "Inspect Pop-up" and you'll see the following window with the current list of urls:

Enjoy the extension!.

Related links:

Fluent Interfaces example using Delphi

2011-08-26T18:14:00.000+02:00

I was introduced to Fluent interfaces when I was developing with Java using Dependency Injection and somebody told me that it could be really interesting if I post an example using Delphi and chaining method, and here I am!. I have developed a simple example that uses chaining methods to populate a THouse object with TDoors and TWindows objects with the hope it will make it easy to understand the concept. There are several examples on the net, but I couldn't find any interesting enough. So this simple example will try to introduce you to "how to develop fluent interfaces using method chaining" with the aim of writing more readable code. The overview of the architecture is the following one, using UML notation:

The Fluent Interface unit example is as follows (uFI.pas) using generics and interfaces:

// ***********************************************
// @author  jordi corbilla
// @comment Fluent interface composition example
//
// ***********************************************

unit uFI;

interface

uses
    Graphics, Contnrs, Generics.Collections, Classes;

type
    TWindow = class;

    IWindow = interface
        function SetColor(color: TColor): TWindow;
        function ToString(): string;
    end;

    TWindow = class(TInterfacedObject, IWindow)
    private
        FColor: TColor;
    public
        function SetColor(color: TColor): TWindow;
        function ToString(): string; override;
        class function New: TWindow;
    end;

    TDoor = class;

    IDoor = interface
        function SetColor(color: TColor): TDoor;
        function ToString(): string;
    end;

    TDoor = class(TInterfacedObject, IDoor)
    private
        FColor: TColor;
    public
        function SetColor(color: TColor): TDoor;
        function ToString(): string; override;
        class function New: TDoor;

    end;

    IHouse = interface
        function AddWindow(window: TWindow): IHouse;
        function AddDoor(door: TDoor): IHouse;
        function ToString(): String;
    end;

    THouseItemsList<T> = class(TObjectList)
        function ToString(): string; override;
    end;

    TDoorList = class(THouseItemsList<IDoor>)
        function ToString(): string; override;
    public

    end;

    TWindowList = class(THouseItemsList<IWindow>)
        function ToString(): string; override;
    end;

    THouse = class(TInterfacedObject, IHouse)
    private
        FDoorList: TDoorList;
        FWindowList: TWindowList;
    protected
        function AddWindow(window: TWindow): IHouse;
        function AddDoor(door: TDoor): IHouse;
    public
        property WindowList: TWindowList read FWindowList;
        property DoorList: TDoorList read FDoorList;
        class function New: IHouse;
        function ToString(): String; override;
        constructor Create();
        destructor Destroy(); override;
    end;

implementation

uses
    SysUtils;

{ THouse }

function THouse.AddDoor(door: TDoor): IHouse;
begin
    Self.FDoorList.Add(door);
    result := Self;
end;

function THouse.AddWindow(window: TWindow): IHouse;
begin
    Self.FWindowList.Add(window);
    result := Self;
end;

constructor THouse.Create;
begin
    FDoorList := TDoorList.Create;
    FWindowList := TWindowList.Create;
end;

destructor THouse.Destroy;
begin
    FreeAndNil(FDoorList);
    FreeAndNil(FWindowList);
    inherited;
end;

class function THouse.New: IHouse;
begin
    result := Create;
end;

function THouse.ToString: String;
var
    description: TStringList;
begin
    description := TStringList.Create;
    try
        description.Add(Self.FDoorList.ToString);
        description.Add(Self.FWindowList.ToString);
    finally
        result := description.Text;
        description.Free;
    end;
end;

{ TWindow }

class function TWindow.New: TWindow;
begin
    result := Create;
end;

function TWindow.SetColor(color: TColor): TWindow;
begin
    Self.FColor := color;
    result := Self;
end;

function TWindow.ToString: string;
begin
    result := 'Window color ' + ColorToString(FColor) + sLineBreak;
end;

{ TDoor }

class function TDoor.New: TDoor;
begin
    result := Create;
end;

function TDoor.SetColor(color: TColor): TDoor;
begin
    Self.FColor := color;
    result := Self;
end;

function TDoor.ToString: string;
begin
    result := 'Door color ' + ColorToString(FColor) + sLineBreak;
end;

{ THouseItemsList }

function THouseItemsList<T>.ToString: string;
var
    i: Integer;
    description: String;
begin
    for i := 0 to Self.count - 1 do
        description := description + ' ' + Self[i].ToString;
    result := description;
end;

{ TDoorList }

function TDoorList.ToString: string;
var
    description: TStringList;
begin
    description := TStringList.Create;
    try
        description.Add('Number of doors: ' + inttostr(Self.count));
        description.Add('Descriptions: ');
        description.Add( inherited ToString);
    finally
        result := description.Text;
        FreeAndNil(description);
    end;
end;

{ TWindowList }

function TWindowList.ToString: string;
var
    description: TStringList;
begin
    description := TStringList.Create;
    try
        description.Add('Number of Windows: ' + inttostr(Self.count));
        description.Add('Descriptions: ');
        description.Add( inherited ToString);
    finally
        result := description.Text;
        FreeAndNil(description);
    end;
end;

end.

Now it comes when we can use the object using FI notation in a more readable way:

var
    House: IHouse;
begin
    House := THouse.New.AddWindow(TWindow.New.SetColor(clFuchsia)).AddDoor(TDoor.New.SetColor(clWhite))
        .AddWindow(TWindow.New.SetColor(clRed)).AddDoor(TDoor.New.SetColor(clGreen));
    Memo1.Lines.Add(House.ToString);
    House := nil;

    House := THouse.New;
    House.AddWindow(TWindow.New.SetColor(clRed)).AddWindow(TWindow.New.SetColor(clBlue)).AddWindow(TWindow.New.SetColor(clGreen));
    House.AddDoor(TDoor.New.SetColor(clRed)).AddDoor(TDoor.New.SetColor(clBlue)).AddDoor(TDoor.New.SetColor(clGreen));
    Memo1.Lines.Add(House.ToString);
    House := nil;

Notice that now, we can chain our objects, composing the structure of the House by using the AddWindow and AddDoor method. To display the result I'm using the ToString method that will do the job for my purpose.

And the result of the previous execution:

Number of doors: 2
Descriptions:
Door color clWhite
Door color clGreen

Number of Windows: 2
Descriptions:
Window color clFuchsia
Window color clRed

Number of doors: 3
Descriptions:
Door color clRed
Door color clBlue
Door color clGreen

Number of Windows: 3
Descriptions:
Window color clRed
Window color clBlue
Window color clGreen

Just play with it and you'll experience the powerfulness of this method. I hope you like it.

I'm looking forward to your comments.

Jordi

Building my own Delphi Physics Engine part IX

2011-08-22T22:08:00.002+02:00

I'm quite familiar with GDI, the graphics provided under Microsoft and which is widely used in Windows applications. TDPE is now ready to use Direct2D as now it's fully supported by Delphi 2010 and XE. According to MSDN, Direct2D is: a hardware-accelerated, immediate-mode, 2-D graphics API that provides high performance and high quality rendering for 2-D geometry, bitmaps, and text. The Direct2D API is designed to interoperate well with GDI, GDI+, and Direct3D.

As I'm testing this under Windows Vista, I've had to upgrade my windows version to Service Pack 2 and then I've installed the following update (KB971512 - The Windows Graphics, Imaging, and XPS Library contain the latest advancements in modern graphics technologies for gaming, multimedia, imaging and printing applications.). Direct2D is already installed in Windows 7.

We can use the same methods from TCanvas for our TDirect2DCanvas as they derive from the same ancestor TCustomCanvas. But you need to check the documentation for differences in the way they work.

A simple way to use Direct2D is as follows:

uses
    Direct2D, D2D1;

procedure Paint();
begin
    if TDirect2DCanvas.Supported then
    begin
        d2dCanvas := TDirect2DCanvas.Create(Canvas, ClientRect);
        try
            d2dCanvas.RenderTarget.beginDraw;
            d2dCanvas.RenderTarget.Clear(D2D1ColorF(clBlack));
            d2dCanvas.RenderTarget.SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
            // drawing goes here
            Paint(d2dCanvas);
            d2dCanvas.RenderTarget.EndDraw;
        finally
            FreeAndNil(d2dCanvas);
        end;
    end;
end;

Here is the result of the Physics Engine using a Direct2D Render and a GDI Render:

You will see the difference when switching from GDI to Direct2D as the performance is quite different. When it comes to Direct2D, my computer is getting quite slower as my graphic card is not powerful at all and we can see that it takes a while to render the image.

GDI uses Pixel graphics but Direct2D can supports vector graphics as well, in which mathematical formulas are used to draw the lines and curves. Vector graphics provides high quality rendering independent of resolution of the device, while the pixelated graphics has dependency with resolution which may results in choppy graphics.

Most of the GDI APIs are not using anti-aliasing and transparency. Ofcrouse there are functions to do so but always there’s programming cost for taking advantage of these features. Also if we apply transparency and anti-aliasing, the computations are done using CPU. Direct2D can take advantage of graphics hardware and delegate the computationally intensive tasks to GPU.

Source : Programming Direct2D.

Get the latest version here: ThundaxBallDemo v1.584.
Interaction:
'd' will drop a box with a random colour and a constant angular velocity.
'f' will drop a circle with a random colour and a constant angular velocity.
'mouse interaction' mouse is able to grab items.
'q' Enable/Disable GDI or Direct2D rendering.

Note: You need to have installed Direct2D to run the app using Direct2D, otherwise GDI will be used.

Related links:

Building my own Delphi Physics Engine part VIII

2011-08-10T23:04:00.002+02:00

TDPE is almost ready and it will not take long to release the first stable library!. I am eager to continue working on the project trying to sort out different physic scenarios to make my dynamic engine even more realistic. Do not hesitate to give it a try as you will find the experience quite interesting. I am still working on the n-edge object and the cutting tool and trying to refactor all the code to cope with a layer architecture. Using this concept, I want to structure my system in a way that every component works using a certain level of abstraction. As you see in the next figure, every object is allocated in the screen while there is another layer which is responsible for the collision detection and another one for the forces interaction. You will notice in the video that there are still little issues to tackle regarding the object interaction as sometimes we can experience overlapping.

In the figure above, you can see that now the items are not rigid and they interact with each other as they were real items. Notice that the square item will go through the round shape of the circle.

Enjoy the video!.

Get the latest executable here: ThundaxBallDemo v1.504.
Interaction:
'd' will drop a box with a random color and a constant angular velocity
'f' will drop a circle with a random color and a constant angular velocity
'mouse interaction' mouse is able to grab items

Related links:

Continuous Integration for your Delphi projects using Jenkins CI

2011-07-10T22:07:00.002+02:00

Going on with the utilization of Msbuild, I'm putting forward this post using Jenkins CI (Continuous Integration) previously known as Hudson, for your Delphi projects under Windows Vista. In a nutshell, Jenkins provides an easy-to-use so-called continuous integration system, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. The automated, continuous build increases the productivity. (Source: What is Jenkins?). With these simple steps I'll lead you throughout the whole installation and configuration of your first Delphi built project using Jenkins CI and MsBuild.

1 . Download the latest version of Jenkins CI.

Use the following link to download the latest windows installer, in my case v1.419. The default installation path is C:\Program Files\Jenkins and there you'll find the service wrapper jenkins.exe and the Java web archive (jenkins.war) that is very useful to start the Jenkins if you have difficulties installing it with a container. It's very easy to run Jenkins by itself using the command: java -jar jenkins.war (which uses Winstone as a container).

2. Setting up environment variables.

To make sure that Jenkins runs perfectly, we need to set up the JENKINS_HOME environment variable:

3. Adding administrator privileges to Jenkins windows service.

We need to be sure that the service has enough permissions to be running. To do this, go to console and type down "services.msc". Then look for Jenkins service and add the log on information using an administrator account.

I had a lot of troubles trying to execute MSBuild from Jenkins until I realised that the service didn't have enough permissions.

4. Installing Jenkins CI plug-ins.

Once everything is done, we can go on with Jenkins and open a web explorer and type http://localhost:8080. Now we need to add the following plug-ins: Jenkins MSBuild Plugin and Hudson Setenv Plugin. To install them go to "Manage Jenkins"-> "Manage Pluggins" -> Available and look for them. Then, save the changes at the end of the page and reload Jenkins.

Once installed, you'll find them under the Installed section:

5. Configure MSBuild.

Now the plug-in is ready, and we need to supply the path of our MSBuild. Go to "Manage Jenkins" -> "Configure Jenkins" and add the Msbuild information in the MSbuild section:

6. Adding environment variables.

As we are trying to build Delphi projects we need to set up Jenkins with the same environment variables included in rsvars.bat batch file. Go to "Manage Jenkins" -> "Configure Jenkins" and add the following environment variables according to your Delphi version:

7. Setting up your project.

Start a new job with your project description and choose the "Build a free-style software project" type. And add the following MSbuild information to build your project (dproj file):

8. Build your Project.

Everything is ready to do the build. Now execute the "Build now" option and you'll see your project being compiled and built using MSBuild.

Now, you can add your Delphi projects and improve the quality of your software.

Related Links:

Delphi Msbuild

2011-07-04T20:08:00.000+02:00

Msbuild has been included since Delphi 2007 to automate our Delphi builds and manage our projects in a better way. I have developed a custom application to provide automated Builds for Delphi (2007 / 2009 / 2010 / XE -Win32) using MSBuild. The app called Thundax Delphi Builder is available here for free. This little tool generates a batch file to call the list of projects and it displays the information using a TMemo getting the info from the console window using a pipe with the capture method from my previous post.

If you take a look at my application, you will see a output section and a configuration section. In the configuration section we need to add the list of projects to compile/build, the path of our Delphi binaries and the different MSBuild commands we want to execute.

As soon as all the parameters are correct, we can hit the "Build" button. The Build button generates a batch file called build.bat. This batch file contains the list of all our projects with the correct commands for MSBuild. Just take a look at the generated batch file and you will understand what is this doing.

First of all, it sets the environment variables for the target compiler. It means that if you enter in the "Bin" section the path to your DelphiXE binaries, it will set MSBuild for DelphiXE. To do this, we only need to run rsvars.bat batch file which contains:

@SET BDS=C:\Program Files (x86)\Embarcadero\RAD Studio\7.0
@SET BDSCOMMONDIR=C:\Users\Public\Documents\RAD Studio\7.0
@SET FrameworkDir=C:\Windows\Microsoft.NET\Framework\v2.0.50727
@SET FrameworkVersion=v2.0.50727
@SET FrameworkSDKDir=
@SET PATH=%FrameworkDir%;%FrameworkSDKDir%;%PATH%
@SET LANGDIR=EN

Of course this tools is just a "little tool" to help you understand how Msbuild works and how to invoke it from the command line. I use continuous integration tools and some day I will talk about one of them, for example Hudson continuous integration.

PS: If you want to download the app, download my Calc Hash to make sure that the MD5 hash is correct. To check it, download the app, remove the " (0c3c3ab27a6000d8881974a411959828)." hash and check the file with the calc. If the app is correct, you should get the same hash.

Related links:

Capturing console output with Delphi 2010/XE

2011-07-04T19:02:00.004+02:00

This new method supersedes the previous one using TDosCommand. It's been tested and it works with Delphi 2010 and Delphi XE, so it's worth to give it a try. It's really easy to use and I'm preparing a little tool with it.

//Anonymous procedure approach by Lars Fosdal
type
    TArg<T> = reference to procedure(const Arg: T);

procedure TForm1.CaptureConsoleOutput(const ACommand, AParameters: String; CallBack: TArg<PAnsiChar>);
const
    CReadBuffer = 2400;
var
    saSecurity: TSecurityAttributes;
    hRead: THandle;
    hWrite: THandle;
    suiStartup: TStartupInfo;
    piProcess: TProcessInformation;
    pBuffer: array [0 .. CReadBuffer] of AnsiChar;
    dBuffer: array [0 .. CReadBuffer] of AnsiChar;
    dRead: DWord;
    dRunning: DWord;
begin
    saSecurity.nLength := SizeOf(TSecurityAttributes);
    saSecurity.bInheritHandle := True;
    saSecurity.lpSecurityDescriptor := nil;

    if CreatePipe(hRead, hWrite, @saSecurity, 0) then
    begin
        FillChar(suiStartup, SizeOf(TStartupInfo), #0);
        suiStartup.cb := SizeOf(TStartupInfo);
        suiStartup.hStdInput := hRead;
        suiStartup.hStdOutput := hWrite;
        suiStartup.hStdError := hWrite;
        suiStartup.dwFlags := STARTF_USESTDHANDLES or STARTF_USESHOWWINDOW;
        suiStartup.wShowWindow := SW_HIDE;

        if CreateProcess(nil, pChar(ACommand + ' ' + AParameters), @saSecurity, @saSecurity, True, NORMAL_PRIORITY_CLASS, nil, nil, suiStartup, piProcess) then
        begin
            repeat
                dRunning := WaitForSingleObject(piProcess.hProcess, 100);
                Application.ProcessMessages();
                repeat
                    dRead := 0;
                    ReadFile(hRead, pBuffer[0], CReadBuffer, dRead, nil);
                    pBuffer[dRead] := #0;

                    //OemToAnsi(pBuffer, pBuffer);
                    //Unicode support by Lars Fosdal
                    OemToCharA(pBuffer, dBuffer);
                    CallBack(dBuffer);
                until (dRead < CReadBuffer);
            until (dRunning <> WAIT_TIMEOUT);
            CloseHandle(piProcess.hProcess);
            CloseHandle(piProcess.hThread);
        end;
        CloseHandle(hRead);
        CloseHandle(hWrite);
    end;
end;

usage:

    CaptureConsoleOutput('java -version', '', 
                procedure(const Line: PAnsiChar) 
                begin
                    Memo1.Lines.Add(String(Line)); 
                end
     );

With all the help I got from Lars, I've released a version of the function for test purposes. You can download the app from here (Thundax Output).

Example:

Related links:

Building my own Delphi Physics Engine part VII

2011-06-21T21:40:00.003+02:00

After several weeks working on my TDPE I think I managed it to get the desired outcome and now the displayed items show more realistic features. In my previous versions, neither angular velocity nor mass was interacting in terms of moving an object and now, using different mathematical algorithms, the gravity and angular velocity are considered for every item. That means that as soon as a collision is originated, the resultant force will lean back or forward the object and it will be rotating or moving until the forces of the system reach a value close to zero.

This new approach has included a massive refactoring of the existing code to cope with this new behaviour that will deliver spectacular performances. During the following weeks I'm going to focus on the cutting tool as now I only have to extent the 4-edges collision object to n-edges. Once I have the n-edges collision object then I would be able to generate small chunks of it and each piece would have its own behaviour giving you the feeling that the object has really been broken.

As it's shown in the image, when most or more than a half of the object is out of the base (in blue), the red box should lean forward and fall according to the laws of physics (falling using rotation instead of falling straight how it was before in previous versions).

The following video will show the results of applying the latest algorithms to my Engine:

Enjoy the video!.

Get the latest executable here: ThundaxBallDemo v1.349.
If you want to drop a box, press 'd' and a new red box will fall.

Related links:

Delphi Compiler version directives

2011-06-15T22:11:00.016+02:00

Due to recent release of DelphiXE, here you can find a extended list of delphi compiler version directives that will help you to upgrade your projects. These are very helpful If you plan on writing Delphi code that should work with several version of the Delphi compiler.

{$IFDEF VER80}  - Delphi 1
{$IFDEF VER90}  - Delphi 2
{$IFDEF VER100} - Delphi 3
{$IFDEF VER120} - Delphi 4
{$IFDEF VER130} - Delphi 5
{$IFDEF VER140} - Delphi 6
{$IFDEF VER150} - Delphi 7
{$IFDEF VER160} - Delphi 8
{$IFDEF VER170} - Delphi 2005
{$IFDEF VER180} - Delphi 2006
{$IFDEF VER180} - Delphi 2007
{$IFDEF VER185} - Delphi 2007
{$IFDEF VER200} - Delphi 2009
{$IFDEF VER210} - Delphi 2010
{$IFDEF VER220} - Delphi XE

Related links:

A "moral operating system"

2011-06-14T23:49:00.011+02:00

Damon Horowitz calls for a "moral operating system". At TEDxSiliconValley, Damon Horowitz reviews the enormous new powers that technology gives us: to know more -- and more about each other -- than ever before. Drawing the audience into a philosophical discussion, Horowitz invites us to pay new attention to the basic philosophy -- the ethical principles -- behind the burst of invention remaking our world. Where's the moral operating system that allows us to make sense of it?

Source: TED.

Enjoy the video!.

OLE Automation with Delphi part II

2011-06-14T20:41:00.098+02:00

Going on with my previous post (OLE Automation with Delphi part I) where I was able to use the invocation of the "Word.Application" service using COM. In this post I am going to show you how to detect if a service is available using OLE Automation. First of all, I'm going to give you a brief overview of the windows Registry and where are all these COM class objects allocated, and then I will move forward to show the Delphi code that is used for this purpose.

COM class objects are identified by a CLSID key:

A CLSID is a globally unique identifier that identifies a COM class object. If your server or container allows linking to its embedded objects, you need to register a CLSID for each supported class of objects

source: msdn.

If we have installed Microsoft Word and look for "Word.Application" inside the registry, we will find the following information under \HKEY_CLASSES_ROOT\Word.Application:

This entry has the CLSID key = {000209FF-0000-0000-C000-000000000046}. This CLSID key has been set when the component was registered. We can look it up and check what executable or routine is invoking in the next key entry: HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID\{CLSID}.

As we can see, it shows the path of Microsoft word and with the option /Automation. Now that we know how to deal with the windows registry and how are set out CLSID keys, let's move on how to use this information with Delphi.

Check if the COM Class Object is registered:

To ensure that the service is available, we can use the OLE32 methods available through ActiveX and ComObj units.

unit Activex;

function CLSIDFromProgID;               external ole32 name 'CLSIDFromProgID';

Example of use:

uses
    ActiveX, ComObj;

procedure TForm1.CheckCLSIDClick(Sender: TObject);
var
    clsid: TCLSID;
    sCLSID: string;
    result: hResult;
begin
    // initialize COM
    CoInitialize(nil);

    // Get CLSID from Microsoft Word
    result := CLSIDFromProgID('Word.Application', clsid);
    sCLSID := GUIDToString(clsid);
    try
        OleCheck(result);
        ShowMessage('Class Word.Application recognized with CLSID ' + sCLSID);
    except
        on e: EOleSysError do
        begin
            ShowMessage('Class Word.Application not recognized CLSID ' + sCLSID);
        end;
    end;

    // deinitialize COM
    CoUninitialize;
end;

Invoking the COM Class Object:
Now that we are sure the COM Class is registered, we can cater the CoCreateInstance method to invoke the class with the proper context properties. dwClsContext is the context in which the code that manages the newly created object will run. The values are taken from the enumeration CLSCTX.
We can find this enumerators in the ActiveX unit with the following values:

{$EXTERNALSYM CLSCTX_INPROC_SERVER}
  CLSCTX_INPROC_SERVER     = 1;
  {$EXTERNALSYM CLSCTX_INPROC_HANDLER}
  CLSCTX_INPROC_HANDLER    = 2;
  {$EXTERNALSYM CLSCTX_LOCAL_SERVER}
  CLSCTX_LOCAL_SERVER      = 4;
  {$EXTERNALSYM CLSCTX_INPROC_SERVER16}
  CLSCTX_INPROC_SERVER16   = 8;
  {$EXTERNALSYM CLSCTX_REMOTE_SERVER}
  CLSCTX_REMOTE_SERVER     = $10;
  {$EXTERNALSYM CLSCTX_INPROC_HANDLER16}
  CLSCTX_INPROC_HANDLER16  = $20;
  {$EXTERNALSYM CLSCTX_INPROC_SERVERX86}
  CLSCTX_INPROC_SERVERX86  = $40;
  {$EXTERNALSYM CLSCTX_INPROC_HANDLERX86}
  CLSCTX_INPROC_HANDLERX86 = $80;

Example of use:
If we take a look again at the Registry picture above, we will notice that our COM Class uses a LOCAL_SERVER context, and that's the value that we will have to set in the API method.

This simple example will use the COM CLSID to invoke Microsoft Word and open it:

uses
    ActiveX, ComObj, Ole2;
{$R *.dfm}

procedure TForm1.InvokeCLSIDClick(Sender: TObject);
var
    clsid: TCLSID;
    sCLSID: string;
    result: hresult;
    localCLSCTX: Integer;
    IWordApp: IUnknown;
    dispIWord: IDispatch;
    AttrName: POleStr;
    paramArgument: VARIANTARG;
    disparam: DISPPARAMS;
    dispIDs: TDispID;
    did: TDispID;
begin
    // initialize COM
    CoInitialize(nil);
    localCLSCTX := CLSCTX_LOCAL_SERVER;
    try
        // Get CLSID from Microsoft Word
        result := CLSIDFromProgID('Word.Application', clsid);
        // sCLSID := GUIDToString(clsid);
        OleCheck(result);
        // create Microsoft Word instance
        result := CoCreateInstance(clsid, nil, localCLSCTX, IID_IUnknown, IWordApp);
        OleCheck(result);
        // get IDispatch interface of received object
        IWordApp.QueryInterface(IID_IDispatch, dispIWord);

        // Invoke Microsoft Word
        AttrName := 'Visible';
        paramArgument.vt := VT_BOOL;
        paramArgument.vbool := true;
        disparam.cArgs := 1;
        disparam.rgvarg := @paramArgument;
        dispIDs := DISPID_PROPERTYPUT;
        disparam.cNamedArgs := 1;
        disparam.rgdispidNamedArgs := @dispIDs;

        dispIWord.GetIDsOfNames(GUID_NULL, @AttrName, 1, LOCALE_SYSTEM_DEFAULT, @did);
        result := dispIWord.Invoke(did, GUID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, disparam, nil, nil, nil);
        OleCheck(result);
    except
        on e: EOleSysError do
        begin
            ShowMessage('Class Word.Application not found CLSID ' + sCLSID);
        end;
    end;
    // release unused objects
    dispIWord.Release;
    IWordApp.Release;
    // deinitialize COM
    CoUninitialize;
end;

Related links:

Delphi Certification program

2011-06-08T21:21:00.027+02:00

Embarcadero released yesterday the "Delphi Certification Program" where you can get one of the Delphi certificates to distinguish yourself from other professionals.

There are two certificates available:

- Delphi Developer Certification

- Delphi Master Developer Certification

For the Delphi developer certification, if you are a registered Delphi XE user or RAD Studio XE user, you are eligible to take the certification test free of charge. As Pawel Glowacki told us in the Embarcadero Live Event, these certificates are to certify your skills and to stand out from the rest. I have been looking forward to them, and now I'm eager to start taking the tests!.

The certification test covers the following areas of knowledge:

Delphi Fundamentals
Data types, variables, and Constants
Procedures and Functions
Classes and Objects
Object Interfaces
Generics, Attributes and Anonymous Method
Database Concepts
Standards Routines and I/O
Libraries and Packages
Memory Management
Exceptions and Assertions

Getting OS information with Delphi

2011-05-22T15:28:00.000+02:00

If you would like to know all about your OS, even for the latest versions like Windows 7 64 bits or Windows Server 2008 R2 there is a fantastic library for this purpose.

DelphiDabbler has a system information unit called dd-sysinfo which contains a lot of helping methods to retrieve OS information. It Contains various static classes, constant and type definitions and global variables for use in providing information about the computer and the operating system.

Related Links:

Particle Engine Simulator (P.E.S)

2011-05-02T00:06:00.001+02:00

I've just bumped into this fantastic Particle Engine Simulator (P.E.S) from Arash Partow and I'm sure you'll find really interesting his applications and insights into computational geometry and others. The PES, uses OpenGL as a display interface and you can get incredible structures like this:

I'm sure that you'll enjoy tinkering with it!.

Polygonal approximation to circle

2011-05-01T22:00:00.000+02:00

In order to be able to tackle the "cutting tool" for my TDPhysicsEngine, I need to work with polygon approximations instead of a full drawn circle using the Canvas.Ellipse Delphi function. To achieve this in the view layer is as easy as using Canvas.Polygon function to draw a polygon using a list of calculated points. To calculate the points, we need to divide the circle in discrete chunks and then let the function draw the lines between points. The main reason what I'm doing that is to be sure that I can cut up a polygon and then use the resulting pieces as new objects that will behave as independent objects:

The function below will help you to draw the polygon:

procedure GDIRenderer.CircleApproximation(xcenter, ycenter, Radius, Rotate: Double; style: TStyle);
var
    PArrow: array [1 .. points] of TPoint;
    i: integer;
    theta: Double;
    x, y : double;
    beforeBrushColor, beforePenColor: TColor;
    beforePenWidth: integer;
begin
    beforeBrushColor := FCanvas.Brush.color;
    beforePenColor := FCanvas.Pen.color;
    beforePenWidth := FCanvas.Pen.Width;

    FCanvas.Pen.color := style.PenColor;
    FCanvas.Pen.Width := style.penWidth;
    FCanvas.Brush.color := style.BrushColor;

    for i := 1 to points do
    begin
        theta := Pi * ((i-1)/(points/2));
        x := xcenter + (Radius* Cos(theta));
        y := ycenter + (Radius* Sin(theta));
        PArrow[i] := Point(Round(x), Round(y));
    end;
    FCanvas.Polygon(PArrow);

    FCanvas.Brush.color := beforeBrushColor;
    FCanvas.Pen.color := beforePenColor;
    FCanvas.Pen.Width := beforePenWidth;
end;

The big difficulty here is to model this behaviour in the model. I need to work more and think about it because for the moment it's adjusted as a sphere and it's not a good approximation.

Building my own Delphi Physics Engine part VI

2011-05-01T03:13:00.001+02:00

I've been quite busy lately and in this article I've focused on the collision container. As you'll see in the following images and video, the spheres will be bouncing around, colliding with one another and with the surfaces inside the container that holds the entire motion of the system. With a simple tweak, the physics engine is able to display the unseen forces when objects are being "kicked". The key feature is that I want to show the resultant vectors that are involved in the collisions and the movement so the observant would have an idea of what's happening inside the model and which forces are being generated.

In the image below, you'll see the resultant force when the sphere has collided with the surface beneath. This leads me to the description of the Elastic collision equations.

The following image shows all the vectors involved in the collision:

And the video showing the dynamics:

You can download from here the last version of the application: ThundaxBallsDemo v1.172 that is digitally signed (once the file is downloaded, right click, properties and go to the certificate and install it) to increase security. To add more spheres press 'a' and 's'. To cut one of the bridges press 'z' and play!.

I also have created the new logo for the Engine, let me know if you like it!.

In few months the library would be ready here:

http://code.google.com/p/thundax-delphi-physics-engine/

Thanks for reading! and do not hesitate to leave any comment!.

Solid maths is the programmer’s friend.

Jordi

Related links:

NIS 2010 SONAR raised when running executables compiled with Delphi 2010

2011-04-25T02:00:00.001+02:00

Going on with my previous post (Signing your Delphi applications with Microsoft Signtool) in this post I'll explain different solutions to avoid false positives by the Antivirus. I've recently got an alert from my NIS 2010 (Norton Internet Security) SONAR indicating that my application contains a HackTool and it has been processed and eliminated by SONAR (I'm trying to run one of my applications and now is a high-risk program and should be deleted every time I try to run it):

Even though it socks, you need to go through the NIS and configure it using the instructions from here.

1. Executable files created by compilers etc on development machines are deleted

We have identified the issue and are making incremental changes to fix the problem. Please ensure that you have the latest NIS patch installed 17.1.0.19 as that should minimize the occurrence of the issue.

In addition to this, developers should exclude dev directories from security scans using the following steps:

On the main UI panel, under Computer click Settings. This will bring up the Settings dialog box.
Under Scan Exclusions click Configure. This will display the Scan Exclusions dialogue box.
Under the lower-half of the screen under Auto-Protect Exclusions click the Add button. This will bring up a dialogue to add a new item.
Add the folder you want to exclude from SONAR.

source: Norton community.

If you are certain that SONAR has incorrectly quarantined a file, you may restore this file to its original location by selecting the appropriate entry in the Quarantine Log and clicking Options. This will display the Security Risk Details dialog:

Click Restore this file. This will show the Quarantine Restore dialog. Ensure that the Exclude this risk from future scans is checked. The file will be restored to its original location and will no longer be detected by SONAR. According to Symantec this is unfortunately a known problem and they are working on a fix for it. From now on the best thing you can do is to set the scan exclusions in the settings, with this, those folders will not be scanned and the files will not be false-detected.

It's important to update the Antivirus to the latest version because most of these issues are already solved and there is no need on doing this.

Other important thing is to bear in mind the digital signature for our applications. If our executables are digitally signed you won't have the false positive problem with the AV because the application is trusted. Please, go on with the related links section to dig more with this issue and do not hesitate to comment if you have any doubt.

NIS version: 17.8.0.5

Related links:

Signing your Delphi applications with Microsoft Signtool

2011-04-23T01:14:00.002+02:00

Today I'm coming with an interesting post about signing your Delphi applications (win32) with Microsoft Signtool. The SignTool tool is a command-line tool that digitally signs files, verifies signatures in files, or time stamps files. The tool is installed in the \Bin folder of the Microsoft Windows Software Development Kit (SDK) installation path. SignTool is available as part of the Windows SDK, which you can download from here.

With few steps I'll show you how to create PKCS#12 certificate with OpenSSL for windows and how to import this certificate into your applications. In most occasions we should use the certificate as a means of identifying the author of an application and establishing trust relationships between applications.

Creating a PKCS#12 certificate with OpenSSL:

Once I have installed OpenSSL on your machine, we need to run the following commands to create the certificate. To create a PKCS#12 certificate, you’ll need a private key and a certificate, so first of all, let´s create the certificate and the private key:

# create a file containing key and self-signed certificate

openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout mycert.pem -out mycert.pem

Now we are ready to generate the .pfx file (.PFX file (Personal Information Exchange format) is the file containing both a public (.cer file) and a private (.pvk file) keys) with myCert.pem:

# export mycert.pem as PKCS#12 file, mycert.pfx

openssl pkcs12 -export -out mycert.pfx -in mycert.pem -name "My Certificate"

You'll be asked to enter a password for your certificate.

Importing the certificate with Singtool:

Now copy the mycert.pfx file into the folder where your executable is placed and run the following command with Signtool:

Signtool sign /f mycert.pfx /p password thundaxballsdemo.exe

Now if we check our application it will be digitally signed with our certificate:

Then you can install this certificate into the "windows trusted certification store".

Related links:

Delphi XE team working

2011-04-22T21:37:00.000+02:00

Here you can see the latest videos from Danysoft about team working with Delphi XE by Luis Alfonso Rey. The videos are in Spanish and there have released the first 2 chapters and it is expected a series of 5 chapters.

Enjoy the videos!.

Assertion failure ..\win32src\thread32.cpp at line 434

2011-04-05T22:42:00.000+02:00

For the ones who are using Delphi 2009 under Windows 7 (64-bits), this error will show up during the debugging of your applications. This just happened to me today and I found a really interesting solution on Embarcadero's Forums. This just happened to me few days ago and I thought it was normal because of the OS, but then I realised that something was going wrong and every minute I got that annoying message leaving my applications non-functional and with the problem of restarting the Delphi IDE again.The solution provided is quite easy and I can guarantee you that it works!.

First of all, you need an hexadecimal editor. I used mh-nexus, an open source version that you can get from here. Then the steps for solving the issue are the following ones:

1. Close Delphi

2. Locate bordbk120N.dll (C:\Program Files (x86)\CodeGear\RAD Studio\6.0\bin)

3. Make a backup of the library (just in case).

4. Open bordbk120N.dll with mh-nexus and locate the hex values: “01 00 48 74 47 80 3D”

5. Replace “74” with “EB”and save the changes.

6. Restart Delphi and the error message should be gone.

Related links:

Google's driverless car

2011-04-03T21:34:00.002+02:00

Sebastian Thrun helped build Google's amazing driverless car, powered by a very personal quest to save lives and reduce traffic accidents. Jawdropping video shows the DARPA Challenge-winning car motoring through busy city traffic with no one behind the wheel, and dramatic test drive footage from TED2011 demonstrates how fast the thing can really go.

Source: TED

Google's car in action:

Silicon-based comedy

2011-03-11T12:07:00.000+01:00

Heather Knight introduces Data, a robotic stand-up comedian that does much more than rattle off one-liners -- it gathers audience feedback (using software co-developed with Scott Satkin and Varun Ramakrishna at CMU) and tunes its act as the crowd responds. Is this thing on? Source: TED.

Today is my last day at AEtech

2011-03-11T01:52:00.001+01:00

After 8 years of working with the most talented group of people I have ever met, I have decided to turn over a new leaf, working for a dynamic multinational delivering financial solutions Software in the UK. Today is my last day at AEtech.

I can’t say enough good things about the friends I have made and the talented people who have taught me so much. When I started here I never could have guessed that I would be creating cutting-edge software for the Industrial Automation sector. The experience working in multidisciplinary teams with very skilled Engineers is something to be a reminder of the very well done work.

Leaving AETech is different than any other job I have left. Joining AETech in 2003 was an easy decision and more strange was to have found success there. I felt like home, and even though it sounds stranger, AETech is the first place I have worked where I feel I am part of the company instead of working for the company.

I am confident that this new step in my career will bring new outcomes. The time will tell. Meanwhile, I will go on blogging, telling you my bests and being in touch.

Many thanks to all of you who have filled with joy the past eight years. I am looking forward to what comes next and don't forget to follow me!.

-Jordi
London, UK ~ 2011

All Boot disk

2011-03-04T13:23:00.000+01:00

Today one of my colleagues showed me this great site where you can download all the boot disk images from MSDOS 3.3 to Windows XP. Then you can use these images to start up a virtual machine. These ISO CD-ROM images have been created to allow you to boot your computer from a CD for the purpose of repairing various issues. The CD images are an exact copy of the boot diskette images. There is no advantage to using these ISO images over a diskette image. Some newer computers do not have a floppy drive installed, so these images allow for compatibility of newer machines.

Great job!.

Building my own Delphi Physics Engine part V

2011-02-05T02:13:00.005+01:00

Today I felt inspired (after parts I, II, III and IV) and I tried to do a cloth simulation in the Thundax Physics Engine. There are a lot of things to do, but at least I can start simulating different components very fast without too much implementation. I saw one amazing implementation of the "processing cloth" in JRC313.com. Even though the applet is written in JavaScript, the performance is quite impressive and it's a nice work.

but, How it works?

"Every line in the cloth simulation is technically called a constraint and every point is a point mass (an object with no dimension, just location and mass). All the constraints do is control the distance between each point mass. If two points move too far apart, it will pull them closer. If two points are too close together, it will push them apart. The cloth is really then just a collection of constraints and point masses in a never ending struggle."

Andrew Hoyer.

using Relaxation in simple linear systems:

In the case of this cloth simulation all I needed to do was try satisfying the constraints as fast as I can. For things like simple rope simulations it may be necessary to satisfy several times (maybe 4 or 5). The more times you satisfy, the more rigid the constraint becomes. This process is known as relaxation and is amazing!. The displacement will then be of the form y(t) = Ae − t / Tcos(μt − δ). The constant T is called the relaxation time of the system and the constant μ is the quasi-frequency. (Wikipedia).

In the following videos you'll be able to check the performance of the simulated cloth. I took advantage of my previous bridge (spring + particles) and I've concatenated a series of bridges to set up a virtual cloth. Now the movement is quite astonishing:

In the second video I'm showing one of the new features for the next release: "the cutting tool". I still need to think about it, but for simple objects it could be simple to cut an object and see its reaction, like in the next video:

You can download the last version of the executable file here: thundax Balls demo v1.52. And maybe in a near future you'll be able to see something similar to the Puzzler for iPhone.

Other interesting video about physics and games is Crayon Physics from Petri Purho:

Crayon Physics Deluxe from Petri Purho on Vimeo.

I hope you enjoy the videos!

Related Links:

Building my own Delphi Physics Engine part IV

2011-02-04T00:19:00.002+01:00

I'm still working on my solution, but I can advance you a preview of the smoothness of the application. I have improved the bridge particle and its interaction with external events. I'm working on a TStyle class that will enhance the GDIRender allowing the different particles to have a custom style on the screen and refactor all the classes to improve the scalability and interoperability of the Engine. If you are interested on testing the application, you can get the latest version of it from here: Thundax Ball Demo v1.1. In this version you will notice the improved interaction with the mouse and the circle particles. I have to work out a solution for the other particles, but I'm still designing the whole product and I need to test some of the features that I want to release in the next version. Once the version is ready, I will upload it on Sourceforge just in case you feel the urge to play with it!.

Here you can see the new performance:

Related Links:

Building my own Delphi Physics Engine part III

2011-02-02T23:57:00.004+01:00

Now I'm working on the interactive part (Controller). Since now I only have developed the model and the view section of the MVC pattern and I'm implementing and testing the controller part. The main problem is that the Engine is quite simple to implement and use until the visual control appears. Now I have to take into account all the events that come from the outside (mouse, keyboard) and add subscribers to the object particles. With the design that I've implemented it is easy to make extensible the model and the view section because the Engine follows the "low cohesion high coupling" principle. My sister challenged me by trying to do something similar to the ruicode project, where its ofxRuiPhysics2d project (Simple 2d physics addon for OF (OpenFrameworks) using the Verlet integrator where it includes particles, collisions and springs) is quite astonishing. Here you can see one of its videos:

And here is my project: Thundax balls demo.exe, a Delphi win32 application that will start a demo with balls, springs and collisions. In the following videos you'll see different performances of my tests. In the first video I'm trying to simulate the environment with all the forces playing at the same time, and in the second video you can see myself using the mouse interacting with the balls and the springs.

I hope you enjoy the videos!.

Related links:

Related frameworks:

It's amazing the large amount of physics Engine that are available on the net. I just google the words "Physics Engine" and here are the results:

Javascript, C, and Java Frameworks:

ActionScript Frameworks:

APE Framework.

3D and Realistic Frameworks:

Logoa Multiphysics.

Netscape Mozilla Documentary 1998 - 2000 ProJect Code Rush

2011-02-01T13:50:00.002+01:00

Now you can see the very inspiring and must-see film from Code Rush.

The year is early 1998, at the height of dot-com era, and a small team of Netscape code writers frantically works to reconstruct the company's Internet browser. In doing so they will rewrite the rules of software development by giving away the recipe for its browser in exchange for integrating improvements created by outside unpaid developers. The fate of the entire company may well rest on their shoulders. Broadcast on PBS, the film capture the human and technological dramas that unfold in the collision between science, engineering, code, and commerce.

Source: Code Rush.

DIASPORA* the new distributed social networking service

2011-01-17T22:30:00.001+01:00

Diaspora (stylized DIASPORA*) is a free personal web server that implements a distributed social networking service. The project is currently under development by Dan Grippi, Maxwell Salzberg, Raphael Sofaer, and Ilya Zhitomirskiy, students at New York University's Courant Institute of Mathematical Sciences.

The group was inspired to create Diaspora by a February 5, 2010 speech from Columbia University law professor Eben Moglen to the Internet Society's New York Chapter, "Freedom in the Cloud", in which Moglen described centralized social networks as "spying for free." In a New York Times interview Salzberg said "When you give up that data, you’re giving it up forever ... The value they give us is negligible in the scale of what they are doing, and what we are giving up is all of our privacy."

The project was announced on April 24, 2010 on Kickstarter and reached its initial $10,000 fund-raising goal in 12 days. In the weeks that followed, it raised $200,641.84 from 6479 backers, making it the second most successful Kickstarter project to date.

source: wikipedia.

Do you think that facebook will tremble with this new social service?

Depth of field calculator

2011-01-16T21:07:00.002+01:00

This year I'm going to start talking about one of my passions: Photography. And for starting, here you can get one of my last applications: Thundax Depth of Field Calculator. With this Delphi win32 front-end application you'll be able to calculate the Depth of field (the portion of a scene that appears sharp in the image) measurements needed in photography. You need to select the CoC (Circles of Confusion) in microns from the sidebar (there is a little sheet with the normal values for different types of cameras), the focal length from the choices, and the lens aperture from the choices. Enter the subject distance in meters from the lens and the calculated values are returned for various other designations of subject distance as well as the near limit of acuity, far limit of acuity, and the total depth of field, all in both meters and feet, accurate and rounded. The calculations are based on the very well known on-line DoF javascript calculator.

In my application you can see the difference of using different apertures (F numbers) while taking the photo. In the example you can see that the distance is the same, but the DoF grows. The aperture is getting smaller and smaller, and the shutter speed is getting longer to compensate. The distance and aperture both play a big role in depth of field. You you want to play with it, for example: for a short depth of field (blurry background) get close and use a lower f-stop. And for a long depth of field (clear all the way through) get farther away and use a higher f-stop. The following example will help you to understand better the DoF:

Picture from: Photo Basics.

The different calculations are the following ones:

procedure TDoF.Calc(Sender: TObject);
var
    focal: integer;
    aperture: double;
    CoC: double;
    Hyperfocal: double;
    distance: double;
    NearF, FarF, doftotal: double;
begin
    distance := StrToFloat(Edit2.Text) * 1000 * 0.3048;
    focal := getFocal(ComboBox1.Text);
    aperture := getAperture(ComboBox2.Text);
    CoC := StrToFloat(Edit1.Text);
    photovalues.Values['Subject distance (inches)'] := FloatToStr(StrToFloat(Edit2.Text) * 12) + ' in';
    photovalues.Values['Subject distance (meters)'] := FloatToStr(StrToFloat(Edit2.Text) * 0.3048) + ' m';
    photovalues.Values['Subject distance (millimeters)'] := FloatToStr(StrToFloat(Edit2.Text) * 0.3048 * 1000) + ' mm';
    Hyperfocal := 0;
    if (aperture * CoC) > 0 then
        Hyperfocal := Sqr(focal) / (aperture * CoC);
    photovalues.Values['Hyperfocal distance for this lens/aperture combination (meters)'] := FloatToStr(Hyperfocal) + ' m';
    photovalues.Values['Hyperfocal rounded distance for this lens/aperture combination (meters)'] := FormatFloat(f, Hyperfocal) + ' m';
    photovalues.Values['Hyperfocal distance for this lens/aperture combination (ft)'] := FloatToStr(Hyperfocal * feet) + ' ft';
    photovalues.Values['Hyperfocal rounded distance for this lens/aperture combination (ft)'] := FormatFloat(f, Round(Hyperfocal * feet)) + ' ft';
    NearF := ((Hyperfocal * 1000 * distance) / ((Hyperfocal * 1000) + (distance - focal))) / 1000;
    photovalues.Values['Near limit of acceptable sharpness (meters)'] := FloatToStr(NearF) + ' m';
    photovalues.Values['Rounded near limit of acceptable sharpness (meters)'] := FormatFloat(f, Round(NearF)) + ' m';
    photovalues.Values['Near limit of acceptable sharpness (ft)'] := FloatToStr(NearF * feet) + ' ft';
    photovalues.Values['Rounded near limit of acceptable sharpness (ft)'] := FormatFloat(f, Round(NearF * feet)) + ' ft';
    FarF := ((Hyperfocal * 1000 * distance) / ((Hyperfocal * 1000) - (distance - focal)) / 1000);
    if FarF < 0 then
    begin
        photovalues.Values['Far limit of acceptable sharpness (meters)'] := 'Infinity';
        photovalues.Values['Rounded far limit of acceptable sharpness (meters)'] := 'Infinity';
        photovalues.Values['Far limit of acceptable sharpness (ft)'] := 'Infinity';
        photovalues.Values['Rounded far limit of acceptable sharpness (ft)'] := 'Infinity';
    end
    else
    begin
        photovalues.Values['Far limit of acceptable sharpness (meters)'] := FloatToStr(FarF) + ' m';
        photovalues.Values['Rounded far limit of acceptable sharpness (meters)'] := FormatFloat(f, Round(FarF)) + ' m';
        photovalues.Values['Far limit of acceptable sharpness (ft)'] := FloatToStr(FarF * feet) + ' ft';
        photovalues.Values['Rounded far limit of acceptable sharpness (ft)'] := FormatFloat(f, Round(FarF * feet)) + ' ft';
    end;
    doftotal := Round(FarF - NearF);
    if doftotal < 0 then
    begin
        photovalues.Values['Total depth of field (meters)'] := 'Infinity';
        photovalues.Values['Total rounded depth of field (meters)'] := 'Infinity';
        photovalues.Values['Total depth of field (ft)'] := 'Infinity';
        photovalues.Values['Total rounded depth of field (ft)'] := 'Infinity';
    end
    else if (doftotal >= 0) and (doftotal < 0.001) then
    begin
        photovalues.Values['Total depth of field (meters)'] := '> 1 mm';
        photovalues.Values['Total rounded depth of field (meters)'] := '> 1 mm';
        photovalues.Values['Total depth of field (ft)'] := '> 0.0393 in';
        photovalues.Values['Total rounded depth of field (ft)'] := '> 0.0393 in';
    end
    else
    begin
        photovalues.Values['Total depth of field (meters)'] := FloatToStr(doftotal) + ' m';
        photovalues.Values['Total rounded depth of field (meters)'] := FormatFloat(f, Round(doftotal)) + ' m';
        photovalues.Values['Total depth of field (ft)'] := FloatToStr(doftotal * feet) + ' ft';
        photovalues.Values['Total rounded depth of field (ft)'] := FormatFloat(f, Round(doftotal * feet)) + ' ft';
    end;
end;

Tell me if it's useful to you and if you need any other calculations.
PS: The program is free for non-commercial use.

Related links:

Technologies of the past

2011-01-13T13:26:00.001+01:00

This video brings me back very good memories, where there were still floppy disks and other storage devices. I still can remember how fragile was the 5 1/4-inch floppy disk and my first installation of the MSDos 6.22 with a bunch of disks. In a short time they won't be remembered. In the video shown there are few children in front of various relics from 20 years ago and they are asked what they were for.

Comparing Methods using Generics

2011-01-11T13:48:00.002+01:00

This is my first post of 2011. I will hopefully be doing more posts this year. These will include my work, tutorials, snippets of code and what I find on the web. Hopefully this year will be a good one, with new projects, more ideas and more motivation.
In Delphi 2009 appeared the Generics (containers-of-type-T) in the Delphi programming language. I have been playing with them in Delphi 2010 and here you can see my results. The new library is quite easy to use and with the help of this libraries we can enhance our code. We can also use the Anonymous methods and call the function "inline" in the sort method.

Using the Generics.defaults and Generics.Collections we can build new container or comparer classes and pass to them the type-T (Integer, String, TObject, etc.).

Default comparer:

This example will create an Integer comparer and it will use a TIntegerList to sort its values:

unit uComparing;

interface

uses
    generics.defaults, generics.collections;

type
    TIntegerComparer = class(TComparer<Integer>);
    TIntegerList = class(TList<Integer>);

implementation

end.

usage:

procedure TForm1.Button1Click(Sender: TObject);
var
    integerList : TIntegerList;
    i: Integer;
begin
    integerList := TIntegerList.Create(TIntegerComparer.default);
    for i := 0 to memo1.Lines.count - 1 do
        integerList.Add(StrToInt(Memo1.Lines[i]));
    integerList.Sort;
    for i := 0 to integerList.count - 1 do
        Memo2.Lines.Add(IntToStr(integerList[i]));
end;

Custom Comparer:

The custom comparer will use a comparer method to sort the values in a descendant way.

unit uComparing;

interface

uses
    generics.defaults, generics.collections;

type
    TIntegerComparer = class(TComparer<Integer>)
    public
        function Compare(const Left, Right : Integer) : Integer; override;
    end;

    TIntegerList = class(TList<Integer>);


implementation

{ TIntegerComparer }

function TIntegerComparer.Compare(const Left, Right: Integer): Integer;
begin
    result := Right - Left;
end;

end.

usage:

procedure TForm1.Button1Click(Sender: TObject);
var
    integerList : TIntegerList;
    i: Integer;
begin
    integerList := TIntegerList.Create(TIntegerComparer.create);
    for i := 0 to memo1.Lines.count - 1 do
        integerList.Add(StrToInt(Memo1.Lines[i]));
    integerList.Sort;
    for i := 0 to integerList.count - 1 do
        Memo2.Lines.Add(IntToStr(integerList[i]));
end;

Anonymous Comparer:

The Anonymous comparer is created inside the sort method:

procedure TForm1.Button1Click(Sender: TObject);
var
    integerList : TIntegerList;
    i: Integer;
begin
    integerList := TIntegerList.Create();
    for i := 0 to memo1.Lines.count - 1 do
        integerList.Add(StrToInt(Memo1.Lines[i]));
    integerList.Sort(TIntegerComparer.Construct(
       function (const Left , Right : integer): integer
       begin
         result := Left - Right;
       end
       ));
    for i := 0 to integerList.count - 1 do
        Memo2.Lines.Add(IntToStr(integerList[i]));
end;

Related links:

PythonCE for Windows CE

2010-12-29T14:07:00.002+01:00

I'm playing with the PythonCE library for Windows CE devices, and I'm building a little graphic application (GUI) with it just to be sure that the chosen technology is the appropriate. I've always used the embedded VC++ and VB and I think it's time to move on and try new things. I've tested this library on my DELL Axim x50.

Firstly, you have to download the PythonCE library for your device. Download PythonCESetup.exe from sourceforge. Once downloaded, you have to execute the PythonCESetup.exe and it automatically will install the PythonCE on your WindowsCE device.

Once done, your pocket device will have installed the python command line:

Then, for executing graphical applications, we need to install the TKinter library. You'll succeed if you follow the next instructions to install the TKinter library on your pocket device:

Using TKinter for Windows CE:

To use Tkinter you have to download this additional software Tkinter.zip and unpack it on your PDA.

The following archive contains 2 folders: "Windows" and "tcl8.4.3". Put all the files in "Windows" in the "Windows" folder of your PDA.
Create a "lib" folder in the "Program files" folder of your PDA.
Inside the "tcl8.4.3" folder in your archive you will find two folders: "library" and "tk8.4". Copy the "tk8.4" folder into the "lib" folder you just created on your PDA.
Copy all the files in "library" into a folder named "tcl8.4" you will create inside the same "lib" folder.

If you succeed, you can execute the next example and try it on our device:

from Tkinter import * 

def onCanvasClick(event):                  
    print 'Got canvas click', event.x, event.y, event.widget

root = Tk()
root.title('MyAPP')
canv = Canvas(root, width=100, height=100)
img = PhotoImage(file='\\My Documents\\logo.gif')
canv.create_image(240,250, image=img, anchor=CENTER)
obj1 = canv.create_text(50, 30, fill="red", text='text1')
obj2 = canv.create_text(50, 70, fill="red", text='text2')
widget = Label(root, text='This is a Label')
widget.config(bg='black', fg='yellow')             
widget.pack(expand=YES, fill=BOTH)
canv.bind('<Double-1>', onCanvasClick)                  
canv.pack()
root.mainloop()

Output Example:

Related links:

Python Examples.

Building today the schools of tomorrow

2010-12-21T13:37:00.008+01:00

This post is dedicated to Richard Gerver who attended the Global Education Forum held in Madrid this year, where different topics related to education were discussed. This video is the last one published in Redes about building today the schools of tomorrow (in Spanish).

"In The XXI century the only thing we know for sure is that it's going to be very different. Now the industry needs more imagination, more creativity, more skilled workers to work together, with a different mentality, a mentality more open to suggestions from others on their team".

Philip Hudson

Director SEK Catalonia

More videos:

Changing education paradigms

2010-12-21T00:29:00.001+01:00

This post is dedicated to Ken Robinson an its "Changing education paradigms". "Creativity expert Sir Ken Robinson challenges the way we're educating our children. He champions a radical rethink of our school systems, to cultivate creativity and acknowledge multiple types of intelligence".

Related videos:

Enjoy the video!.

Piecewise function plotter

2010-12-20T23:50:00.015+01:00

I've been working lately on a front-end application to draw and generate the piecewise-defined functions that are mainly used for the input fuzzy sets. This application is developed with Delphi and for generating the outputs it uses the GNUplot and the LateX equation editor. The application is called Thundax Piecewise v1.1 and you can download it from here. This win32 installation package contains the required files to work with the GNUplot. This software is for academical purposes and with it you can define the piecewise-defined functions without wasting your time trying to draw the graphs and the equations.

Using the application:

If you want to get the equations from the previous image, you only need to add the points (x,y) (defined as 4 points per graph), add the equation description, the range and the number of samples:

The description of the parameters:

Points per graph: default value = 4. Number of points that are used to define the function:

Range-x: Default value [0:30]. Range to be displayed at x-axis.

Range-y: Default value [-0.1:1.1]. Range to be displayed at y-axis.

Samples: default value = 1. Number of samples for the x-axis. In a range from 1 to 10 with a sample of 1 it will show all the numbers.

Once everything is done, you just need to let the application generate the graph output automatically using GNUPlot (If the function is not plotted, check the script and execute it into the GNUplot command prompt):

And then copy-and paste the output script to Latex editor and get the piecewise function for each one:

The only thing the applications does, is to parse the input data and transform it as scripts for the GNUplot and Latex. The conversion is pretty simple and the scripts examples are like these:

GNUPlot Script example:

cold(x)=(x<=40? 0: cold2(x))
cold2(x)=(x<=40 & x > 40? 1: cold3(x))
cold3(x)=(x<=50 & x > 40? -0.1*x + 5: cold4(x))
cold4(x)=(x<=50 & x > 50? 1: cold5(x))
cold5(x)=(x>50? 0:0)
cool(x)=(x<=40? 0: cool2(x))
cool2(x)=(x<=55 & x > 40? 0.066667*x  -2.666667: cool3(x))
cool3(x)=(x<=55 & x > 55? 1: cool4(x))
cool4(x)=(x<=65 & x > 55? -0.1*x + 6.5: cool5(x))
cool5(x)=(x>65? 0:0)
justright(x)=(x<=60? 0: justright2(x))
justright2(x)=(x<=65 & x > 60? 0.2*x  -12: justright3(x))
justright3(x)=(x<=65 & x > 65? 1: justright4(x))
justright4(x)=(x<=70 & x > 65? -0.2*x + 14: justright5(x))
justright5(x)=(x>70? 0:0)
warm(x)=(x<=65? 0: warm2(x))
warm2(x)=(x<=75 & x > 65? 0.1*x  -6.5: warm3(x))
warm3(x)=(x<=75 & x > 75? 1: warm4(x))
warm4(x)=(x<=85 & x > 75? -0.1*x + 8.5: warm5(x))
warm5(x)=(x>85? 0:0)
hot(x)=(x<=80? 0: hot2(x))
hot2(x)=(x<=90 & x > 80? 0.1*x  -8: hot3(x))
hot3(x)=(x<=90 & x > 90? 1: hot4(x))
hot4(x)=(x<=90 & x > 90? 1: hot5(x))
hot5(x)=(x>90? 0:0)
set yrange[-0.1:1.1]
set xtics 0, 15
set grid
set samples 1001
bind Close "exit gnuplot"
plot [40:90] cold(x) ,cool(x) ,justright(x) ,warm(x) ,hot(x)

Notice that we use the function bind Close "exit gnuplot" to bind the exit of the application once the user has closed the plotted graph. (And I think this function is available since version 4.4).
Latex Script example:

cold(x)=\begin{Bmatrix}{0}&\mbox{if}& x\leq40\\{1}&\mbox{if}& 40< x \leq40\\{-0.1*x + 5}&\mbox{if}& 40< x \leq50\\{1}&\mbox{if}& 50< x \leq50\\{0}&\mbox{if}& x > 50\end{matrix}\\
cool(x)=\begin{Bmatrix}{0}&\mbox{if}& x\leq40\\{0.066667*x  -2.666667}&\mbox{if}& 40< x \leq55\\{1}&\mbox{if}& 55< x \leq55\\{-0.1*x + 6.5}&\mbox{if}& 55< x \leq65\\{0}&\mbox{if}& x > 65\end{matrix}\\
justright(x)=\begin{Bmatrix}{0}&\mbox{if}& x\leq60\\{0.2*x  -12}&\mbox{if}& 60< x \leq65\\{1}&\mbox{if}& 65< x \leq65\\{-0.2*x + 14}&\mbox{if}& 65< x \leq70\\{0}&\mbox{if}& x > 70\end{matrix}\\
warm(x)=\begin{Bmatrix}{0}&\mbox{if}& x\leq65\\{0.1*x  -6.5}&\mbox{if}& 65< x \leq75\\{1}&\mbox{if}& 75< x \leq75\\{-0.1*x + 8.5}&\mbox{if}& 75< x \leq85\\{0}&\mbox{if}& x > 85\end{matrix}\\
hot(x)=\begin{Bmatrix}{0}&\mbox{if}& x\leq80\\{0.1*x  -8}&\mbox{if}& 80< x \leq90\\{1}&\mbox{if}& 90< x \leq90\\{1}&\mbox{if}& 90< x \leq90\\{0}&\mbox{if}& x > 90\end{matrix}\\

I'm still working on this project and for the next milestone I'll try to add the Weighted average method to calc the area of the graph and the ability to save the data of the project.

Related links:

Building my own Delphi Physics Engine part II

2010-12-10T00:13:00.004+01:00

Going on with my DPE (Delphi Physics Engine) I've improved my old version (Building my own Delphi Physics Engine Part I) of the Jansen Mechanism by creating the rest of the legs displaced 120º each one. I've been fixing the damping level of the framework just to be sure that the movements are as realistic as possible. In this version, the movement is quite realistic and we can trace the movement of the leg by plotting the kinetic analysis:

A physics engine is computer software that provides an approximate simulation of certain simple physical systems, such as rigid body dynamics (including collision detection), soft body dynamics, and fluid dynamics, of use in the domains of computer graphics, video games and film. Their main uses are in video games (typically as middleware), in which case the simulations are in real-time. The term is sometimes used more generally to describe any software system for simulating physical phenomena, such as high-performance scientific simulation. Wikipedia.

Here you can see the CGI result with the hanging version of the Jansen mechanism with one leg and with three legs:

And the final version with the development of the Jansen machine. In this version (Thundax Test Forces v2.exe) if you press 'p' the machine will start walking and if you want to change direction, you only need to press the 'z'.

What's next?. Now I'll try to reproduce different physics systems and show how it goes. The Easy Java Simulations tool, offers a wide range of examples that I would like to try.
Enjoy the learning!.

Related Links:

Building my own Delphi Physics Engine part I

2010-12-03T00:51:00.005+01:00

These days I've been working on my own Delphi Physics Engine based on the very well known APE (ActionScript Physics Engine) with some improvements that will help developers to build models very fast. In this beta version I've done the following improvements:

Enhance user performance.
Drastic reduction of Memory leaks.
Improve the interoperability between objects.
Improve maths algorithms to collision detection.
Use the VLO GDI Render to perform the drawing of the shapes.

In this first insight into the Engine, I'm going to show you a model of the Jansen mechanism, a kinetic sculpture that can move with the help of several pairs of legs.

I've built my own model taking advantage of the physic engine and imagination!.

Here you can see my own model:

The movement is still not very well performed, but it's due to the measures of the different parts of the sculpture. As for the calculation points, I've used the next template:

You can download the demo project from here (Thundax Test Forces). To play with the application, you only need to press 'z' to start the kinetic sculpture, and as for the objects below the sculpture, press 'd' and you'll force a collision between two objects.

The next days I'll be improving the model (you can see the kinetic analysis that is plotted below the sculpture) and adding the extra foot to perform a fully movement.

Enjoy the learning!.

Related links:

DelphiDoom for Delphi fans

2010-11-30T13:18:00.002+01:00

I've recently found Delphi Doom, an adaptation from the original UNIX Doom C source code to Delphi. The project was finished in 2005 but the latest deploy was released on 3 March 2008 (Version: 1.0.2 build 383). I've been tinkering with it and it's been great!. It cast me back when I was young, trying to pass all the levels by killing some hideous and very nasty monsters. This Application is a WIN32 port of the famous Doom game created by ID Software. The main difference of DelphiDoom is that is written in the Pascal programming language. The source code has been translated from C to Pascal. In addition many new features have been added to to expand the old engine features and take advantage of capabilities of modern computers. Remember that you need the IWAD file just for being able to pay. The IWAD file is the file which contains all of the game data for a complete game.

Enjoy the game!.

2d Physics with Delphi

2010-11-18T19:00:00.001+01:00

I'm modelling a series of objects with some physics and mathematics and I found interesting to talk about the library I am using: Delphi APE. This fantastic library available for Delphi (Windows) and Lazarus (Linux) allows very simple task as powerful as gravity, collision processes, grouping behaviour and general process. Great the job done by Alex cove and others like Vincent and Jeremy who helped him to make the conversion to Delphi.

This great library which I'm testing with Delphi 2010 is very easy to use and it shows a very interesting example combining different elements and letting them play. You can download the library from here, and test the different modelled items. The results are very well done and with simple steps we can achieve things like this:

Another interesting library is the one done by Algoryx called Phun.:

Related articles:

Follow us on Facebook

2010-11-17T18:42:00.001+01:00

Few days ago I set up the Facebook fan page just to let my followers be updated with my latest news. and posts. I hope you enjoy my posts and thanks for following.

Alpha-beta pruning algorithm with Delphi

2010-11-17T14:41:00.019+01:00

I'm trying to get round to writing more often and to do my own research with some interesting and complicated algorithms. Given to my great passion for different types of algorithms, in AI , I have found one very interesting and here you can get it build with Delphi 2010. With this solution, you'll be able to add values to the leaves and run the algorithm to find the nodes that will be evaluated and others that will be pruned. I've used my little framework to build the structure (using a GDI render) and then only focus on the algorithm that was the important part. Alpha-beta pruning is a search algorithm which seeks to reduce the number of nodes that are evaluated in the search tree by the minimax algorithm. It is a search with adversary algorithm used commonly for machine playing of two-player games (Tic-tac-toe, Chess, Go, etc.). It stops completely evaluating a move when at least one possibility has been found that proves the move to be worse than a previously examined move. Such moves need not be evaluated further. Alpha-beta pruning is a sound optimization in that it does not change the result of the algorithm it optimizes (Algorithmist.com).

The pseudo-code is quite simple, and it looks like this:

The structure of the application is very simple and the most difficult part is the simulation process where you need to draw every step of the algorithm.

You can download the application from here (Thundax Alpha-beta pruning) and play with it to understand how the algorithm works.

This video shows the execution of the program:

The code of the algorithm is explained as follows:

Alpha-beta algorithm:

function TViewMinimax.alphabeta(Node: TNode; alpha: integer; beta: integer): integer;
var
    i: integer;
    ret: integer;
begin
    if Node.isLeaf then
        ret := Node.Value
    else
    begin
        for i := 0 to Node.children.Count - 1 do
        begin
            alpha := max(alpha, -alphabeta(Node.children.Items[i], -beta, -alpha));
            case Node.player of
                tMAX:
                    begin
                        Node.Value := alpha;
                        SetAlpha(Node, alpha);
                        Node.visited := true;
                    end;
                tMIN:
                    begin
                        Node.Value := -alpha;
                        SetBeta(Node, alpha);
                        Node.visited := true;
                    end;
            end;
            if beta <= alpha then
                Break;
        end;
        ret := alpha;
    end;
    result := ret;
end;

Drawing the nodes by using a pre-order method for iterating the binary tree:

procedure TViewMinimax.Draw;
begin
    preorder(Self.FMinimax.root);
end;

procedure TViewMinimax.preorder(root: TNode);
begin
    if Assigned(root) then
    begin
        if root.children.Count > 0 then
        begin
            DrawLine(root, root.children.Items[0]);
            DrawLine(root, root.children.Items[1]);
            preorder(root.children.Items[0]);
            preorder(root.children.Items[1]);
        end;
        DrawRectangle(root);
    end;
end;

procedure TViewMinimax.DrawRectangle(Node: TNode);
begin
    Fcanvas.Font.Name := 'Arial';
    Fcanvas.Brush.Style := bsSolid;
    if Node.visited then
        Fcanvas.Brush.Color := clRed
    else
        Fcanvas.Brush.Color := clWhite;
    if Node.selected then
        Fcanvas.Brush.Color := clGreen;
    Fcanvas.Pen.Width := 2;
    Fcanvas.Pen.Color := clBlack;
    Fcanvas.Rectangle(Node.position.x - gap, Node.position.y - gap, Node.position.x + gap, Node.position.y + gap);
    Fcanvas.TextOut(Node.position.x - 5, Node.position.y - 5, Inttostr(Node.Value));
    Fcanvas.Brush.Color := clWhite;
    if (Node.isLeaf) and (Node.Order <> 0) then
        Fcanvas.TextOut(Node.position.x - 5, Node.position.y + 15, Inttostr(Node.Order));
    if not Node.isLeaf then
    begin
        case Node.player of
            tMAX:
                begin
                    if Node.alpha <> 0 then
                        Fcanvas.TextOut(Node.position.x - 65, Node.position.y - 10, Inttostr(Node.Order) + ': a=' + Inttostr(Node.alpha));
                    if Node.newAlpha <> 0 then
                        Fcanvas.TextOut(Node.position.x - 65, Node.position.y + 5, Inttostr(Node.NewOrder) + ': a=' + Inttostr(Node.newAlpha));
                end;
            tMIN:
                begin
                    if Node.beta <> 0 then
                        Fcanvas.TextOut(Node.position.x - 65, Node.position.y - 10, Inttostr(Node.Order) + ': ß=' + Inttostr(Node.beta));
                    if Node.Newbeta <> 0 then
                        Fcanvas.TextOut(Node.position.x - 65, Node.position.y + 5, Inttostr(Node.NewOrder) + ': ß=' + Inttostr(Node.Newbeta));
                end;
        end;
        if Node.text <> '' then
        begin
            Fcanvas.Brush.Color := clyellow;
            if (Node.newAlpha = 0) and (Node.Newbeta = 0) then
                Fcanvas.TextOut(Node.position.x - 53, Node.position.y + 5, Node.text)
            else
                Fcanvas.TextOut(Node.position.x - 53, Node.position.y + 20, Node.text)
        end;
    end;
end;

Setting up the Minimax Algorithm:

procedure TForm1.Start1Click(Sender: TObject);
var
    vminimax: TViewMinimax;
    minimax: TMinimax;
    words: TStringList;
    alpha, beta: integer;
begin
    minimax := TMinimax.Create;
    if Edit1.Text <> '' then
    begin
        words := TStringList.Create;
        SplitTextIntoWords(Edit1.Text, words);
        minimax.AddNumbers(words);
    end;
    minimax.CreateTree;
    Memo1.Lines.Clear;

    Image1.Canvas.Brush.color := clwhite;
    Image1.Canvas.Rectangle(0, 0, Image1.Width, Image1.Height);

    vminimax := TViewMinimax.Create(Self.Image1.Canvas, minimax, Memo1);
    if CheckBox1.Checked then
        vminimax.time := 1000
    else
        vminimax.time := 0;
    alpha := alphavalue;
    beta := betavalue;

    vminimax.Draw;
    Self.Image1.Canvas.TextOut(951, 25 - 5, 'MAX');
    Self.Image1.Canvas.TextOut(951, 127 - 5, 'MIN');
    Self.Image1.Canvas.TextOut(951, 228 - 5, 'MAX');
    Self.Image1.Canvas.TextOut(951, 328 - 5, 'MIN');

    Start1.Enabled := false;
    CheckBox1.Enabled := false;
    vminimax.alphabeta(minimax.root, alpha, beta);
    vminimax.Draw;
    Start1.Enabled := true;
    CheckBox1.Enabled := true;

    FreeAndNil(words);
    FreeAndNil(minimax);
    FreeAndNil(vminimax);
end;

Splitting the text into numbers (comma separated values):

procedure SplitTextIntoWords(const S: string; words: TstringList);
var
    startpos, endpos: Integer;
begin
    Assert(Assigned(words));
    words.Clear;
    startpos := 1;
    while startpos <= Length(S) do
    begin
        while (startpos <= Length(S)) and (S[startpos] = ',') do
            Inc(startpos);
        if startpos <= Length(S) then
        begin
            endpos := startpos + 1;
            while (endpos <= Length(S)) and not (S[endpos] = ',') do
                Inc(endpos);
            words.Add(Copy(S, startpos, endpos - startpos));
            startpos := endpos + 1;
        end;
    end;
end;

Related links:

I am my connectome

2010-11-12T19:20:00.001+01:00

This is another interesting TED video of Sebastian Seung. He is mapping a massively ambitious new model of the brain that focuses on the connections between each neuron. He calls it our "connectome," and it's as individual as our genome -- and understanding it could open a new way to understand our brains and our minds.

Source: TED Sebastian Seung.

Genetic Algorithms (GA)

2010-11-10T23:22:00.002+01:00

This semester I am expanding knowledge in terms of Artificial Intelligence and one of the concepts that most captivated me was the resolution of problems using genetic algorithms. These are based on coding the problem in chromosomes and genes into packages. After applying a series of functions, we need to mutate the population to reach our goal. and find the best solution. The definition from wikipedia is: "The genetic algorithm (GA) is a search heuristic that mimics the process of natural evolution. This heuristic is routinely used to generate useful solutions to optimization and search problems. Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to optimization problems using techniques inspired by natural evolution, such as inheritance, mutation, selection, and crossover".

Basically the algorithm works like this:

There are several examples on the net which uses GA to solve common problems such as these:

One of the examples that best shows the use of GA is the solution from Roger Alsing where the algorithm is trying to copy an image generating polygons. These polygons are created in a population of chromosomes and they try to evolve to fit the source image. I've been playing with it and it's great!. You can download the source code and the binaries from here.

Here you can see the results of playing with the application:

Genetic Vectorizer Example by Roger Alsing:

Using my image (40h of running time):

using Einstein image (20h of running time):

Video showing the start of the algorithm:

In the video you can see the different steps the algorithm is doing by creating a population of chromosomes as polygons and trying to fit them by shape and by colour from the source image. The result of the application is the image shown above.

Sodorace game:

Sodarace is the on-line Olympics pitting human creativity against machine learning in a competition to design robots that race over 2D terrains using the Sodaconstructor virtual construction kit.

Enjoy the learning!.

Related articles:

Outstanding videos of robots

2010-11-10T00:16:00.000+01:00

Due to the recent contributions of the scientific community about robots, here are a collection of the best videos I found on the Web. It's amazing how technology improves and the number of mysteries that lie ahead. In the following videos we can see the different robots built by Boston Dynamics (for me the most outstanding are the Big Dog and Little Dog). And we can also find the new Actroid-F presented recently in the AIST Lab Fair and other different examples of robots.

Boston Dynamics: Big Dog:

Boston Dynamics: Little Dog:

Actroid-F in AIST Open Lab:

Transformer Robot:

I hope you enjoy the astonishing videos!

David McCandless: The beauty of data visualization

2010-11-03T19:55:00.000+01:00

This is an interesting video from TED talking about the beauty of data visualization. David McCandless turns complex data sets (like worldwide military spending, media buzz, Facebook status updates) into beautiful, simple diagrams that tease out unseen patterns and connections. Good design, he suggests, is the best way to navigate information glut -- and it may just change the way we see the world.

Presentation of the new Rad Studio XE and the new Visual Studio 2010 in Barcelona

2010-11-03T19:30:00.004+01:00

On November 24 will be held this seminar in Barcelona, which conveniently will show us the new features of the new RAD Studio XE, Delphi XE, C++ Builder XE, Delphi Prism XE and RadPHP XE. I'll take this opportunity to learn in a practical way the latest additions, see examples of operation, contact other users, chat with the team and meet interesting Danysoft promotions. I'm also attending the Visual Studio 2010 presentation which will show us practical themes that are awakening the community of developers. The new ASP.NET , the MVC Framework and the new features included in the WCF (Windows Communication Foundation) will be the discussed topics.

I'll see you there!.

Related topics:

Delphi Unicode Migration

2010-10-21T11:29:00.003+02:00

One of my colleagues found this interesting document about migrating Delphi versions. I'm sure is very useful and this will help us to release a stable version before we move on to Delphi XE.

Check out this SlideShare Presentation:

Delphi Unicode Migration

View more documents from Kristy McHugh.

Other interesting document: Reasons to migrate from Delphi 7 to Delphi 2009:

Reasons to migrate from Delphi 7 to Delphi 2009

View more documents from Michael Findling.

The conversation Prism

2010-10-20T10:51:00.000+02:00

The arts of listening, learning and sharing:

Source:

www.theconversationprism.com

Clean Code: A Handbook of Agile Software Craftsmanship

2010-10-19T13:15:00.008+02:00

It recently arrived at my hands the book from Robert C. Martin: Clean Code. Martin presents a revolutionary paradigm in his book: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distil their best agile practice of cleaning code “on the fly” into a book that will instil within you the values of a software craftsman and make you a better programmer-but only if you work at it.

Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code-of transforming a code base that has some problems into one that is sound and efficient. The third part is the pay-off: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code. Source: Clean Code Handbook

Clean Code I: Arguments from Mike C. on Vimeo.

Clean Code III: Functions from Mike C. on Vimeo.

Related Links:

Keeping track of a list by comparing it.

2010-10-18T21:36:00.000+02:00

Due to my last application developed, I had to compare a list by scanning it and then present the results by including if any item was added or removed. For accomplish this task I've developed a little unit that is able to compare the list and show the results in a TMemo.

//@Author Jordi Coll
//@2010

unit uListCompare;

interface

uses
    Classes, SysUtils;

type
    TListCompare = class(TObject)
        private
            FList2: TStringList;
            FList1: TStringList;
            procedure SetList1(const Value: TStringList);
            procedure SetList2(const Value: TStringList);
        public
            property List1: TStringList read FList1 write SetList1;
            property List2: TStringList read FList2 write SetList2;
            constructor Create();
            destructor Destroy(); override;
            procedure DumpList();
            function ExistInList1(s: string): boolean;
            function ExistInList2(s: string): boolean;
    end;

implementation

{ TListCompare }

constructor TListCompare.Create;
begin
    FList1 := TStringList.Create;
    FList2 := TStringList.Create;
end;

destructor TListCompare.Destroy;
begin
    FreeAndNil(FList1);
    FreeAndNil(FList2);
    inherited;
end;

procedure TListCompare.DumpList;
var
    i: Integer;
begin
    if List2.Count = 0 then
    begin
        for i := 0 to List1.Count - 1 do
        begin
            List2.Add(List1[i]);
           log('New Item ->' + List1[i]);
        end;
    end
    else
    begin
        for i := 0 to List1.Count - 1 do
        begin
            if not ExistInList2(List1[i]) then
                log('New Item ->' + List1[i]);
        end;
        for i := 0 to List2.Count - 1 do
        begin
            if not ExistInList1(List2[i]) then
                log('Item doesn''t exist ->' + List2[i]);
        end;
        List2.Clear;
        for i := 0 to List1.Count - 1 do
            List2.Add(List1[i]);
    end;
end;

function TListCompare.ExistInList1(s: string): boolean;
var
    found: boolean;
    i: Integer;
begin
    i := 0;
    found := false;
    while (i < FList1.Count) and (not found) do
    begin
        found := FList1[i] = s;
        inc(i);
    end;
    result := found;
end;

function TListCompare.ExistInList2(s: string): boolean;
var
    found: boolean;
    i: Integer;
begin
    i := 0;
    foundt := false;
    while (i < FList2.Count) and (not found) do
    begin
        foundt := FList2[i] = s;
        inc(i);
    end;
    result := found;
end;

procedure TListCompare.SetList1(const Value: TStringList);
begin
    FList1 := Value;
end;

procedure TListCompare.SetList2(const Value: TStringList);
begin
    FList2 := Value;
end;

end.

The only thing you have to do is fill the List1 with your items and then execute the procedure DumpList that will dump the information from List1 to List2 and will compare it to show the differences. This object can be called in a thread or a controlled loop.

Killing suspicious processes

2010-10-18T21:18:00.009+02:00

As a result of an experiment, we found out that one process was being run in my local machine by an unknown user and this trigger my curiosity to know more about this and which actions I could do to fix it. Firstly, I decided to monitor the process and gather data from it by using some Delphi API libraries and secondly, build a little application to kill the process and keep a little log just in case. The application is called Thundax Suspicious process watcher v1.1 and it's able to filter processes by unknown/known users and apply actions to them.

Once the application is found (by the process to inspect text box) the utility kills the process and shows the resulted information. We can also force the killing system to the known processes and use it to force the end of and application by filtering it by name and user name.

In the next picture you can notice that I've terminated the execution of the notepad.exe by simply adding it name and process user name (me).

The application core is based on two parts, the first one that is able to search for the applications that are being run in your machine and the second one that is able to kill a process by its PID. Here you can get the implemented code:

Get process list:

procedure ProcessList();
var
    hProcSnap: THandle;
    pe32: TProcessEntry32;
    Domain, User: string;
    listItem: TListItem;
begin
    hProcSnap := CreateToolHelp32SnapShot(TH32CS_SNAPALL, 0);
    if hProcSnap = INVALID_HANDLE_VALUE then
        Exit;
    pe32.dwSize := Sizeof(ProcessEntry32);
    ListView1.Clear;
    listCompare.List1.Clear;
    if Process32First(hProcSnap, pe32) = True then
        while Process32Next(hProcSnap, pe32) = True do
        begin
            if GetUserAndDomainFromPID(pe32.th32ProcessID, User, Domain) then
            begin
                if RadioButton2.Checked then
                begin
                    listItem := ListView1.Items.Add;
                    listItem.Caption := pe32.szExeFile;
                    listItem.SubItems.Add(IntToStr(pe32.th32ProcessID));
                    listItem.SubItems.Add(User);
                    listItem.SubItems.Add(Domain);
                    listCompare.List1.Add(pe32.szExeFile);
                    if AnsiUpperCase(pe32.szExeFile) = AnsiUpperCase(Edit2.text) then
                    begin
                        if Edit3.text <> '' then
                        begin
                            if AnsiUpperCase(User) = AnsiUpperCase(Edit3.text) then
                            begin
                                Log('Application founded ->' + AnsiUpperCase(Edit2.text));
                                if CheckBox3.Checked then
                                begin
                                    KillProcess(pe32.th32ProcessID);
                                    Sleep(300);
                                    Log('Application killed ->' + AnsiUpperCase(Edit2.text));
                                end
                            end;
                        end
                        else
                        begin
                            Log('Application founded ->' + AnsiUpperCase(Edit2.text));
                            if CheckBox3.Checked then
                            begin
                                KillProcess(pe32.th32ProcessID);
                                Sleep(300);
                                Log('Application killed ->' + AnsiUpperCase(Edit2.text));
                            end
                        end;

                    end;
                end
            end
            else
            begin
                if RadioButton1.Checked then
                begin
                    // Suspicious Items
                    listItem := ListView1.Items.Add;
                    listItem.Caption := pe32.szExeFile;
                    listItem.SubItems.Add(IntToStr(pe32.th32ProcessID));
                    listItem.SubItems.Add('UNKNOW');
                    listItem.SubItems.Add('UNKNOW');
                    listCompare.List1.Add(pe32.szExeFile);
                    if AnsiUpperCase(pe32.szExeFile) = AnsiUpperCase(Edit1.text) then
                    begin
                        Log('Application founded ->' + AnsiUpperCase(Edit1.text));
                        if CheckBox2.Checked then
                        begin
                            KillProcess(pe32.th32ProcessID);
                            Sleep(300);
                            Log('Application killed ->' + AnsiUpperCase(Edit1.text));
                        end
                    end;
                end
            end;
            Application.ProcessMessages;
        end;
    CloseHandle(hProcSnap);
end;

function GetUserAndDomainFromPID(ProcessId: DWORD; var User, Domain: string): Boolean;
var
    hToken: THandle;
    cbBuf: Cardinal;
    ptiUser: PTOKEN_USER;
    snu: SID_NAME_USE;
    ProcessHandle: THandle;
    UserSize, DomainSize: DWORD;
    bSuccess: Boolean;
begin
    Result := false;
    ProcessHandle := OpenProcess(PROCESS_QUERY_INFORMATION, false, ProcessId);
    if ProcessHandle <> 0 then
    begin
        if OpenProcessToken(ProcessHandle, TOKEN_QUERY, hToken) then
        begin
            bSuccess := GetTokenInformation(hToken, TokenUser, nil, 0, cbBuf);
            ptiUser := nil;
            while (not bSuccess) and (GetLastError = ERROR_INSUFFICIENT_BUFFER) do
            begin
                ReallocMem(ptiUser, cbBuf);
                bSuccess := GetTokenInformation(hToken, TokenUser, ptiUser, cbBuf, cbBuf);
            end;
            CloseHandle(hToken);

            if not bSuccess then
            begin
                Exit;
            end;

            UserSize := 0;
            DomainSize := 0;
            LookupAccountSid(nil, ptiUser.User.Sid, nil, UserSize, nil, DomainSize, snu);
            if (UserSize <> 0) and (DomainSize <> 0) then
            begin
                SetLength(User, UserSize);
                SetLength(Domain, DomainSize);
                if LookupAccountSid(nil, ptiUser.User.Sid, PChar(User), UserSize, PChar(Domain), DomainSize, snu) then
                begin
                    Result := True;
                    User := StrPas(PChar(User));
                    Domain := StrPas(PChar(Domain));
                end;
            end;

            if bSuccess then
            begin
                FreeMem(ptiUser);
            end;
        end;
        CloseHandle(ProcessHandle);
    end;
end;

Kill process by PID:

procedure KillProcess(pid: integer);
var
    h: THandle;
begin
    try
        h := OpenProcess(PROCESS_TERMINATE, false, pid);
        try
            if h <> 0 then
                TerminateProcess(h, 0);
        finally
            CloseHandle(h);
        end;
    except
        ShowMessage('Error');
    end;
end;

Let me know if you have any doubt about the program or any improvement!.

Related links:

Entrepreneurs can change the world

2010-10-01T19:33:00.010+02:00

A very inspiring video!.

Working with Microsoft Excel (.xlsx) files in Delphi 2010

2010-10-01T19:24:00.001+02:00

Due to the improvement of the new format of Microsoft office 2007 files (.docx, .xlsx based on xml) the way we use to access this documents has changed. Instead of using OLE we can use the power of Delphi and the type library Borland (TLB Files).

In this article we'll talk about how to create the TLB files and the code we need to access the .Excel (.xlsx file) of the example I've created.

First of all, we need to import the components via -> Component -> Import a Type Library. Once we are there, we need to select the "Microsoft Excel 12.0 Object Library" and go on with the import. Mark the "Generate component wrappers" check-box and finally add the component to the working unit. This will generate the Excel_TLB.pas.

Once we have integrated this file into our project, we need to go on with importing the second component: Component -> Import a Type Library and then install the "Microsoft Office 12.0 Object Library". This will generate the Office_TLB.pas (this unit is necessary because it's used by Excel_TLB.pas).

1 - Knowing the number and name of the sheets of the Workbook.

The following code will open a excel file and will load all the sheets into a combo box. Even though it represents a small portion of code, the library is quite complicated to use.

procedure TForm1.LoadCombo();
var
    XLSXReader: Excel_TLB.TExcelApplication;
    newWorkbook: Excel_TLB._Workbook;
    objXLS: Excel_TLB.TExcelWorkbook;
    objSheet: Excel_TLB.TExcelWorksheet;
    i: Integer;
begin
    newWorkbook := XLSXReader.Workbooks.Add('C:\book1.xlsx', GetUserDefaultLCID);
    objXLS := Excel_TLB.TExcelWorkbook.Create(nil);
    objXLS.ConnectTo(newWorkbook);
    objSheet := Excel_TLB.TExcelWorksheet.Create(nil);
    for i := 1 to objXLS.Worksheets.count do
    begin
        objSheet.ConnectTo(objXLS.Worksheets[i] as _Worksheet);
        ComboBox1.Items.Add(objSheet.Name);
    end;
    newWorkbook.Close(false, EmptyParam, EmptyParam, GetUserDefaultLCID);
    FreeAndNil(objXLS);
    FreeAndNil(objSheet);
end;

2 - Accessing to Excel fields.

The following example will get the objSheet and will get all the data from the sheet and will dump into a dataset to display then the result into a grid.

procedure TForm1.Open(Sender: TObject);
var
    XLSXReader: Excel_TLB.TExcelApplication;
    newWorkbook: Excel_TLB._Workbook;
    objXLS: Excel_TLB.TExcelWorkbook;
    objSheet: Excel_TLB.TExcelWorksheet;
    objWrapper: TExcelWrapper;
begin
    newWorkbook := XLSXReader.Workbooks.Add('C:\book1.xlsx', GetUserDefaultLCID);
    objXLS := Excel_TLB.TExcelWorkbook.Create(nil);
    objXLS.ConnectTo(newWorkbook);
    objSheet := Excel_TLB.TExcelWorksheet.Create(nil);
    objSheet.ConnectTo(objXLS.Worksheets['sheet1'] as _Worksheet);
    objWrapper := TExcelWrapper.Create(objSheet);
    if cdsExcel.Active then
        cdsExcel.Close;
    objManager.FillDataSet(cdsExcel);
    cdsExcel.Open;
    cdsExcel.First;
    newWorkbook.Close(false, EmptyParam, EmptyParam, GetUserDefaultLCID);
end;

Then the code for getting the data from the sheet:

procedure TExcelWrapper.FillDataSet(var cdsExcel: TAEClientDataSet);
var
    count: Integer;
    i: Integer;
    bFinished, correct: boolean;
    Value: String;
begin
    if Assigned(FSheet) then
    begin
        try
            cdsExcel.DisableControls;
            count := 0;
            i := 2;
            LastModule := '';
            bFinished := false;
            while not bFinished do
            begin
                Value := FSheet.Cells.Item[i, 1];
                if Value = '' then
                    count := count + 1
                else
                begin
                    count := 0;
                    cdsExcel.Append;
                    cdsExcel.FieldByName('Column1').AsString := FSheet.Cells.Item[i, 1];
                    cdsExcel.FieldByName('Column2').AsString := FSheet.Cells.Item[i, 2];
                    cdsExcel.FieldByName('Column3').AsString := FSheet.Cells.Item[i, 3];
                end;
                if count > 2 then
                    bFinished := true;
                i := i + 1;
            end;
            cdsExcel.Post;
        finally
            cdsExcel.EnableControls;
        end;
    end;
end;

3 - Things to take into account.

You need to remember that the library creates an instance of Excel application, and you must close all the opened connections using the Close procedure.

newWorkbook.Close(false, EmptyParam, EmptyParam, GetUserDefaultLCID);

Related links:

http://powerdelphi.wikispaces.com/Exportar+Query+a+Excel

AGILE 2010: Present and Future of Agilism in Spain

2010-09-30T20:37:00.002+02:00

I've post the last video of AGILE Spain conference held in July 2010, where very interesting topics were discussed. I'm sorry because it's in Spanish, but I hope you enjoy it!.

Reflexion time - Adaptation is the Key

2010-09-30T20:02:00.006+02:00

First of all, I would like to thank all the positive comments I've received for my Blog. I'm truly happy because they inspire me to keep publishing interesting topics related with Delphi, Technology and Science. I can see that the page is widely visited throughout the world and the rate of daily visitors is quite good, but the users don't leave any feedback and sometimes this is a little disappointing. Anyway, I'll keep writing and doing my own research in order to improve myself and sharing my knowledge to the world.

Now I'm immersed on a reflexivity's period, thinking about job opportunities, new projects and new interesting articles to publish. This month I've been working on new interesting projects, migrating versions from Delphi 2007 to Delphi 2010, doing a big rewrite of code due to its internal changes with Indy10 and other new features like generics and working with parameters (I'm eager to test the new Delphi XE, but as soon as I finish the other projects). I've been as well working on a new system to improve the usability of working with Microsoft Office 2007 files such as Excel files (.xlsx) and Word files (.docx), and some other projects as a photographer doing a catalogue for a company!. As you can see this month has been pretty hectic and I never stop running. I have other projects in mind that I need to put into gear, but I need some time to meditate about them, but I'll keep you posted!.

I've been providing services as a technological consultant to some companies in order to improve their IT departments in a wide range of aspects like: security, collaborative work and documentation. And all these experiences have been very rewarded to put into practise all the things learned during the last three years.

With all of this, I just want to motivate you, and remember to do what you love to achieve all what you want. I've been following this simple rule and everything is working fine. I can't complain of anything!.

Here you can see a very interesting video showing the power of adaptation:

Don't hesitate to comment in the blog and feel free to contact me through the web.

If you have time, you can take a look at my portfolio and check out my passion for photography!.

LeanKit Kanban

2010-09-16T19:12:00.003+02:00

This week I've been working with the LeanKit Kanban, a very interesting approach for using Kanban boards in Agile development. All of you know about my interests with the Agile approach, and I think that this interesting and free (limited) tool will help you to keep track of your daily work.

Here you can see a mock up of my kanban board:

In the Jesse Liberty blog, you can find a very interesting description of the Kanban tool:

What Kanban Does For You

What is not obvious in looking at the board is how quickly it reveals bottlenecks, where I’m wasting time, and how to be as effective as possible. The fact that it is all very visual, that you are moving these cards around and can see at a glance all the relevant information, makes it very easy to see what is stuck, and what is moving nicely.

LeanKit Kanban has a number of features that I don’t personally use, but would have killed for in previous projects, such as advanced analytics that include diagrams for Cycle time, cumulative flow, process efficiency, work distribution and more. The analytics allow a team to answer such critical questions as “what is holding the project back?” and ”when will this item be ready?” with high confidence.

I do use the notification capabilities, which turns what is usually a “polling” exercise in frustration into an “interrupt-driven” management approach; much better.

The bottom line, for me, though, is that each “card” carries its entire history, its description, its priority, its due date and everything else I need to know about a sub-feature. That is very clean and it fits well with the way I work.

Jesse Liberty.

Symphony of Science

2010-09-08T11:56:00.000+02:00

The Poetry of Reality is a music video that gathers sentences of 12 scientists and science enthusiasts, including Carl Sagan, Stephen Hawking, Richard Dawkins and Richard Feynman and others. There is real poetry in the real world and science is the poetry of reality.

Source: La reserva.com.

Delphi XE preview videos

2010-08-20T17:59:00.000+02:00

Here you can see the latest videos from embarcadero talking about the new version of Delphi called Delphi XE.

First preview:

this second preview covers some of the third party tools that will be part of Delphi XE:

FinalBuilder, used to manage the build process

The ability to invoke IDE operations (like audits, metrics, code formatting) from the command line, and so invoke them from external tools like FinalBuilder

The integrated version of profiling tool AQTime

The logging support provided by CodeSite, a nice tool written by Ray Konopka.

Source:

Google success!

2010-08-19T20:45:00.002+02:00

This is an interesting Google video: Inside the Mind of Google: "Most successful company in the history of the world".

I hope you enjoy it!.