Jump to content

MarkShark

Members
 View Profile  See their activity

  • Content Count

    86

  • Joined

  • Last visited

Posts posted by MarkShark

  1. Posted

    Thanks all!  I ended up using Frost's suggestion of using the hash as the key like so: 

    Hash := THashFNV1a32.GetHashValue(FTokenStart^, FTokenLength * SizeOf(Char));
if not FTokenDictionary.TryGetValue(Hash, Result) then
  Result := UnknownToken;

    And it appears to be roughly three times faster than my old verson using SetString!  I used that particular hash because it looks like that's what Delphi's default string comparer uses.

     

  2. Posted

    Hi all!  I often find myself needing to look up a string token in a dictionary.  Usually, the token is part of a larger string being parsed.  Currently I take a copy of that portion of the string using SetString or Copy and use that new string for the lookup.  The code looks something like this:

      

      // Not shown: parse some source string and get a pointer to the first char of the token and the length of said token
  // Now get a copy of that token so we can look it up in the dictionary
  SetString(TempToken, FTokenStart, FTokenLength);
  if not FTokenDictionary.TryGetValue(TempToken, Result) then
    Result := UnknownToken;

    I'm wondering if there's any way to avoid the SetString part of this.  Thanks for any ideas!

  4. Posted

    Hi all!  I'm doing the following to convert a string to utf8 and then to move it into a memory location (it happens to be a globalallocbuffer for a clipboard format, but I don't' think that matters to my question.)   It works well, but I was wondering if it's possible to do it without the intermediate byte array.  Delphi 11 btw.  Any thoughts appreciated.

      

            Buf := TEncoding.UTF8.GetBytes(AString);
        Move(Buf, PtrData^, Length(Buf));

     

  7. Posted · Edited by MarkShark
    Clarification

    @pyscripter, you pointed me in the right direction, but I think your syntax is off (I'm guessing just a typo.)   Here's what worked: 

        var SList := Shared.Make<TStringList>(TStringList.Create(dupIgnore, True, False));

    Unlike some of my other tries this one just creates a single StringList with the correct parameters.  I mention that just because some of my other syntax tests created a parameter-less StringList, immediately freed it, and then created the dupIgnore one.   This syntax above seems to do the trick!  Thanks!

     

    Also @Vincent Parrett  I think you're right about Shared<>.Make!  It turns out I was using the wrong "thing".   Shared.Make<> vs Shared<>.Make.

     

    • Like 1

  8. Posted

    I'm trying to use Spring4D's Shared<> smartpointer feature to get a smartpointer to a TStringList.  This is easy and works really well, but I haven't been able to figure out how to do this and call an overloaded constructor.

     

    So this works great: 

      var SList := Shared<TStringList>.Make;
  SList.Add('Blah');

    But I'd like to create a stringlist using the overloaded create call that includes the duplicate option.   Something like the following, which doesn't work.  

    var SList := Shared<TStringList>.Make(dupIgnore, True, False);
SList.Add('Blah');

    Anyone know how to do it?  Thanks!

     

     

     

     

  9. Posted

    I'm using the new SynEdit with the SQL Highlighter.  I've tested with a 250,000 line sql script containing a real mix of statements including comments, string literals, lots of brackets, etc.  I don't see any lag or stuttering.  Make sure to test outside of debug mode as that really seems to affect the dwrite stuff.  My machine isn't a high end machine, it's an AMD mini pc with a mobile 4-core (Ryzen 7 3750H), Windows 11, Delphi 11.  I can't say enough about the new features of the SynEdit, the new gutter stuff, the alpha blended select and especially the new way it does the end of row selections is really nice.  Pyscripter has done an amazing job modernizing the control.  It will be interesting to get feedback on what cpu/gpu people are using and if there are particular settings that seem to affect performance.

    • Like 1

  10. Posted

    Thanks Dalija and the other posters, this is all "good stuff" and I love to learn new things and techniques.  I'm not sure how the word condescending matches anything said here so far btw.  Also just as a note I see that Emba switched to using AtomicCmpExchange instead of InterlockedCompareExchangePointer in Delphi 11 (or perhaps earlier.)  Kind of interesting.

     

  13. Posted

    Thank you Peter!  I'm checking out your code and trying to learn some uncoupling/interface techniques.  In the HelperRegistry function I notice you use the following code to set the InternalHelperRegistry while also returning it.  Is it done this way for thread safety or is it just related to maintaining the proper refcount of the interface?

     

    BTW:  Your posts through the years have been extremely helpful to me, so thanks as always! 

      

          Result := THelperRegistry.Create;
      Result._AddRef; // the call below does not increment the refcount!
      P:= InterlockedCompareExchangeObject(InternalHelperRegistry,
        TObject(Pointer(Result)), nil);
      if P <> nil then begin
        Result._Release;
        Result := InternalHelperRegistry;
      end; {if}

    -Mark

  14. Posted

    I realize that this is going to be very subjective, but what are people's thoughts on using begin end just to limit the scope of an inline variable?  For example:

      

    ... code
begin
  var LocalString := 'My String';
  ... Use LocalString for something
end;
... more code

    Are there any caveats to doing so?   I know that doing this can cause an implicit try-finally for managed types, so I can see that being a performance factor in a loop and something to be aware of. It also seems like they've fixed the issues with the debugger and inline vars in Delphi 11 (at least in the simple cases I've tried), which makes them more usable.

     

    -Mark

     

  16. Posted · Edited by MarkShark
    typo fix

    I had to do this for a password management tray app I wrote for personal use.  Here's the technique I ended up with (with lots of help from stack overflow and others.)

     

    Step 1:

      Use EnumWindows with a callback to build up a list of window handles.  They will be in the current z-order. It needs to check if the window is visible, unowned, and has WS_EX_APPWINDOW in its style before adding it to your list.

    Step 2:

      Loop through the window handles above and find the first one in the list with a thread process id different than your current program.  This is done using GetWindowThreadProcessId on each window handle from your enum list and comparing to the results of GetCurrentThreadID.

     

    That window handle should be the main window of the app that was last active.   I would perform the above whenever my tray app was activated. I'm guessing there are exceptions for "stay on top" apps and such but it seemed to work for my needs.  I hope that helps or at least gives a clue!

     

    -Mark

     

    Update note:  Once I get the window handle of the last activated app I would also call GetLastActivePopup on it (as I needed to know if it had a modal popup active.)

     

    • Like 1

  18. Posted · Edited by MarkShark
    clarifying

    Summary:  Using a Parallel.BackgroundWorker if I check for WorkItem.CancellationToken.IsSignalled within the .OnExecute anonymous procedure I see that it is terminated immediately if I call FWorker.CancelAll from the main thread.  HOWEVER if I use a function called from the OnExecute handler it seems that the token is only signaled once the function completes.  I've included some code below, but if anyone could explain what I'm seeing it would be much appreciated!

     

    Using a Paralel.BackgroundWorker created like:

      FWorker := Parallel.BackgroundWorker.Execute(nil);

     

    I then schedule a work item like:

      

      FWorker.Schedule(
    FWorker.CreateWorkItem(TOmniValue.Null),
    FWorker.Config
      .OnExecute(
        procedure(const WorkItem: IOmniWorkItem)
        begin
          var LElapsed: Integer := 1;
          repeat
            Sleep(100);
            Inc(LElapsed, 100);
          until WorkItem.CancellationToken.IsSignalled or (LElapsed > 5000);
        end)
      .OnRequestDone(
        procedure (const Sender: IOmniBackgroundWorker; const WorkItem: IOmniWorkItem)
        begin
          if WorkItem.CancellationToken.IsSignalled then
            Memo1.Lines.Add('Task ' + WorkItem.UniqueID.ToString + ' onRequestDone and was cancelled.')
          else
            Memo1.Lines.Add('Task ' + WorkItem.UniqueID.ToString + ' onRequestDone');
        end
      )
  );

    Calling FWorker.CancelAll; from the main thread cancels this workitem immediately.

     

    However if instead of the "repeat until" above I call the following function, the token is never signaled "during the call", though it is signaled after the call returns. 

    function NiceWaitEx(const ACancelToken: IOmniCancellationToken; AWaitMs: Integer): Integer;
