Denis Dzyubenko

Window resizing and repainting synchronization on X11

2009-06-10T21:10:00.002+04:00

Implemented the _NET_WM_SYNC_REQUEST protocol in Qt for synchronizing window resize (ConfigureNotify events) and repainting (Expose events).

The change makes window resize feel a bit more sluggish in some cases (for example when repainting the whole toplevel is not very fast) since the frame doesn't follow the mouse when the window manager waits for the preview resize+repaint to complete, however there are no more grey unexposed areas when the user resizes windows. Though it works perfectly in Compiz and Metacity, kwin4 seems to need more polishing in its composition manager.

More info.

Automatic window maximization in Gnome

2009-04-08T21:24:00.004+04:00

After using Windows 7 for some time, I've noticed that it has a really nice feature that allows to automatically maximize a window by dragging it to the top edge of the screen and restore a window from a maximized state by dragging its titlebar. I've implemented the same feature for metacity, the Gnome's window manager, and I find it very convenient. Lets hope it will be accepted upstream. Issue 578409 in bugzilla.

P.S. It's been a while since I blogged last time here and I made only a few blog posts in the corporate blog, well I have to say I am a terrible blogger, will see how it goes on.

Visual Studio 2005 tips & tricks

2007-09-10T11:51:00.002+04:00

Here are some tips and trick for Microsoft Visual Studio 2005 (mostly Visual C++ ones).

1. Open files in Visual Studio

You can open files from Windows Explorer (or Total Commander, or any similar application) in existing instance of MSVS by specifying shell command for file type:

"...\Microsoft Visual Studio 8\Common7\IDE\devenv.exe" /edit "%1"

2. How to Not Step Into Functions using the debugger (article)

Here is my configuration with comments:

Default configuration of MSVC8:


"Security check function"="__security_check_cookie"
"Rpcrt4.dll functions that hinder RPC StepInto"="_ObjectStublessClient.*"
"Rpcrt4.dll function that hinders RPC StepOut"="_Invoke@12"
"Run time check function"="_RTC_CheckEsp"

Don't step into TAO reference counted pointers:


"TAO_vars"="TAO_Objref_Var_T.*\\:\\:in=NoStepInto"
"TAO_seq_var"="TAO_Seq_Var_Base_T.*\\:\\:.*=NoStepInto"

Don't step into STL:


"std_string_c_str"="std\\:\\:basic_string.*\\:\\:.*=NoStepInto"
"std::list"="std\\:\\:list.*\\:\\:.*=NoStepInto"
"std::vector"="std\\:\\:vector.*\\:\\:.*=NoStepInto"
"std::map"="std\\:\\:map.*\\:\\:.*=NoStepInto"
"std::set"="std\\:\\:set.*\\:\\:.*=NoStepInto"

Don't step into boost::foreach and boost::shared_ptr (could be very usefull within code like

foreach(Object& obj, getObject())

'step-into' goes to getObject() instead of boost internals)


"boost_foreach"="boost\\:\\:foreach_detail_\\:\\:.*=NoStepInto"
"boost_shared_ptr"="boost\\:\\:shared_ptr.*\\:\\:.*=NoStepInto"

Don't step into 'dynamic_cast'


"RTDynamicCast"="__RTDynamicCast=NoStepInfo"

Here are my configuration: dbg.reg

3. Debugger Visualizers for Qt generic container types


;------------------------------------------------------------------------------
;  QList,QQueue
;------------------------------------------------------------------------------
QList<*>|QQueue<*>{
children
(
    #array
    (
        expr :    *($T1*)(($c.d->array+$c.d->begin)[$i]),
        size :    $c.d->end-$c.d->begin
    )
)

preview
(
    #(
        "[",
        $e.d->end - $e.d->begin ,
        "](",
   
        #array
        (
            expr :     *($T1*)(($c.d->array+$c.d->begin)[$i]),
            size :     $c.d->end-$c.d->begin
        ),
        ")"
    )
)


}

