Changeset 6795 for trunk/gtk/msgwin.c


Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (14 years ago)
Author:
charles
Message:

run libT, cli, daemon, gtk through the source-code formatter "uncrustify" as promised/threatened

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/msgwin.c

    r6402 r6795  
    44 * This file is licensed by the GPL version 2.  Works owned by the
    55 * Transmission project are granted a special exemption to clause 2(b)
    6  * so that the bulk of its code can remain under the MIT license. 
     6 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
    88 * the Transmission project.
    9  * 
     9 *
    1010 * $Id$
    1111 */
     
    3838struct MsgData
    3939{
    40     TrCore * core;
    41     GtkTreeView * view;
    42     GtkListStore * store;
    43     GtkTreeModel * filter;
    44     GtkTreeModel * sort;
    45     int maxLevel;
    46     gboolean isPaused;
    47     guint refresh_tag;
     40    TrCore *        core;
     41    GtkTreeView *   view;
     42    GtkListStore *  store;
     43    GtkTreeModel *  filter;
     44    GtkTreeModel *  sort;
     45    int             maxLevel;
     46    gboolean        isPaused;
     47    guint           refresh_tag;
    4848};
    4949
     
    5656
    5757static void
    58 level_combo_changed_cb( GtkWidget * w, gpointer gdata )
     58level_combo_changed_cb( GtkWidget * w,
     59                        gpointer    gdata )
    5960{
    6061    struct MsgData * data = gdata;
    61     GtkTreeIter iter;
    62     if( gtk_combo_box_get_active_iter( GTK_COMBO_BOX(w), &iter ) )
    63     {
    64         int level = 0;
     62    GtkTreeIter      iter;
     63
     64    if( gtk_combo_box_get_active_iter( GTK_COMBO_BOX( w ), &iter ) )
     65    {
     66        int            level = 0;
    6567        GtkTreeModel * m = gtk_combo_box_get_model( GTK_COMBO_BOX( w ) );
    6668        gtk_tree_model_get( m, &iter, 1, &level, -1 );
     
    7476
    7577static void
    76 doSave( GtkWindow      * parent,
     78doSave( GtkWindow *      parent,
    7779        struct MsgData * data,
    78         const char     * filename )
     80        const char *    filename )
    7981{
    8082    FILE * fp = fopen( filename, "w+" );
     83
    8184    if( !fp )
    8285    {
    8386        errmsg( parent,
    84                 _("Couldn't save file \"%1$s\": %2$s"),
    85                 filename, g_strerror( errno ) );
     87               _( "Couldn't save file \"%1$s\": %2$s" ),
     88               filename, g_strerror( errno ) );
    8689    }
    8790    else
    8891    {
    89         GtkTreeIter iter;
     92        GtkTreeIter    iter;
    9093        GtkTreeModel * model = GTK_TREE_MODEL( data->sort );
    9194        if( gtk_tree_model_iter_children( model, &iter, NULL ) ) do
    92         {
    93             char * date;
    94             const char * levelStr;
    95             const struct tr_msg_list * node;
    96 
    97             gtk_tree_model_get( model, &iter,
    98                                 COL_TR_MSG, &node,
    99                                 -1 );
    100             date = gtr_localtime( node->when );
    101             switch( node->level ) {
    102                 case TR_MSG_DBG: levelStr = "debug"; break;
    103                 case TR_MSG_ERR: levelStr = "error"; break;
    104                 default:         levelStr = "     "; break;
     95            {
     96                char *                     date;
     97                const char *               levelStr;
     98                const struct tr_msg_list * node;
     99
     100                gtk_tree_model_get( model, &iter,
     101                                    COL_TR_MSG, &node,
     102                                    -1 );
     103                date = gtr_localtime( node->when );
     104                switch( node->level )
     105                {
     106                    case TR_MSG_DBG:
     107                        levelStr = "debug"; break;
     108
     109                    case TR_MSG_ERR:
     110                        levelStr = "error"; break;
     111
     112                    default:
     113                        levelStr = "     "; break;
     114                }
     115                fprintf( fp, "%s\t%s\t%s\t%s\n", date, levelStr,
     116                        ( node->name ? node->name : "" ),
     117                        ( node->message ? node->message : "" ) );
     118
     119                g_free( date );
    105120            }
    106             fprintf( fp, "%s\t%s\t%s\t%s\n", date, levelStr,
    107                      ( node->name ? node->name : "" ),
    108                      ( node->message ? node->message : "" ) );
    109 
    110             g_free( date );
    111         }
    112         while( gtk_tree_model_iter_next( model, &iter ) );
     121            while( gtk_tree_model_iter_next( model, &iter ) );
     122
    113123        fclose( fp );
    114124    }
     
    116126
    117127static void
    118 onSaveDialogResponse( GtkWidget * d, int response, gpointer data )
    119 {
    120   if( response == GTK_RESPONSE_ACCEPT )
    121   {
    122       char * filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( d ) );
    123       doSave( GTK_WINDOW( d ), data, filename );
    124       g_free( filename );
    125   }
    126 
    127   gtk_widget_destroy( d );
    128 }
    129 
    130 static void
    131 onSaveRequest( GtkWidget * w, gpointer data )
    132 {
    133   GtkWindow * window = GTK_WINDOW( gtk_widget_get_toplevel( w ) );
    134   GtkWidget * d = gtk_file_chooser_dialog_new( _("Save Log"), window,
    135                                                GTK_FILE_CHOOSER_ACTION_SAVE,
    136                                                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
    137                                                GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
    138                                                NULL );
    139   gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
    140                                            GTK_RESPONSE_ACCEPT,
    141                                            GTK_RESPONSE_CANCEL,
    142                                            -1 );
    143   g_signal_connect( d, "response",
    144                     G_CALLBACK( onSaveDialogResponse ), data );
    145   gtk_widget_show( d );
    146 }
    147 
    148 static void
    149 onClearRequest( GtkWidget * w UNUSED, gpointer gdata )
     128onSaveDialogResponse( GtkWidget * d,
     129                      int         response,
     130                      gpointer    data )
     131{
     132    if( response == GTK_RESPONSE_ACCEPT )
     133    {
     134        char * filename =
     135            gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( d ) );
     136        doSave( GTK_WINDOW( d ), data, filename );
     137        g_free( filename );
     138    }
     139
     140    gtk_widget_destroy( d );
     141}
     142
     143static void
     144onSaveRequest( GtkWidget * w,
     145               gpointer    data )
     146{
     147    GtkWindow * window = GTK_WINDOW( gtk_widget_get_toplevel( w ) );
     148    GtkWidget * d = gtk_file_chooser_dialog_new( _(
     149                                                     "Save Log" ), window,
     150                                                 GTK_FILE_CHOOSER_ACTION_SAVE,
     151                                                 GTK_STOCK_CANCEL,
     152                                                 GTK_RESPONSE_CANCEL,
     153                                                 GTK_STOCK_SAVE,
     154                                                 GTK_RESPONSE_ACCEPT,
     155                                                 NULL );
     156
     157    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
     158                                             GTK_RESPONSE_ACCEPT,
     159                                             GTK_RESPONSE_CANCEL,
     160                                             -1 );
     161    g_signal_connect( d, "response",
     162                      G_CALLBACK( onSaveDialogResponse ), data );
     163    gtk_widget_show( d );
     164}
     165
     166static void
     167onClearRequest( GtkWidget * w UNUSED,
     168                gpointer      gdata )
    150169{
    151170    struct MsgData * data = gdata;
     171
    152172    gtk_list_store_clear( data->store );
    153173    tr_freeMessageList( myHead );
     
    156176
    157177static void
    158 onPauseToggled( GtkToggleToolButton * w, gpointer gdata )
     178onPauseToggled( GtkToggleToolButton * w,
     179                gpointer              gdata )
    159180{
    160181    struct MsgData * data = gdata;
     182
    161183    data->isPaused = gtk_toggle_tool_button_get_active( w );
    162184}
    163185
    164 static struct {
    165   const char * label;
    166   const char * pref;
    167   int id;
     186static struct
     187{
     188    const char *  label;
     189    const char *  pref;
     190    int           id;
    168191} trLevels[] = {
    169   { N_("Error"), "error", TR_MSG_ERR },
    170   { N_("Information"), "info",  TR_MSG_INF },
    171   { N_("Debug"), "debug", TR_MSG_DBG },
     192    { N_( "Error" ),       "error",       TR_MSG_ERR          },
     193    { N_( "Information" ), "info",        TR_MSG_INF          },
     194    { N_( "Debug" ),       "debug",       TR_MSG_DBG          },
    172195};
    173196
     
    176199{
    177200    const char * foreground;
    178     switch( msgLevel ) {
    179         case TR_MSG_DBG: foreground = "gray"; break;
    180         case TR_MSG_INF: foreground = "black"; break;
    181         case TR_MSG_ERR: foreground = "red"; break;
    182         default: g_assert_not_reached( );
     201
     202    switch( msgLevel )
     203    {
     204        case TR_MSG_DBG:
     205            foreground = "gray"; break;
     206
     207        case TR_MSG_INF:
     208            foreground = "black"; break;
     209
     210        case TR_MSG_ERR:
     211            foreground = "red"; break;
     212
     213        default:
     214            g_assert_not_reached( );
    183215    }
    184216    return foreground;
     
    187219static void
    188220renderText( GtkTreeViewColumn  * column UNUSED,
    189             GtkCellRenderer    * renderer,
    190             GtkTreeModel       * tree_model,
    191             GtkTreeIter        * iter,
    192             gpointer             gcol )
    193 {
    194     const int col = GPOINTER_TO_INT( gcol );
    195     char * str = NULL;
     221            GtkCellRenderer *          renderer,
     222            GtkTreeModel *              tree_model,
     223            GtkTreeIter *              iter,
     224            gpointer                    gcol )
     225{
     226    const int                  col = GPOINTER_TO_INT( gcol );
     227    char *                     str = NULL;
    196228    const struct tr_msg_list * node;
     229
    197230    gtk_tree_model_get( tree_model, iter, col, &str, COL_TR_MSG, &node, -1 );
    198231    g_object_set( renderer, "text", str,
    199                             "foreground", getForegroundColor( node->level ),
    200                             "ellipsize", PANGO_ELLIPSIZE_END,
    201                             NULL );
     232                  "foreground", getForegroundColor( node->level ),
     233                  "ellipsize", PANGO_ELLIPSIZE_END,
     234                  NULL );
    202235}
    203236
    204237static void
    205238renderTime( GtkTreeViewColumn  * column UNUSED,
    206             GtkCellRenderer    * renderer,
    207             GtkTreeModel       * tree_model,
    208             GtkTreeIter        * iter,
    209             gpointer             data UNUSED )
    210 {
    211     struct tm tm;
    212     char buf[16];
     239            GtkCellRenderer *          renderer,
     240            GtkTreeModel *              tree_model,
     241            GtkTreeIter *              iter,
     242            gpointer             data   UNUSED )
     243{
     244    struct tm                  tm;
     245    char                       buf[16];
    213246    const struct tr_msg_list * node;
    214247
    215     gtk_tree_model_get(tree_model, iter, COL_TR_MSG, &node, -1 );
     248    gtk_tree_model_get( tree_model, iter, COL_TR_MSG, &node, -1 );
    216249    tm = *localtime( &node->when );
    217     g_snprintf( buf, sizeof( buf ), "%02d:%02d:%02d", tm.tm_hour, tm.tm_min, tm.tm_sec );
    218     g_object_set (renderer, "text", buf,
    219                             "foreground", getForegroundColor( node->level ),
    220                             NULL );
    221 }
    222 
    223 static void
    224 appendColumn( GtkTreeView * view, int col )
    225 {
    226     GtkCellRenderer * r;
     250    g_snprintf( buf, sizeof( buf ), "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
     251                tm.tm_sec );
     252    g_object_set ( renderer, "text", buf,
     253                   "foreground", getForegroundColor( node->level ),
     254                   NULL );
     255}
     256
     257static void
     258appendColumn( GtkTreeView * view,
     259              int           col )
     260{
     261    GtkCellRenderer *   r;
    227262    GtkTreeViewColumn * c;
    228     const char * title = NULL;
    229 
    230     switch( col ) {
    231         case COL_SEQUENCE: title = _( "Time" ); break;
     263    const char *        title = NULL;
     264
     265    switch( col )
     266    {
     267        case COL_SEQUENCE:
     268            title = _( "Time" ); break;
     269
    232270        /* noun.  column title for a list */
    233         case COL_NAME: title = _( "Name"); break;
     271        case COL_NAME:
     272            title = _( "Name" ); break;
     273
    234274        /* noun.  column title for a list */
    235         case COL_MESSAGE:  title = _( "Message" ); break;
    236         default: g_assert_not_reached( );
     275        case COL_MESSAGE:
     276            title = _( "Message" ); break;
     277
     278        default:
     279            g_assert_not_reached( );
    237280    }
    238281
     
    242285            r = gtk_cell_renderer_text_new( );
    243286            c = gtk_tree_view_column_new_with_attributes( title, r, NULL );
    244             gtk_tree_view_column_set_cell_data_func( c, r, renderText, GINT_TO_POINTER(col), NULL );
     287            gtk_tree_view_column_set_cell_data_func( c, r, renderText,
     288                                                     GINT_TO_POINTER(
     289                                                         col ), NULL );
    245290            gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
    246291            gtk_tree_view_column_set_fixed_width( c, 200 );
     
    251296            r = gtk_cell_renderer_text_new( );
    252297            c = gtk_tree_view_column_new_with_attributes( title, r, NULL );
    253             gtk_tree_view_column_set_cell_data_func( c, r, renderText, GINT_TO_POINTER(col), NULL );
     298            gtk_tree_view_column_set_cell_data_func( c, r, renderText,
     299                                                     GINT_TO_POINTER(
     300                                                         col ), NULL );
    254301            gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
    255302            gtk_tree_view_column_set_fixed_width( c, 500 );
     
    260307            r = gtk_cell_renderer_text_new( );
    261308            c = gtk_tree_view_column_new_with_attributes( title, r, NULL );
    262             gtk_tree_view_column_set_cell_data_func( c, r, renderTime, NULL, NULL );
     309            gtk_tree_view_column_set_cell_data_func( c, r, renderTime, NULL,
     310                                                     NULL );
    263311            gtk_tree_view_column_set_resizable( c, TRUE );
    264312            break;
     
    274322
    275323static gboolean
    276 isRowVisible( GtkTreeModel * model, GtkTreeIter * iter, gpointer gdata )
    277 {
    278     const struct MsgData * data = gdata;
     324isRowVisible( GtkTreeModel * model,
     325              GtkTreeIter *  iter,
     326              gpointer       gdata )
     327{
     328    const struct MsgData *     data = gdata;
    279329    const struct tr_msg_list * node;
     330
    280331    gtk_tree_model_get( model, iter, COL_TR_MSG, &node, -1 );
    281332    return node->level <= data->maxLevel;
     
    283334
    284335static void
    285 onWindowDestroyed( gpointer gdata, GObject * deadWindow UNUSED )
     336onWindowDestroyed( gpointer             gdata,
     337                   GObject * deadWindow UNUSED )
    286338{
    287339    struct MsgData * data = gdata;
     340
    288341    g_source_remove( data->refresh_tag );
    289342    g_free( data );
     
    291344
    292345static tr_msg_list *
    293 addMessages( GtkListStore * store, struct tr_msg_list * head )
    294 {
    295     const char * default_name = g_get_application_name( );
     346addMessages( GtkListStore *       store,
     347             struct tr_msg_list * head )
     348{
     349    const char *        default_name = g_get_application_name( );
    296350    static unsigned int sequence = 1;
    297     tr_msg_list * i;
    298 
    299     for( i=head; i; i=i->next )
     351    tr_msg_list *       i;
     352
     353    for( i = head; i; i = i->next )
    300354    {
    301355        GtkTreeIter unused;
     
    303357        gtk_list_store_insert_with_values( store, &unused, 0,
    304358                                           COL_TR_MSG, i,
    305                                            COL_NAME, ( i->name ? i->name : default_name ),
     359                                           COL_NAME,
     360                                           ( i->name ? i->name :
     361                                             default_name ),
    306362                                           COL_MESSAGE, i->message,
    307363                                           COL_SEQUENCE, sequence++,
    308364                                           -1 );
    309365
    310          if( !i->next )
    311              break;
     366        if( !i->next )
     367            break;
    312368    }
    313369
     
    319375{
    320376    struct MsgData * data = gdata;
     377
    321378    if( !data->isPaused )
    322379    {
     
    340397debug_level_combo_new( void )
    341398{
    342     unsigned int i;
    343     int ii;
    344     int curlevel;
    345     GtkWidget * levels;
    346     GtkListStore * store;
     399    unsigned int      i;
     400    int               ii;
     401    int               curlevel;
     402    GtkWidget *       levels;
     403    GtkListStore *    store;
    347404    GtkCellRenderer * renderer;
    348405
    349     store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
     406    store = gtk_list_store_new ( 2, G_TYPE_STRING, G_TYPE_INT );
    350407
    351408    curlevel = pref_int_get( PREF_KEY_MSGLEVEL );
    352     for( i=ii=0; i<G_N_ELEMENTS(trLevels); ++i ) {
     409    for( i = ii = 0; i < G_N_ELEMENTS( trLevels ); ++i )
     410    {
    353411        GtkTreeIter iter;
    354         gtk_list_store_append (store, &iter);
    355         gtk_list_store_set (store, &iter, 0, _(trLevels[i].label),
    356                                           1, trLevels[i].id,
    357                                          -1);
     412        gtk_list_store_append ( store, &iter );
     413        gtk_list_store_set ( store, &iter, 0, _( trLevels[i].label ),
     414                             1, trLevels[i].id,
     415                             -1 );
    358416        if( trLevels[i].id == curlevel )
    359417            ii = i;
    360418    }
    361     levels = gtk_combo_box_new_with_model (GTK_TREE_MODEL(store));
     419    levels = gtk_combo_box_new_with_model ( GTK_TREE_MODEL( store ) );
    362420    g_object_unref( G_OBJECT( store ) );
    363421    store = NULL;
    364422
    365     renderer = gtk_cell_renderer_text_new ();
    366     gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(levels), renderer, TRUE );
    367     gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(levels), renderer,
     423    renderer = gtk_cell_renderer_text_new ( );
     424    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( levels ), renderer, TRUE );
     425    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( levels ), renderer,
    368426                                    "text", 0,
    369427                                    NULL );
     
    373431}
    374432
    375 
    376433/**
    377434***  Public Functions
     
    381438msgwin_new( TrCore * core )
    382439{
    383     GtkWidget * win;
    384     GtkWidget * vbox;
    385     GtkWidget * toolbar;
    386     GtkWidget * w;
    387     GtkWidget * view;
    388     GtkToolItem * item;
     440    GtkWidget *      win;
     441    GtkWidget *      vbox;
     442    GtkWidget *      toolbar;
     443    GtkWidget *      w;
     444    GtkWidget *      view;
     445    GtkToolItem *    item;
    389446    struct MsgData * data;
    390447
     
    403460
    404461    toolbar = gtk_toolbar_new( );
    405     gtk_toolbar_set_orientation( GTK_TOOLBAR( toolbar ), GTK_ORIENTATION_HORIZONTAL );
     462    gtk_toolbar_set_orientation( GTK_TOOLBAR(
     463                                     toolbar ), GTK_ORIENTATION_HORIZONTAL );
    406464    gtk_toolbar_set_style( GTK_TOOLBAR( toolbar ), GTK_TOOLBAR_BOTH_HORIZ );
    407465
    408       item = gtk_tool_button_new_from_stock( GTK_STOCK_SAVE );
    409       g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
    410       g_signal_connect( item, "clicked", G_CALLBACK(onSaveRequest), data );
    411       gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    412 
    413       item = gtk_tool_button_new_from_stock( GTK_STOCK_CLEAR );
    414       g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
    415       g_signal_connect( item, "clicked", G_CALLBACK(onClearRequest), data );
    416       gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
     466    item = gtk_tool_button_new_from_stock( GTK_STOCK_SAVE );
     467    g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
     468    g_signal_connect( item, "clicked", G_CALLBACK( onSaveRequest ), data );
     469    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
     470
     471    item = gtk_tool_button_new_from_stock( GTK_STOCK_CLEAR );
     472    g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
     473    g_signal_connect( item, "clicked", G_CALLBACK( onClearRequest ), data );
     474    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    417475
    418476    item = gtk_separator_tool_item_new( );
    419477    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    420478
    421       item = gtk_toggle_tool_button_new_from_stock( GTK_STOCK_MEDIA_PAUSE );
    422       g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
    423       g_signal_connect( item, "toggled", G_CALLBACK(onPauseToggled), data );
    424       gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
     479    item = gtk_toggle_tool_button_new_from_stock( GTK_STOCK_MEDIA_PAUSE );
     480    g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
     481    g_signal_connect( item, "toggled", G_CALLBACK( onPauseToggled ), data );
     482    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    425483
    426484    item = gtk_separator_tool_item_new( );
    427485    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    428486
    429       w = gtk_label_new( _( "Level" ) );
    430       gtk_misc_set_padding( GTK_MISC( w ), GUI_PAD, 0 );
    431       item = gtk_tool_item_new( );
    432       gtk_container_add( GTK_CONTAINER( item ), w );
    433       gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    434 
    435       w = debug_level_combo_new( );
    436       g_signal_connect( w, "changed", G_CALLBACK(level_combo_changed_cb), data );
    437       item = gtk_tool_item_new( );
    438       gtk_container_add( GTK_CONTAINER( item ), w );
    439       gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
     487    w = gtk_label_new( _( "Level" ) );
     488    gtk_misc_set_padding( GTK_MISC( w ), GUI_PAD, 0 );
     489    item = gtk_tool_item_new( );
     490    gtk_container_add( GTK_CONTAINER( item ), w );
     491    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
     492
     493    w = debug_level_combo_new( );
     494    g_signal_connect( w, "changed", G_CALLBACK(
     495                          level_combo_changed_cb ), data );
     496    item = gtk_tool_item_new( );
     497    gtk_container_add( GTK_CONTAINER( item ), w );
     498    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
    440499
    441500    gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
     
    449508                                      G_TYPE_POINTER,    /* category */
    450509                                      G_TYPE_POINTER,    /* message */
    451                                       G_TYPE_POINTER);   /* struct tr_msg_list */
     510                                      G_TYPE_POINTER );   /* struct tr_msg_list
     511                                                            */
    452512
    453513    addMessages( data->store, myHead );
    454514    onRefresh( data ); /* much faster to populate *before* it has listeners */
    455515
    456     data->filter = gtk_tree_model_filter_new( GTK_TREE_MODEL( data->store ), NULL );
     516    data->filter = gtk_tree_model_filter_new( GTK_TREE_MODEL(
     517                                                  data->store ), NULL );
    457518    data->sort = gtk_tree_model_sort_new_with_model( data->filter );
    458519    gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( data->sort ),
     
    460521                                          GTK_SORT_ASCENDING );
    461522    data->maxLevel = pref_int_get( PREF_KEY_MSGLEVEL );
    462     gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( data->filter ),
     523    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( data->
     524                                                                   filter ),
    463525                                            isRowVisible, data, NULL );
    464526
     
    475537                                    GTK_POLICY_AUTOMATIC );
    476538    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
    477                                          GTK_SHADOW_IN);
     539                                         GTK_SHADOW_IN );
    478540    gtk_container_add( GTK_CONTAINER( w ), view );
    479541    gtk_box_pack_start( GTK_BOX( vbox ), w, TRUE, TRUE, 0 );
     
    486548    return win;
    487549}
     550
Note: See TracChangeset for help on using the changeset viewer.