begin
  const LagMs = 100;
  var LElapsed: Integer := 1;
  repeat
    Sleep(LagMs);
    Inc(LElapsed, LagMs);
  until ACancelToken.IsSignalled or (LElapsed > AWaitMs);
  Result := LElapsed;
end;
      FWorker.Schedule(
    FWorker.CreateWorkItem(TOmniValue.Null),
    FWorker.Config
      .OnExecute(
        procedure(const WorkItem: IOmniWorkItem)
        begin
          NiceWaitEx(WorkItem.CancellationToken, 5000);
        end)
      .OnRequestDone(
        procedure (const Sender: IOmniBackgroundWorker; const WorkItem: IOmniWorkItem)
        begin
          if WorkItem.CancellationToken.IsSignalled then
            Memo1.Lines.Add('Task ' + WorkItem.UniqueID.ToString + ' onRequestDone and was cancelled.')
          else
            Memo1.Lines.Add('Task ' + WorkItem.UniqueID.ToString + ' onRequestDone');
        end
      )
  );

    When I use the second version (with the call) the workitem always goes the full 5 seconds although shows that it was cancelled at the end.

     

    I hope that's enough to explain the issue (and my confusion lol.)  Any thoughts appreciated!

     

    -Mark

     

  21. Posted · Edited by MarkShark

    I can confirm the change as well.  I've also noticed that the Ctrl-Alt-Up and Ctrl-Alt-Down keys don't seem to navigate between methods anymore (although Ctrl-Alt-Mousewheel still seems to do it.)  I was going to suggest it to jump to the first line after begin, but it's gone.  So if you want the old behavior you can do Ctrl-Shift-Up, Ctrl-Shift-Down, and then Ctrl-Alt-Mousewheel up!  Simple, right? (Wink)  

     

    Method Hopping:

    http://docwiki.embarcadero.com/RADStudio/Sydney/en/Code_Navigation_(IDE_Tutorial)

     

    • Like 1

  24. Posted

    I have a background worker that I create with: 

      FWorker := Parallel.BackgroundWorker
    .NumTasks(1)
    .Execute(HandleQueryWorkItem);

    I queue jobs to this worker and everything works great .  I have a situation where I want to check if the worker is idle with a timeout, so I'm trying to use: 

    FWorker.WaitFor(MyMilliseconds);

    This seems to work in my test cases, however calling WaitFor calls "CompleteAdding" (which seems to make sense.)  However it never gets turned back on and future queueing of jobs raises "Adding to completed collection".

     

    So is there a way to turn queueing back on, or am I doing something fundamentally wrong?   Thanks for any insight or tips!

     

    -Mark

     

  25. Posted

    Windows file explorer in detail view shows combobox-like headers (on hover over) that allow filtering the data based on the column type (for example to only show files changed today, or to only show Excel documents.)  Does anyone know if this is something that the standard TListView control is capable of directly, or is this more an owner draw header type thing?  Alternately, is there a similar control that can do this?  The TVirtualStringTree in column mode perhaps?   My searches on this haven't panned out so I'm wondering if anyone has any suggestions or thoughts.  Thanks!

     

    -Mark

     

×