;------------------------------------------------------------------------------
;  QList::iterator, QQueue::iterator
;------------------------------------------------------------------------------
QList<*>::iterator|QList<*>::const_iterator|QQueue<*>::iterator|QQueue<*>::const_iterator {

preview
(
    #(*($T1*)$e.i->v)
)

children
(
    #(ptr: *($T1*)$e.i->v)
)

}

;------------------------------------------------------------------------------
;  QListIterator
;------------------------------------------------------------------------------
QListIterator<*>|QMutableListIterator<*> {

preview
(
    #(*($T1*)$e.i.i->v)
)

children
(
    #(ptr: *($T1*)$e.i.i->v)
)

}


;------------------------------------------------------------------------------
;  QVector::iterator, QStack::iterator
;------------------------------------------------------------------------------
QVector<*>::iterator|QVector<*>::const_iterator|QStack<*>::iterator|QStack<*>::const_iterator {

preview
(
    #($e.i)
)

children
(
    #(ptr: $e.i)
)

}

;------------------------------------------------------------------------------
;  QVector, QStack
;------------------------------------------------------------------------------
QVector<*>|QStack<*>{
children
(
    #array
    (
        expr :    $c.d->array[$i],
        size :    $c.d->size
    )
)

preview
(
    #(
        "[",
        $e.d->size ,
        "](",
   
        #array
        (
            expr :     $c.d->array[$i],
            size :     $c.d->size
        ),
        ")"
    )
)


}

;------------------------------------------------------------------------------
;  QLinkedList
;------------------------------------------------------------------------------
QLinkedList<*>{
children
(
    #list
    (
        head : $c.d->n,
  size : $c.d->size,
        next : n
    ) : #( (*(QLinkedListNode<$T1>*)&$e).t )
)

preview
(
    #(
        "[",
        $e.d->size ,
        "](",
    #list
    (
      head : $c.d->n,
      size : $c.d->size,
      next : n
    ) : ( (*(QLinkedListNode<$T1>*)&amp;amp;amp;$e).t ),
    ")"
    )
)


}

;------------------------------------------------------------------------------
;  QLinkedList::iterator
;------------------------------------------------------------------------------
QLinkedList<*>::iterator|QLinkedList<*>::const_iterator{
    preview
(
    #($e.i->t)
)

children
(
    #(ptr: $e.i->t)
)

}

;------------------------------------------------------------------------------
;  QMap::Node
;------------------------------------------------------------------------------
QMap<*,*>::Node{
preview
(
    #(
      "(",
      $e.key,
      "; ",
      $e.value,
      ")"
     )
)

children
(
    #(
      key: $e.key,
      value: $e.value
     )
)

}

;------------------------------------------------------------------------------
;  QMap::iterator
;------------------------------------------------------------------------------
QMap<*>::iterator|QMap<*>::const_iterator{
preview
(
    #(
     (QMap<$T1>::Node*)((char*)$e.i - (sizeof(*(QMap<$T1>::PayloadNode*)0) - sizeof(QMapData::Node*)))
    )
)

children
(
    #(
      node: (QMap<$T1>::Node*)((char*)$e.i - (sizeof(*(QMap<$T1>::PayloadNode*)0) - sizeof(QMapData::Node*)))
    )
)

}

;------------------------------------------------------------------------------
;  QMap
;------------------------------------------------------------------------------

QMap<*>{
children
(
    #tree
    (
          head : $c.d->forward[0],
          skip : $c.d,
        size : $c.d->size,
        left : backward,
        right : forward
    ) : ( (QMap<$T1>::Node*)((char*)&$e - (sizeof(*(QMap<$T1>::PayloadNode*)0) - sizeof(QMapData::Node*))) )
)
    
preview
(
    #(
        "[",
        $e.d->size,
        "](",

        #tree
        (
            head : $c.d->forward,
            size : $c.d->size,
            left : backward,
            right : forward
        ) : $e,
   
        ")"
    )
)        
}

