mORMot Open Source

Hi, Arnaud.

I did small changes to the SQLite3Service unit (TService).
I only added common property ControlHandler for setting the callback handler and some minor changes to fit it properly in code.
If the handler is not set from "outside" then your hack is used.
So this "outside discipline" is some how similar to the SvcMgr.TService approach.
The difference is that our TService does not force you to subclassing (no abstract procedure), it could be easily used in composition scenario too (I moved DoCtrlHandle to the public visibility for that reason).
Anyway I think that this approach is good (it's just added choice, we lose nothing), even if the asm (automatic router ) code would be corrected.
This always works, because is just basic Pascal .

I sent you code via mail (I don't want to bloat the forum ).

1. Entry point is here http://synopse.info/fossil/wiki?name=SQLite3+Framework.
2. This follows you to the download page.
3. Download and Read SAD documentation (ok, you already did)
4. Download official code at http://synopse.info/files/SynopseSQLite3.zip or bleeding edge code from the source control web interface (read about it here)
5. Look at examples in ...\Synopse\SQLite3\Samples\
6. Investigate the code (and comments in code) "playing" with examples or with your "samples"
7. Search first in this forum, because many questions was already asked, then ask...

Iterate all of the points again and again .

This was discussed at least in two topics:
First in favor to object.
And second, yes there are possible problems with them too.

Yes it works and seems as more complete solution .

I already showed you with previous post.

What you are naming Database is named in my case as rest.

So lets repeat and complete with your variables :

var
 TableRole: TSQLTable;
 sql: string;
begin
  sql := StringToUTF8('your join sql here');
  TableRole := TSQLTableDB.Create(Database,[TSQLUserRoles, TSQLUserRole], sql, false);
  TSQLTableToGrid.Create(dgRoles, TableRole, Database);
end;

That is all. You must first read the SAD documentation and take MainDemo as first reference and Arnaud code (and comments) as MASTER REFERENCE !

This is somehow related to the scaling of the "elements", because in BMP (print as bitmap) case
following code works well (copied from PaintPreview, case for GDI+):

rec := Rect(0,0,Bmp.Width,Bmp.Height);
if not ForceNoAntiAliased then
   DrawEmfGdip(BMP.Canvas.Handle,TMetaFile(Pages.Objects[i]), rec,ForceInternalAntiAliased);

and this does not (original code for ForcePrintAsBitmap in TGDIPages.PrintPages function), which does some stretching (scaling)  - I'm guessing from the name of procedure:

BMP.Canvas.StretchDraw(Rect(0,0,Bmp.Width,Bmp.Height), TMetaFile(Pages.Objects[i]));

and with pdf export must be same issue when using "metafile to pdf commands".

Hopefully this narrow the problem down...
For me this solution becomes from "show stopper" to "accepted workaround", because at least I need working printing (pdf export is fine feature, but not the requirement in my application).

I think you could do it simply via direct call of EngineExecute('VACUUM') of TSQLRest instance.

But you should read first about VACUUM command, that you call it at proper time, synchronized on server side.

You have one small lapsus (which is show stopper ) in SQLite3i18n at line 1904:

      text := ppi^.GetGenericStringValue(comp);

should be

      old := ppi^.GetGenericStringValue(comp);

With first code excerpt goes this too:

fFieldComponents[i] := C;
continue;

I was not thinking about the "long" version, but only about upper comparison, because later you use continue word, so the flow control is changed and the "extra" code

if (C<>nil) and (C<>self) and (C<>Scroll) then begin

is never reached in set case.
So It seems that you were using C only for common handling of controls and TGroupBox does not count in it.
From technical aspect usage of the upper is the same, but cleaner design is assigning Group, not the C.

coblongpamor, if you need really customized look of edit form, then don't use TRecordEditForm, but develop custom GUI by "hand" (using Delphi RAD approach) as is done in Main Demo in FileEdit.pas (TEditForm) and manipulate with TSQLRecord as you wish.

Looking at the code should be enough, because basics of the framework are used in it.

Quick look through comments in your code give me the filling of only <summary> node usage and missing others (as see, seealso, param...), which are used in chm, MS Help 2, HTML and other help formats used as API description in Delphi IDE and similar.

E.g. automatically inserted template (with regions of course) with typing almost only ///:

{$REGION 'xmldoc'}
/// <summary>
/// Register a specified test to this class instance
/// </summary>
/// <param name="aMethod">Comment here the aMethod param</param>
/// <param name="aName">Comment here the aName param</param>
{$ENDREGION}
procedure Add(aMethod: TSynTestEvent; const aName: string);

with excerpt of generated xml doc (which is really verbose, too verbose, but quickly generated by compiler and you can guess that all xml tags are not completely the same as in .NET, but this is not the problem):

(...)
<procedure name="Add" visibility="public">
<devnotes>
<summary>
 Register a specified test to this class instance 
</summary>
<param name="aMethod">
Comment here the aMethod param
</param>
<param name="aName">
Comment here the aName param
</param>
</devnotes>
<parameters>
<parameter name="aMethod" type="TSynTestEvent"/>
<parameter name="aName" type="string" paramflags="const"/>
</parameters>
</procedure>
(...)

versus

/// register a specified test to this class instance
procedure Add(aMethod: TSynTestEvent; const aName: string);

Xml Doc is indeed more verbose (with more information in this case) when used for commenting the code, but with using regions that is not any problem, because they are collapsible and you don't see this as nagging text.

-------------
I saw that you have some special tags in comments, but I don't know if they could achieve same effect as regular xml doc tags?
Are this comment tags used in your code described anywhere?
In SynProject you have some kind of version control, but is it possible (with minor work) to attach some 3rd version control, such as subversion or fossil ?

I'll definitely look at SynProject in details to become more familiar with used concepts. Then I can properly make a comment, what could be done to easily interface (or extend) with existing tools, practices...

Yes, that was my point, only replacing PasDoc parser with xml doc parser, what Delphi itself is already. So if they add some new feature to Pascal language, we don't feel this, because xml doc output format is consistent and parsing xml is very easy.

Don't forget not only that you are compatible with .NET commenting, but you get Help Insight, compiler warnings about wrong referenced "classes" and maybe refactoring tools too. In short Embercadero is enforcing Microsoft standards and they (both) make tools for us.

I think would be best to use the Delphi generated xml output and parse it to some intermediate format which would fit in SynProject.
This way we don't need custom parser implementation for xml comments in code, rather we parse the well formated generated xml from Delphi compiler.
In this way you have generated xml with all classes, functions, records even if you did not comment anything. You get all hierarchy and you could easily generate final documentation only for "elements" which are commented if you wish.

What you think about that?

By mistake I named SynProject as Synopse in my last post. I'm aware (from your description, not really used it) of your completeness of this documenting program.

Maybe is not totally proper that I opened different but somehow connected subject, when I mentioned XML (with XSLT you have the power needed) as possible output for documentation and at the same time I was talking about XML DOC comments, which are standard at least in Microsoft world.

I really like xml doc comments, because I don't take this kind of xml as evil (opposite from that I see SOAP as too verbose). If you have proper tools at your hand this is not the obstacle. With tools I mean, using regions to hide comments, auto generated templates (automatically extracted arguments...) for procedures and functions for example,  help insight showing your comments in Delphi IDE, Delphi checks referencing comments integrity when compiling and I can bet that some tool is capable to refactor referencing comments when you e.g. rename class.

If I understand correctly you use modified PasDoc (as I know all old parsers brake on new features of Delphi language, so constant update of them is the must) for comment extraction and then you generate pro file.
As I see it, xml doc could be replacement (or the extra possibility) only for PasDoc parser (not as the whole) as intermediate format, which has well formed xml format and could be easily parsed and transformed into pro format (or could be used for totally different cases, because it is standardized...).

In short, if I want to comment code in xml doc and use the generated Delphi xml documentation output as source for SynProject, which parts need the change? Is it only the PasDoc parser or is the "picture" more complex?
If this is not too hard, maybe I can try and add support for Delphi generated XML documentation, which is the code (with or without comments) extraction only.

Yes, HTML would be better and user editable...
Maybe even better as custom XML (raw data) with some XSLT transformation to get HTML or some other output.

Yes

You don't need to check for trigger existence, because you know that is not yet created, so just call "create trigger...".

I was using InitializeTable for filling the delphi enum in some reference table (on table creation), where the enum's could be translated (not i18n) in some other text.

I didn't really looked the code, just run the tests and look for results .

Now all tests pass just fine.

Yes indeed looks that PAnsiChar casting was guilty for hidden conversion.
Super , now there is only one failing test left and that is the PDF check:

Unit SynSelfTest

813:

H := Hash32(MS.Memory,MS.Position);
Check( (H=$93D859A5) or (H=$9FB359A7) ); // Arial,Bold and Tahoma FontBBox
MS.SaveToFile(ChangeFileExt(paramstr(0),'.pdf'));

Is the date below in resulting pdf correct?

/CreationDate (D:20100610191717)
/ModDate (D:20100610191717)

Is the webcontact01 mail or is web link in some page (that I can send you the resulting pdf for quick diff with yours expected one)?

Hm, next error is strange for me, you will get it much faster than me, what is going on.

Direct access file test failure:
When I look in Test1.json dump file, created with different exe-s (1252,1250), the only difference is in BLOB part:

Unit SQLite3

  R.Bind(1,PAnsiChar(chr(224)+chr(233)+chr(231)+'dsjdsBLOB23'),14); // Bind Blob
(...)
  JS := Demo.ExecuteJSON(Req); // get result in JSON format
  FileFromString(JS,'Test1.json');
  Check(Hash32(JS)=$221D7DBD,'Expected ExecuteJSON result not retrieved');//line 5623

Here are JSON excerpts (Difference is in 2 Bytes in BLOB ?! Are we not forcing this with chr(...) to be correct, where is the problem?):
1250: "Mônet","YennZHNqZHNCTE9CMjM=",1840,1926,19, -> Ye is $59 $65
1252: "Mônet","4OnnZHNqZHNCTE9CMjM=",1840,1926,19, -> 4O is $34 $4F

Ok, with debugger I saw that sqlite3_column_blob api in

W.WrBase64(sqlite3_column_blob(Request,i),
                sqlite3_column_bytes(Request,i),true);

returned for those 3 Bytes next values for 1250:
$61 $E9 $E7 -> 97 233 231 //strange, the first one is incorrect?!

and for 1252:
$E0 $E9 $E7 -> 224 233 231 //all three are correct

No this does not work, I think that there is no way to change system code page without restarting the OS.

Yes, using break is the shortest one .

With next PDF test I really don't have a clue what could be wrong and how to test it, because I don't know what to expect in intermediate steps.

Unit SynSelfTests

Check on line 792 is OK,
but the check on line 813 fails:

H := Hash32(MS.Memory,MS.Position); //MS.Position=6725, H=$93E059A5 
Check( (H=$93D859A5) or (H=$9FB359A7) ); // Arial,Bold and Tahoma FontBBox