Thread: Gdk-pixbuf and file locations (and other GTK+ questions)

  1. #16
    Registered User
    Join Date
    May 2015
    Posts
    52
    Thanks again, I've started focusing more intently on GTK and I actually have a sample output already!
    Nothing much, but it's something.
    Gdk-pixbuf and file locations (and other GTK+ questions)-wip-jpg
    The one box isn't editable by the player, while the other is the input box, which will get commands and pass them to the game. There's an "enter" and a "quit" button, both from images I quickly made, and both functional.
    Of course, all images are placeholders right now.

    I have encountered a single problem a few times now and I was wondering if you could help me out.
    I need to modify some widgets (and possibly other data) from my main function in callbacks. The g_signal_connect function only accepts one data variable, but, as I saw online, one can create a struct with all the info needed and pass that as data to the callback. However, the exact documentation was lacking in every post I found, and while I tried many variations, I couldn't get it to work.
    If you can help, I'd like to see an example or some explanation on the whole idea. It's the one thing I've stumped on so far.

    Oh, also, I came up with nothing when I searched about how to get an event that reads keypresses of the Enter key, so that I can use that in addition to the "enter" button I have.

    EDIT: I mistakenly posted a previous version (without the icon for the enter button) and I can't remove it, just ignore it.
    Attached Images Attached Images Gdk-pixbuf and file locations (and other GTK+ questions)-wip-jpg 
    Last edited by Sotos; 07-07-2015 at 07:54 AM.

  2. #17
    Registered User migf1's Avatar
    Join Date
    May 2013
    Location
    Athens, Greece
    Posts
    385
    Quote Originally Posted by Sotos View Post
    ...
    I have encountered a single problem a few times now and I was wondering if you could help me out.
    I need to modify some widgets (and possibly other data) from my main function in callbacks. The g_signal_connect function only accepts one data variable, but, as I saw online, one can create a struct with all the info needed and pass that as data to the callback. However, the exact documentation was lacking in every post I found, and while I tried many variations, I couldn't get it to work.
    If you can help, I'd like to see an example or some explanation on the whole idea. It's the one thing I've stumped on so far.
    Have a look at the code, in the end of this post.

    Notice that struct Gui *gui = NULL; which is defined in the main function (and populated via the GtkBuilder *builder object from a glade file) is subsequently passed as the last argument in the callback function for the "clicked" signal of the OK button (line 166).

    The callback function (namely, on_clicked_button_ok() in line 63 ) takes the gui object as its last argument, because it needs access to the GtkEntries gui->op1 and gui->op2, along with the GtkLabel gui->result.

    Without wrapping the widgets into the Gui struct, and then passing it as an argument to the callback function of the OK GtkButton, we wouldn't be able to access the rest of the widgets from within the callback (unless of course we had defined them globally... something I personally try to avoid whenever I can).

    At the end of that post, I have included a zip file with the source-code and the glade file. You may want to have a look at them too, ideally compiling & running the program to see what's happening.

    Actually, the user enters 2 numbers in the GtkEntry widgets op1 & op2, he then hits the OK GtkButton, and the sum of op1, op2 is displayed in a GtkLabel result.

    Btw, for GTK2 you should download Glade v3.8.x (Glade v3.10.x is for GTK3).

    Oh, also, I came up with nothing when I searched about how to get an event that reads keypresses of the Enter key, so that I can use that in addition to the "enter" button I have.
    Although you can try to handle key-presses manually inside the GtkEntry widget, via the key_press_event, it will most probably get complicated.

    Another approach (an easier one imo) is to set your Enter GtkButton as the default button of the main window, and then use the function gtk_entry_set_activates_default() on the GtkEntry widget that you use for getting user input.

    For example, in the code of the post I mentioned earlier, you can add the lines:
    Code:
    gtk_entry_set_activates_default( GTK_ENTRY(gui->op1), TRUE );
    gtk_entry_set_activates_default( GTK_ENTRY(gui->op2), TRUE );
    in the main() function, so whenever the user presses ENTER while inside either of the 2 GtkEntry widgets, the OK GtkButton will be activated, because it is already set as the default button of the window (it is set as default in the glade file, but you can also set it manually via the function gtk_window_set_default()).
    Last edited by migf1; 07-07-2015 at 03:26 PM.
    "Talk is cheap, show me the code" - Linus Torvalds

  3. #18
    Registered User
    Join Date
    May 2015
    Posts
    52
    I worked the struct out (haven't bothered with Enter yet, but I'll keep your advice in mind).

    I'm facing a really weird problem though. I've managed to locate it, but it's so odd that I must be missing something really obvious ._.

    I made a sample program just to test it, and it goes like this.
    I have a window and two buttons, Button 1 and Button 2.
    Button 1 is added to the window, and linked to a callback that will remove that from the window and add Button 2 in its stead when the user enters the button with his mouse.
    Similarly, Button 2 is linked to a callback that swaps it out for Button 1 when the user leaves the button.
    g_object_ref_sink and g_object_ref / g_object_unref functions are added for the program to properly work.
    Sure enough, when I run it, I can run my cursor through the button, and it will change to Button 2 while the cursor is in it, returning back to Button 1 when the cursor leaves. All's working fine.

    Then, I tried to do the same thing with event boxes, as I will need to work with more than buttons. So, I unlink the buttons to the callbacks, call
    Code:
    gtk_widget_set_events(eventbox,GDK_ENTER_NOTIFY_MASK);
    gtk_widget_set_events(eventbox,GDK_LEAVE_NOTIFY_MASK);
    and the appropriate g_signal_connect functions with "enter_notify_event" and "leave_notify_event" as the events, and but the buttons into the eventbox and the eventbox in the window.
    Now, whenever I run the code, it crashes at the g_object_ref function in my callbacks. If I remove that, it returns GTK_IS_CONTAINER failures with the eventbox.

    I have tangled with it for a couple of hours now to no avail. Is "enter_notify_event" wrong in some way? I've no idea.

    Below is the whole code, look through it if you can spare the time.
    Thanks in advance
    Code:
    #include <gtk/gtk.h>
    
    typedef struct {
        GtkWidget *button1;
        GtkWidget *button2;
        GtkWidget *window;
    } strct;
    
    
    void callback_func (GtkWidget *ignored, strct *test) {
        GtkWidget *window=test->window;
        GtkWidget *changebutton1=test->button1;
        GtkWidget *changebutton2=test->button2;
        g_object_ref(changebutton1);
        gtk_container_remove(GTK_CONTAINER(window),changebutton1);
        gtk_container_add(GTK_CONTAINER(window),changebutton2);
        g_object_unref(changebutton2);
        gtk_widget_show_all(window);
    }
    void callback_func2 (GtkWidget *ignored, strct *test) {
        GtkWidget *window=test->window;
        GtkWidget *changebutton1=test->button1;
        GtkWidget *changebutton2=test->button2;
        g_object_ref(changebutton2);
        gtk_container_remove(GTK_CONTAINER(window),changebutton2);
        gtk_container_add(GTK_CONTAINER(window),changebutton1);
        g_object_unref(changebutton1);
        gtk_widget_show_all(window);
    }
    
    
    int main(int argc, char *argv[])
    {
        strct test;
        gtk_init(&argc,&argv);
        GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
        GtkWidget *eventbox=gtk_event_box_new();
        GtkWidget *changebutton1=gtk_button_new_with_label("Button 1");
        GtkWidget *changebutton2=gtk_button_new_with_label("Button 2");
    
    
        test.window=eventbox;
        test.button1=changebutton1;
        test.button2=changebutton2;
    
    
        g_object_ref_sink(changebutton1);
        g_object_ref_sink(changebutton2);
    
    
        g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
        g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
    
    
        gtk_widget_set_events(eventbox,GDK_ENTER_NOTIFY_MASK);
        gtk_widget_set_events(eventbox,GDK_LEAVE_NOTIFY_MASK);
        gtk_container_add(GTK_CONTAINER(window),eventbox);
        gtk_container_add(GTK_CONTAINER(eventbox),changebutton1);
        g_signal_connect (G_OBJECT (eventbox), "enter_notify_event",G_CALLBACK (callback_func),(gpointer*)&test);
        g_signal_connect (G_OBJECT (changebutton2), "leave_notify_event",G_CALLBACK(callback_func2),(gpointer*)&test);
        gtk_widget_show_all(window);
    
    
        gtk_main ();
        return 0;
    }
    Note that the "window" in the callbacks is the "window" part of the struct, which is linked to the eventbox, not the actual window.

  4. #19
    Registered User migf1's Avatar
    Join Date
    May 2013
    Location
    Athens, Greece
    Posts
    385
    IMHO, that was more complicated than it needs to be (and frankly quite wrong ) .

    You can simply show & hide the buttons, inside the callback functions. See the code below. Also, the callback function for the "enter_notify_event" and "leave_notify_event" has a different prototype than the one you use (follow this link).

    All in all, the following code does what I think you are after with buttons.

    Code:
    #include <gtk/gtk.h>
    #include <stdio.h>   // for debugging messages
    
    typedef struct Gui {
        GtkWidget *button1;
        GtkWidget *button2;
        GtkWidget *hbox;
        GtkWidget *window;
    } Gui;
    
    /*********************************************//**
     *
     *************************************************
     */
    void on_enter_notify_event_button1(
        GtkWidget *button1,
        GdkEvent  *event,
        Gui       *gui
        )
    {
        (void) button1;
        (void) event;
    
        printf( "%s\n", "in" );  // for debugging
    
        gtk_widget_hide( gui->button1 );
        gtk_widget_show( gui->button2 );
    }
    
    /*********************************************//**
     *
     *************************************************
     */
    void on_leave_notify_event_button2(
        GtkWidget *button2,
        GdkEvent  *event,
        Gui       *gui
        )
    {
        (void) button2;
        (void) event;
    
        printf( "%s\n", "out" );  // for debugging
    
        gtk_widget_hide( gui->button2 );
        gtk_widget_show( gui->button1 );
    }
    
    /*********************************************//**
     *
     *************************************************
     */
    int main( int argc, char *argv[] )
    {
        Gui gui = { NULL };
    
        gtk_init( &argc, &argv );
    
        gui.window   = gtk_window_new( GTK_WINDOW_TOPLEVEL );
        gui.hbox     = gtk_hbox_new( TRUE, 1 );
        gui.button1  = gtk_button_new_with_label( "Button 1" );
        gui.button2  = gtk_button_new_with_label( "Button 2" );
    
        /* lay out the widgets */
        gtk_container_add( GTK_CONTAINER(gui.window), gui.hbox );
        gtk_box_pack_start_defaults( GTK_BOX(gui.hbox), gui.button1 );
        gtk_box_pack_start_defaults( GTK_BOX(gui.hbox), gui.button2 );
    
        /* connect signal handlers */
        g_signal_connect(
            gui.window,
            "delete_event",
            G_CALLBACK( gtk_main_quit ),
            NULL
            );
        g_signal_connect(
            gui.window,
            "destroy",
            G_CALLBACK( gtk_main_quit ),
            NULL
            );
    
        g_signal_connect(
            gui.button1,
            "enter_notify_event",
            G_CALLBACK( on_enter_notify_event_button1 ),
            &gui
            );
        g_signal_connect(
            gui.button2,
            "leave_notify_event",
            G_CALLBACK( on_leave_notify_event_button2 ),
            &gui
            );
    
        /* all set, go */
        gtk_widget_show_all( gui.window );
        gtk_widget_hide( gui.button2 );
        gtk_main();
    
        return 0;
    }
    As you can see, both buttons are created, they are packed inside a GtkHBox, and their callback functions are simply hiding the button that emitted the signal, and they are showing the other button.

    For widgets that are not "eventable", the same thing can be done by say wrapping the hbox inside an event-box, and then catch signals on the event-box. Something like this (GtkButton are "eventable" so there's no need for an event-box around them, but I kept it the same as your example):

    Code:
    #include <gtk/gtk.h>
    #include <stdio.h>   // for debugging messages
    
    typedef struct Gui {
        GtkWidget *button1;
        GtkWidget *button2;
        GtkWidget *eventbox;
        GtkWidget *hbox;
        GtkWidget *window;
    } Gui;
    
    /*********************************************//**
     *
     *************************************************
     */
    void on_enter_notify_event_eventbox(
        GtkWidget *eventbox,
        GdkEvent  *event,
        Gui       *gui
        )
    {
        (void) eventbox;
        (void) event;
    
        printf( "%s\n", "in" );  // for debugging
    
        gtk_widget_hide( gui->button1 );
        gtk_widget_show( gui->button2 );
    }
    
    /*********************************************//**
     *
     *************************************************
     */
    void on_leave_notify_event_eventbox(
        GtkWidget *eventbox,
        GdkEvent  *event,
        Gui       *gui
        )
    {
        (void) eventbox;
        (void) event;
    
        printf( "%s\n", "out" );  // for debugging
    
        gtk_widget_hide( gui->button2 );
        gtk_widget_show( gui->button1 );
    }
    
    /*********************************************//**
     *
     *************************************************
     */
    int main( int argc, char *argv[] )
    {
        Gui gui = { NULL };
    
        gtk_init( &argc, &argv );
    
        gui.window   = gtk_window_new( GTK_WINDOW_TOPLEVEL );
        gui.eventbox = gtk_event_box_new();
        gui.hbox     = gtk_hbox_new( TRUE, 1 );
        gui.button1  = gtk_button_new_with_label( "Button 1" );
        gui.button2  = gtk_button_new_with_label( "Button 2" );
     
        /* lay out the widgets */
        gtk_container_add( GTK_CONTAINER(gui.window), gui.eventbox );
        gtk_container_add( GTK_CONTAINER(gui.eventbox), gui.hbox );
        gtk_box_pack_start_defaults( GTK_BOX(gui.hbox), gui.button1 );
        gtk_box_pack_start_defaults( GTK_BOX(gui.hbox), gui.button2 );
    
        /* connect signal handlers */
        g_signal_connect(
            gui.window,
            "delete_event",
            G_CALLBACK( gtk_main_quit ),
            NULL
            );
        g_signal_connect(
            gui.window,
            "destroy",
            G_CALLBACK( gtk_main_quit ),
            NULL
            );
    
        g_signal_connect(
            gui.eventbox,
            "enter_notify_event",
            G_CALLBACK( on_enter_notify_event_eventbox ),
            &gui
            );
        g_signal_connect(
            gui.eventbox,
            "leave_notify_event",
            G_CALLBACK( on_leave_notify_event_eventbox ),
            &gui
            );
    
        /* all set, go */
        gtk_widget_show_all( gui.window );
        gtk_widget_hide( gui.button2 );
        gtk_main();
    
        return 0;
    }
    Last edited by migf1; 07-08-2015 at 02:55 AM. Reason: typos
    "Talk is cheap, show me the code" - Linus Torvalds

  5. #20
    Registered User
    Join Date
    May 2015
    Posts
    52
    That worked like a charm, I didn't even know the gtk_widget_hide and gtk_widget_show functions existed. Thank you for putting up with me
    Of course, I have yet another problem. I asked about it on StackOverflow (where I made an account so that I don't pester you so much), but there was no response, so here I am again.

    I used GtkTextView instead of GtkEntry, as the output I'm going to have will be paragraphs, not single lines. However, I can find no way to make the text drop to the next line if it exceeds the border of the window. The window is not resizable, with a fixed size, and if the text goes over the border, it just keeps on, hiding the beginning of the row.

    I tried to work with row and column counters, but that wasn't possible, as each character has a different width. So, a full row on a sample window may consist of 10 "m"s but 16 "0"s, and I can't just cut off the row at a certain column.
    I also found a gtk_entry_set_max_length command, but that seems to only work for characters, not other measures of length. Plus, working with paragraphs and a different GtkEntry for each line would be extremely messy.

    Any ideas?

    EDIT: I found something, I'll try to work on that.
    http://www.compsci.hunter.cuny.edu/~...K_textview.pdf mentions something relevant at page 9.
    Last edited by Sotos; 07-08-2015 at 05:16 AM.

  6. #21
    Registered User
    Join Date
    May 2015
    Posts
    52
    For some reason I can't edit my post a second time, so, yeah, apparently it was just the wrap option, way easier than I thought. That was fixed easily.

  7. #22
    Registered User
    Join Date
    May 2015
    Posts
    52
    Another update, on the transparency I was looking for, I believe that the gdk_window_shape_combine_mask command is what I was looking for. If I can get a mask in the shape of a non rectangular image, and then add the same image on top of the window, it will essentially do the job. I hope.

    However, gdk_window_shape_combine_mask needs me to provide a mask in a GdkBitmap format, which is obsolete, as I read. I tried to do it with a pixbuf instead, but didn't come up with anything other than errors...

  8. #23
    Registered User migf1's Avatar
    Join Date
    May 2013
    Location
    Athens, Greece
    Posts
    385
    Unfortunately, image processing is not my... forte (especially via GTK). I hope someone else can help you with that.

    However, there may be an easier way to do what you are after (for example, GTK widgets retain automatically the transparency of their icons and/or images) .. what exactly are you trying to do?
    "Talk is cheap, show me the code" - Linus Torvalds

  9. #24
    Registered User
    Join Date
    May 2015
    Posts
    52
    Gtk widgets don't retain the transparency, as far as I've tested. Transparent backgrounds turn to grey ones, resulting in every icon having a grey rectangle around it instead of a transparent background.
    This isn't so much of a problem regarding general widgets. However, I'd like to do something about the window, so that I wouldn't have to make its image square. Refer to this client from Diablo 3, for example.
    http://i.stack.imgur.com/V26PQ.jpg

    As you can see, the window isn't a perfect rectangle. Instead, some things escape (like the "III" and the devil's horns on the top side, or some angular details on other sides). That's what I want to attempt.

  10. #25
    Registered User migf1's Avatar
    Join Date
    May 2013
    Location
    Athens, Greece
    Posts
    385
    Quote Originally Posted by Sotos View Post
    Gtk widgets don't retain the transparency, as far as I've tested. Transparent backgrounds turn to grey ones, resulting in every icon having a grey rectangle around it instead of a transparent background.
    I'm not sure we are talking about the same thing, but look at this pic (actual code follows later in the post).

    Gdk-pixbuf and file locations (and other GTK+ questions)-cclwqqw-jpg

    The shield is the background image (a .png with transparent areas), while the diablo3-logo, the play-button and the blizzard-stripe are all image-widgets from transparent .png files. No grey areas appear at all. And as you can see, those images are not necessarily rectangular.

    This isn't so much of a problem regarding general widgets. However, I'd like to do something about the window, so that I wouldn't have to make its image square. Refer to this client from Diablo 3, for example.
    http://i.stack.imgur.com/V26PQ.jpg

    As you can see, the window isn't a perfect rectangle. Instead, some things escape (like the "III" and the devil's horns on the top side, or some angular details on other sides). That's what I want to attempt.
    I think that's not possible with GTK, or if it is then most probably you'll have to subclass either the GtkWidget class or the GtkWindow class, meaning that you should have a very deep knowledge of the GTK internals.

    If the non-decorated GTK2 window shown in the picture above is something you can live with, then here's the (quick & dirty) source-code for it.

    Code:
    #include <gtk/gtk.h>
    
    /*********************************************//**
     * 
     *************************************************
     */
    gboolean mygtk2_window_set_bgimage_from_file(
        GtkWidget   *window,   /* the window to host the background image */
        const gchar *bgfname,  /* filename of image to be used as bgpixmap */
        GdkPixbuf   **bgpixbuf /* pixbuf to load from file & return to caller */
        )
    {
        GdkPixmap *bgpixmap = NULL;    /* pixmap to be created from pixbuf */
        GtkStyle  *style = NULL;
        GError    *error = NULL;
    
        /* sanity check */
        if ( NULL == window || NULL == bgfname || NULL == bgpixbuf ) {
            return FALSE;
        }
    
        /* load image from file to bgpixbuf */
        *bgpixbuf = gdk_pixbuf_new_from_file( bgfname, &error );
        if ( error ) {
            if ( GDK_PIXBUF_ERROR == error->domain ) {
                g_print( "Pixbuf Related Error:\n" );
            }
            if ( G_FILE_ERROR == error->domain ) {
                g_print( "File Error: Check file permissions and state:\n" );
            }
    
            g_printerr ("%s\n", error[0].message );
            return FALSE;
        }
    
        /*
         * Create bgpixmap from *bgpixbuf, apply it to a new gtk_style
         * and finally apply the new style to the window.
         */
        gdk_pixbuf_render_pixmap_and_mask( *bgpixbuf, &bgpixmap, NULL, 0 );
        style = gtk_style_new();
        style->bg_pixmap[0] = bgpixmap;
        gtk_widget_set_style( window, style );
    
        /* schedule window for redraw */
        gtk_widget_show( window );
    
        return TRUE;
    }
    
    /*************************************************//**
     * 
     *****************************************************
     */
    int main( int argc, char *argv[] )
    {
        GtkWidget *w;          /* our main window */
        GdkPixbuf *bgpixbuf;   /* background image */
    
        gtk_init( &argc, &argv );
    
        /* create main window, set a background image & prepare some visuals */
        w = gtk_window_new( GTK_WINDOW_TOPLEVEL );
        gtk_window_set_default_size( GTK_WINDOW(w), 768, 383 );
        gtk_window_set_position( GTK_WINDOW(w), GTK_WIN_POS_CENTER );
        gtk_window_set_decorated( GTK_WINDOW(w), FALSE );
        mygtk2_window_set_bgimage_from_file(
            w,
            "diablo/shield.png",
            &bgpixbuf
            );
    
    
        /* create a vbox as the main container of the window */
        GtkWidget *vbox    = gtk_vbox_new( FALSE, 0 );
        gtk_container_add( GTK_CONTAINER(w), vbox );
    
        /* create an image for the logo and pack it as vbox's 1st child */
        GtkWidget *imglogo = GTK_WIDGET(
                    gtk_image_new_from_file("diablo/logo_370x189.png")
                    );
        gtk_box_pack_start( GTK_BOX(vbox), imglogo, FALSE, FALSE, 0 );
    
        /* create an image for the blizzard stripe & pack it as vbox's last child */
        GtkWidget *imgbliz = GTK_WIDGET(
                    gtk_image_new_from_file("diablo/bliz_768x41.png")
                    );
        gtk_box_pack_end( GTK_BOX(vbox), imgbliz, FALSE, FALSE, 0 );
    
        /* create an hbox to host the play-image and
          pack it as vbox's one-before-the-last child */
        GtkWidget *hboxplay = gtk_hbox_new( FALSE, 0 );
        gtk_box_pack_end( GTK_BOX(vbox), hboxplay, FALSE, FALSE, 0 );
    
        /* create the play-image, wrap it inside an event-box
           and make invisible the window of the event-box */
        GtkWidget *imgplay = GTK_WIDGET(
                    gtk_image_new_from_file("diablo/play.png")
                    );
        GtkWidget *ebplay = gtk_event_box_new();
        gtk_container_add( GTK_CONTAINER(ebplay), imgplay );
        gtk_event_box_set_visible_window( GTK_EVENT_BOX(ebplay), FALSE );
    
        /* pack the event-box as hbox's last (and only) child */
        gtk_box_pack_end( GTK_BOX(hboxplay), ebplay, FALSE, FALSE, 0 );
    
    
        /* connect signal handlers for the main window */
        g_signal_connect(
            G_OBJECT(w),
            "delete-event", G_CALLBACK(gtk_main_quit),
            NULL
            );
        g_signal_connect(
            G_OBJECT(w),
            "destroy",
            G_CALLBACK(gtk_main_quit),
            NULL
            );
    
        /* connect signal handlers for the event-box that holds the play-image*/
        g_signal_connect(
            G_OBJECT( ebplay ),
            "button-release-event",
            G_CALLBACK( gtk_main_quit ),
            NULL
            );
    
        /* all set, go */
        gtk_widget_show_all( w );
        gtk_main();
    
        g_object_unref( bgpixbuf );
    
        return 0;
    }
    I've also attached a .7z file, that additionally contains the pictures and a Win32 executable (to close the window, click on the play-image with either mouse-button).

    PS. Btw, as you can see, properly laying out the widgets may become quite tedious and error-prone. The more complex the layout, the more tedious & error-prone it becomes. That's where Glade comes to the rescue (along with using a GtkBuilder object for loading the .glade file into your program).

    EDIT:

    Forgot to give the link to the .7z file:

    https://app.box.com/s/rt1ck8m1ninu6s81992k1a3d6wh3fcpc
    Last edited by migf1; 07-10-2015 at 10:40 AM. Reason: link to the .7z file
    "Talk is cheap, show me the code" - Linus Torvalds

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Tictactoe x and o locations.
    By xTonyLeo in forum C Programming
    Replies: 10
    Last Post: 01-27-2013, 06:12 PM
  2. New pointer locations
    By mica in forum C Programming
    Replies: 2
    Last Post: 03-23-2011, 08:31 AM
  3. Benifits of differnt file locations
    By peckitt99 in forum Tech Board
    Replies: 3
    Last Post: 08-22-2007, 12:16 PM
  4. writing to certain locations.
    By epidemic in forum C++ Programming
    Replies: 2
    Last Post: 12-19-2006, 12:12 PM
  5. file i/o locations
    By algi in forum C++ Programming
    Replies: 4
    Last Post: 01-16-2005, 11:21 AM