To use these visualizers they should be pasted into "c:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger\autoexp.dat"

Here are some articles about configuring visualizers for STLport: Garry's Brain Blog

These tips are written in short just not to forget.

apt-cacher

2007-01-14T17:22:00.000+03:00

Damn! Write a patch to a debian package apt-cacher only to find out that latest version from Etch already support the functionality I need. (g)

though publish the patch here (only to base app, not to the package itself), in case I (or anybody) will need it in Woody.


diff -u apt-cacher.orig/apt-cacher.pl apt-cacher/apt-cacher.pl
--- apt-cacher.orig/apt-cacher.pl   2005-07-30 17:03:00.000000000 +0400
+++ apt-cacher/apt-cacher.pl    2007-01-14 17:00:49.000000000 +0300
@@ -683,7 +683,8 @@

 sub usage_error {
    print STDERR "--- apt-cacher.pl:Usage error\n";
-
+   my $is_proxy_user = "no";
+   $is_proxy_user = "yes" if ($config{proxy_user});
    print <<EOF;
 Content-Type: text/html
 Expires: 0
@@ -723,6 +724,7 @@
 <tr bgcolor="cccccc"><td bgcolor="ccccff"> errorfile </td><td> $config{errorfile} </td></tr>
 <tr bgcolor="cccccc"><td bgcolor="ccccff"> expire_hours </td><td> $config{expire_hours} </td></tr>
 <tr bgcolor="cccccc"><td bgcolor="ccccff"> http_proxy </td><td> $config{http_proxy} </td></tr>
+<tr bgcolor="cccccc"><td bgcolor="ccccff"> proxy_user </td><td> $is_proxy_user </td></tr>
 <tr bgcolor="cccccc"><td bgcolor="ccccff"> use_proxy </td><td> $config{use_proxy} </td></tr>
 <tr bgcolor="cccccc"><td bgcolor="ccccff"> debug </td><td> $config{debug} </td></tr>
 </table>
@@ -781,6 +783,9 @@
   # Check whether a proxy is to be used, and set the appropriate environment variable
   if ( $config{use_proxy} eq 1 && $config{http_proxy}) {
      push(@elist, "-x", "http://$config{http_proxy}");
+    if ($config{proxy_user}) {
+       push(@elist, "-U", "$config{proxy_user}");
+   }
   }
   # Check if we need to set a rate limiting value: otherwise make it null
   push(@elist,"--limit-rate", $config{limit}) if ($config{limit} > 0);

apt-cacher is a proxy for apt, that allows upgrading many debian boxes through one caching 'proxy'.

Emacs learning curve

2007-01-10T20:30:00.000+03:00

Comparison of text editors learning curves. True.

fine-tuning Firefox

2007-01-05T15:07:00.000+03:00

Feels like a secret knoledge: To be able closing a tab with a middle click, you should set middlemouse.ContentLoadURL to false in about:config. Seems it is need only in Linux-version of Firefox.

Google Reader update

2007-01-04T04:00:00.000+03:00

wow, Google added new feature to the Google Reader - trends view - very nice statistics about reading feed - now I know I've read more that 4000 items for the last 30 days. what a waste of time of mine. (g)

The one I don't understand is how do they calculate percent of read items - trends tell me all my feed has 100% read items. Is 'read' mean 'viewed by user'? If so, thats not true, since when reading with google reader I scroll throw all items reading titles, and read full articles (summaries and descriptions) only when title concerns me.
I think there should be another trend like 'percent of viewed items' - 'viewed' like 'opened original source article'.

Expandable posts

2007-01-03T23:25:00.000+03:00

Added 'expandable post' feature described at hackosphere.

Though I am not sure if it is useful since it isn't the same as <lj-cut> and doesn't stop loading of all post contents. It just makes posts partially hidden.

(just not to forget how to make posts 'expandable': after blog template customization (done once) wrap text with tags <span id="fullpost"> and </span>)

distributing compilation

2006-12-21T18:54:00.000+03:00

Everyone knows how long does it take to transform c++ sources into binary code, but there are several tools in the ~~google~~world that can cut down compilation time: Xoreax IncrediBuild for Microsoft Visual Studio, and BuilderBooster for Borland C++ Builder and Borland Turbo C++.
We use first for some time and find it really usefull - installed on 10 computers (two developer and eight other office computers), it cuts down compilation time of eight megabytes c++ project from 40 minutes to about 5 mins!
Since our projects divides into two parts - server-side that uses ACE+TAO, STL, Boost, and written with Visual Studio. And client-side, written with Borland C++ Builder 5 (for historical reasons), so IncrediBuild can't satisfy all our needs, and it would be nice to speed up compilation of client-side software too. But it is not. BuilderBooster sucks - it has some bugs (which were revealed after only first 20 mins of using!), its Delphi-style GUI is awful!
What a pity! even google doesn't know any good distributed compiling tool for BCB.
So, hope our migration from BCB to Qt4 doesn't take too much time :(

2006-11-16T14:36:00.000+03:00

Microsoft released PowerShell (ex-"Monad") - powerfull shell for Windows.

Does they think unix-like shell is obsolete? ("Introducing Windows PowerShell: UNIX Administrators Won’t Be Laughing Anymore")
Command-line tools which operate objects instead of strings maybe very usefull, but what about the-main-unix-approach "every think is a string"?

Have to try it in real-life work...

Google Desktop 4.5

2006-11-15T13:34:00.000+03:00

yep, another shiny Google Desktop is out: transparency support, firefox 2.0 support.
i'm loving it :)

Trac to Jira migration

2006-10-27T19:53:00.000+04:00

Some days ago I spent few hours to migrate our corporate issue tracking system from Trac to Jira. For this task I've written some scripts that automate the migration process.

Just to remember, in case I will need them again some day, I publish them ~~here~~ ... on Google Code. Will see if Google Code is comparable enough with sourceforge to use.

comments.py extracts and reformats all trac comments.

export.py saves ticket and extracted comments to a csv file.

Example of using these scripts: trac2jira.sh

Jira import configuration: jira.config

And the script to update subversion commit messages. It simply replaces links to Trac tickets (ex: #1) to Jira-style issue links (ex: COR-1): repo_update.sh

hello, world

2006-10-27T11:13:00.000+04:00

Just to mark beginning of blog usage, here are my hello-s:

Elisp


(while t
 (message "Hello, all")
 (message ""))

Python


def hello_world_generator(msg):
 for i in range(0, len(msg)):
   yield msg[i]

if __name__ == '__main__':
 for char in hello_world_generator('Hello, world'):
   print char,

And of course, the C++


#include <string>
#include <algorithm>
#include <iterator>
#include <iostream>

using namespace std;

class hello_world_iterator : public iterator<forward_iterator_tag, char>
{
  static const string msg;
  string::const_iterator msg_i;
  bool end_;
public:
  hello_world_iterator(bool end=false) : msg_i(msg.end()), end_(end) { }

  char operator* () const
  {
    return (msg_i == msg.end()) ? '\0' : *msg_i;
  }
  hello_world_iterator& operator++ ()
  {
    if (msg_i == msg.end() && !end_)
      msg_i = msg.begin();
    else
      msg_i++;
    if (msg_i == msg.end())
      end_ = true;
    return *this;
  }

  bool operator== (const hello_world_iterator &rhs) const
  {
    return msg_i == rhs.msg_i && end_ == rhs.end_;
  }
  bool operator!= (const hello_world_iterator &rhs) const
  {
    return !(*this == rhs);
  }
};

const string hello_world_iterator::msg = "Hello, world";

int main(int argc, char* argv[])
{
  copy(hello_world_iterator(), hello_world_iterator(true),
    ostream_iterator<char>(cout));
  return 0;
}

(c++ version was written very fast, so sorry, it may contain some flaws).