ipdf-svn/src/GtkAuthDialog.cpp Source File

00001 /* 
00002  * Copyright (C) 2006, iRex Technologies B.V.
00003  *
00004  * This program is free software; you can redistribute it and/or modify
00005  * it under the terms of the GNU General Public License as published by
00006  * the Free Software Foundation; either version 2, or (at your option)
00007  * any later version.
00008  *
00009  * This program is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program; if not, write to the Free Software
00016  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017  */
00018 
00019 #include "GtkAuthDialog.h"
00020 #include "liberdm/erdm.h"
00021 #include "PDFView.h"
00022 #include "controller.h"
00023 #include <glib.h>
00024 #include <gtk/gtk.h>
00025 #include <libintl.h>
00026 #include <locale.h>
00027 
00028 // define macro for string resource. i18n/g11n
00029 #define _(string)       gettext(string)
00030 #define N_(string)      string
00031 
00032 // for the whole dialog
00033 #define PINCODE_SCREEN_WIDTH        768         
00034 #define PINCODE_SCREEN_HEIGHT       SCREEN_HEIGHT
00035 
00036 // for client area
00037 #define PINCODE_BACKGROUND_WIDTH    707         
00038 #define PINCODE_BACKGROUND_HEIGHT   347
00039 #define PINCODE_BG_PADDING_LEFT     (PINCODE_SCREEN_WIDTH - PINCODE_BACKGROUND_WIDTH)/2
00040 #define PINCODE_BG_PADDING_RIGHT    PINCODE_BG_PADDING_LEFT
00041 #define PINCODE_BG_PADDING_BOTTOM   270
00042 #define PINCODE_BG_PADDING_TOP      540
00043 
00044 // title message "Enter the password to open the protected document."
00045 #define PINCODE_MESSAGE_PADDING     5
00046 #define PINCODE_MESSAGE_LABEL_WIDTH  PINCODE_BACKGROUND_WIDTH
00047 #define PINCODE_MESSAGE_LABEL_HEIGHT 30
00048 
00049 // input entry
00050 #define PINCODE_INPUT_XPOS          150
00051 #define PINCODE_INPUT_YPOS          0
00052 #define PINCODE_INPUT_WIDTH         200
00053 #define PINCODE_INPUT_HEIGHT        30
00054 
00055 // button
00056 #define PINCODE_BUTTON_XPOS         450
00057 #define PINCODE_BUTTON_YPOS         0
00058 #define PINCODE_BUTTON_WIDTH        100
00059 #define PINCODE_BUTTON_HEIGHT       30
00060 #define PINCODE_BUTTON_OFFSET       30
00061 
00062 // error message
00063 #define PINCODE_ERRORMSG_XPOS       150
00064 #define PINCODE_ERRORMSG_YPOS       0
00065 #define PINCODE_ERRORMSG_WIDTH      400
00066 #define PINCODE_ERRORMSG_HEIGHT     30
00067 
00068 
00069 #define GTK_PINCODE_SCREEN_TYPE                 (gtk_pincode_screen_get_type ())
00070 #define GTK_PINCODE_SCREEN(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_PINCODE_SCREEN_TYPE, GtkPincodeScreen))
00071 #define GTK_PINCODE_SCREEN_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_PINCODE_SCREEN_TYPE, GtkPincodeScreenClass))
00072 #define IS_GTK_PINCODE_SCREEN(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_PINCODE_SCREEN_TYPE))
00073 #define IS_GTK_PINCODE_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_PINCODE_SCREEN_TYPE))
00074 
00075 
00076 static void gtk_pincode_screen_class_init(GtkPincodeScreenClass * klass);
00077 static void gtk_pincode_screen_init(GtkPincodeScreen * screen);
00078 static int  count = -1;  
00079 
00080 GtkWidget *gtk_pincode_screen_new()
00081 {
00082     GtkPincodeScreen *screen;
00083     screen = (GtkPincodeScreen *) g_object_new(GTK_PINCODE_SCREEN_TYPE, NULL);
00084     return GTK_WIDGET(screen);
00085 }
00086 
00087 
00088 GType gtk_pincode_screen_get_type(void)
00089 {
00090     static GType pincode_screen_type = 0;
00091 
00092     if (!pincode_screen_type)
00093     {
00094         static const GTypeInfo pincode_screen_info = {
00095             sizeof(GtkPincodeScreenClass),
00096             NULL,               /* base_init */
00097             NULL,               /* base_finalize */
00098             (GClassInitFunc) gtk_pincode_screen_class_init,
00099             NULL,               /* class_finalize */
00100             NULL,               /* class_data */
00101             sizeof(GtkPincodeScreen),
00102             0,                  /* n_preallocs */
00103             (GInstanceInitFunc) gtk_pincode_screen_init,
00104         };
00105         pincode_screen_type = g_type_register_static(GTK_TYPE_EVENT_BOX, "PincodeScreen", 
00106                     &pincode_screen_info, (GTypeFlags)0);
00107     }
00108     return pincode_screen_type;
00109 }
00110 
00111 // message widget "Enter the password to open the protected document".
00112 static GtkWidget *create_pincode_message_widget(GtkPincodeScreen * screen)
00113 {
00114     GtkWidget *messageLabel = NULL;
00115     
00116     // messageLabel 
00117     messageLabel = gtk_label_new(_("Enter the password to open the protected document"));
00118     gtk_box_pack_start(GTK_BOX(screen->clientArea), messageLabel, FALSE, FALSE, PINCODE_MESSAGE_PADDING);
00119     gtk_widget_set_name(messageLabel, "pincode_message_title_text");
00120     gtk_label_set_line_wrap(GTK_LABEL(messageLabel), TRUE);
00121     gtk_widget_set_size_request(messageLabel, PINCODE_MESSAGE_LABEL_WIDTH, PINCODE_MESSAGE_LABEL_HEIGHT);
00122     gtk_label_set_justify(GTK_LABEL(messageLabel), GTK_JUSTIFY_CENTER);
00123     
00124     return messageLabel;
00125 }
00126 
00127 // pin code input: input widget and ok/cancel buttons
00128 static GtkWidget *create_pincode_input_widget(GtkPincodeScreen * screen)
00129 {
00130     GtkWidget *fixed;
00131 
00132     // fixed
00133     fixed = gtk_fixed_new();
00134     gtk_box_pack_start(GTK_BOX(screen->clientArea), fixed, FALSE, FALSE, PINCODE_MESSAGE_PADDING);
00135     gtk_widget_set_size_request(GTK_WIDGET(fixed), -1, PINCODE_INPUT_HEIGHT);
00136     
00137     // input entry
00138     screen->inputWidget = gtk_entry_new();
00139     gtk_widget_set_name(GTK_WIDGET(screen->inputWidget), "pin_code_entry");
00140     gtk_entry_set_visibility(GTK_ENTRY(screen->inputWidget), FALSE);
00141     gtk_fixed_put(GTK_FIXED(fixed), screen->inputWidget, PINCODE_INPUT_XPOS, PINCODE_INPUT_YPOS);
00142     gtk_widget_set_size_request(GTK_WIDGET(screen->inputWidget), PINCODE_INPUT_WIDTH, -1);
00143    
00144     // ok Button
00145     screen->okButton = (GtkButton *)gtk_toggle_button_new();
00146     gtk_fixed_put(GTK_FIXED(fixed), GTK_WIDGET(screen->okButton), PINCODE_BUTTON_XPOS, PINCODE_BUTTON_YPOS);
00147     gtk_widget_set_size_request(GTK_WIDGET(screen->okButton), PINCODE_BUTTON_WIDTH, -1);
00148     gtk_button_set_label(GTK_BUTTON(screen->okButton), _("Confirm"));
00149 
00150     return fixed;
00151 }
00152 
00153 // error message widget "Password incorrect. Please try again."
00154 static GtkWidget *create_pincode_error_msg_widget(GtkPincodeScreen * screen)
00155 {
00156     if (count <= 0) 
00157     {
00158         screen->errorMsg = 0;
00159         return NULL;
00160     } 
00161            
00162     GtkWidget *fixed;
00163     fixed = gtk_fixed_new();
00164     gtk_box_pack_start(GTK_BOX(screen->clientArea), fixed, FALSE, FALSE, PINCODE_MESSAGE_PADDING);
00165     gtk_widget_set_size_request(GTK_WIDGET(fixed), -1, PINCODE_ERRORMSG_HEIGHT);
00166 
00167     // error msg label
00168     screen->errorMsg = gtk_label_new(_("Password incorrect. Please try again."));
00169     gtk_widget_set_name(screen->errorMsg, "pincode_message_error_text");
00170     gtk_label_set_line_wrap(GTK_LABEL(screen->errorMsg), TRUE);
00171     gtk_widget_set_size_request(screen->errorMsg, PINCODE_ERRORMSG_WIDTH, -1);
00172     gtk_label_set_justify(GTK_LABEL(screen->errorMsg), GTK_JUSTIFY_CENTER);
00173     gtk_fixed_put(GTK_FIXED(fixed), screen->errorMsg, PINCODE_ERRORMSG_XPOS, PINCODE_ERRORMSG_YPOS);
00174     return screen->errorMsg;
00175 }
00176 
00177 
00178 // create gtkPincodeScreen - set the default values 
00179 //
00180 // object hierarchy:
00181 // screen (GtkPincodeScreen background)
00182 //    |--alignment
00183 //       |--clientArea(GtkVBox)
00184 //          |--messageWidget
00185 //          |--inputWidget
00186 static void gtk_pincode_screen_init(GtkPincodeScreen * screen)
00187 {
00188     // tmp
00189     GtkWidget *alignment = NULL;
00190     GtkWidget *clientArea = NULL;      // GtkVBox
00191     GtkWidget *messageWidget = NULL;   // message widget
00192 
00193     // screen style
00194     gtk_widget_set_name(GTK_WIDGET(screen), "pincode_screen_background");
00195     gtk_widget_set_size_request(GTK_WIDGET(screen), PINCODE_SCREEN_WIDTH, PINCODE_SCREEN_HEIGHT);
00196 
00197     // alignment 
00198     alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
00199     gtk_container_add(GTK_CONTAINER(screen), GTK_WIDGET(alignment));
00200     gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
00201                               PINCODE_BG_PADDING_TOP,
00202                               PINCODE_BG_PADDING_BOTTOM, 
00203                               PINCODE_BG_PADDING_LEFT, 
00204                               PINCODE_BG_PADDING_RIGHT);
00205     
00206     // background, use event box to set bk image
00207     GtkWidget * bk = gtk_event_box_new();
00208     gtk_widget_set_size_request(GTK_WIDGET(bk), PINCODE_BACKGROUND_WIDTH, PINCODE_BACKGROUND_HEIGHT);
00209     gtk_widget_set_name(bk, "pincode_input_background");
00210     gtk_container_add(GTK_CONTAINER(alignment), bk);
00211 
00212     // client area
00213     clientArea = gtk_vbox_new(FALSE, PINCODE_MESSAGE_PADDING);
00214     gtk_container_add(GTK_CONTAINER(bk), clientArea);
00215     screen->clientArea = clientArea;
00216 
00217     // messageWidget
00218     messageWidget = create_pincode_message_widget(screen);
00219         
00220     // inputWidget
00221     create_pincode_input_widget(screen);
00222 
00223     // error message
00224     create_pincode_error_msg_widget(screen);    
00225 
00226     // signals 
00227     g_signal_connect(G_OBJECT(screen), "expose_event", 
00228         G_CALLBACK(GtkAuthDialog::exposeCbk), screen);
00229     g_signal_connect(G_OBJECT(screen), "destroy", 
00230         G_CALLBACK(GtkAuthDialog::destroyCbk), screen);
00231 
00232     // input
00233     g_signal_connect_after(G_OBJECT(screen->inputWidget), "focus-in-event",       
00234         G_CALLBACK(GtkAuthDialog::focusInCbk), screen);
00235     g_signal_connect_after(G_OBJECT(screen->inputWidget), "focus-out-event",      
00236         G_CALLBACK(GtkAuthDialog::focusOutCbk), screen);
00237     g_signal_connect_after(G_OBJECT(screen->inputWidget), "focus", 
00238         G_CALLBACK(GtkAuthDialog::focusCbk),  screen);
00239     g_signal_connect_after(G_OBJECT(screen->inputWidget), "move-cursor", 
00240         G_CALLBACK(GtkAuthDialog::moveCursorCbk), screen);
00241     g_signal_connect_after(G_OBJECT(screen->inputWidget), "changed",              
00242         G_CALLBACK(GtkAuthDialog::changedCbk), screen);
00243 
00244     // button
00245     g_signal_connect(G_OBJECT(screen->okButton), "clicked", 
00246         G_CALLBACK(GtkAuthDialog::buttonClickedCbk), screen);
00247     g_signal_connect(G_OBJECT(screen->okButton), "state-changed", 
00248         G_CALLBACK(GtkAuthDialog::buttonStateChangedCbk), screen);    
00249 
00250     // show widget 
00251     gtk_widget_show_all(GTK_WIDGET(screen));
00252 }
00253 
00254 
00255 // init class
00256 static void gtk_pincode_screen_class_init(GtkPincodeScreenClass * klass)
00257 {
00258     // nothing needs to be done here 
00259 }
00260 
00262 // gtk auth dialog
00263 GtkAuthDialog::GtkAuthDialog(void)
00264 : dialog(NULL)
00265 , view(NULL)
00266 , bOk(gFalse)
00267 , bUpdate(gFalse)
00268 {
00269 }
00270 
00271 GtkAuthDialog::~GtkAuthDialog(void)
00272 {
00273 }
00274 
00275 void GtkAuthDialog::initPincodeDialog()
00276 {
00277     dialog = (GtkPincodeScreen *)g_object_new(GTK_PINCODE_SCREEN_TYPE, NULL);
00278     gtk_container_add(GTK_CONTAINER(view->getWindow()), GTK_WIDGET(dialog));
00279     gtk_widget_show_all(GTK_WIDGET(view->getWindow()));
00280     dialog->authDialog = this;
00281 }
00282 
00283 int GtkAuthDialog::popupAuthDialog(CPDFView * p)
00284 {
00285     ++count;
00286     view = p;
00287     initPincodeDialog();
00288     gtk_main();
00289     return bOk;
00290 }
00291 
00292 static gboolean updateScreen(gpointer data)
00293 {
00294     CPDFView * view = (CPDFView *)data;
00295     XSync(view->ctrl->gtkMgr.display, gTrue);
00296     view->refreshDeviceScreen(dmQTyping);
00297     return FALSE;
00298 }
00299 
00300 gboolean GtkAuthDialog::exposeCbk(GtkPincodeScreen * dialog,
00301                                   GdkEventExpose * event, gpointer user_data)
00302 {
00303     // grab focus, do not refresh screen now. 
00304     // focusInCbk will be invoked
00305     dialog->authDialog->bUpdate = gFalse;
00306     gtk_widget_grab_focus(dialog->inputWidget);
00307 
00308     // popup keyboard
00309     if (count <= 0)
00310     {
00311         dialog->authDialog->view->ctrl->channels.popupKeyboard();
00312     }
00313     else
00314     {
00315         gtk_idle_add(updateScreen, dialog->authDialog->view);
00316         
00317     }        
00318     dialog->authDialog->view->ctrl->channels.busy_off();
00319     return FALSE;
00320 }
00321 
00322 gboolean GtkAuthDialog::focusInCbk(GtkWidget *widget, 
00323         GdkEventFocus * event, gpointer data)
00324 {
00325     GtkPincodeScreen * screen = (GtkPincodeScreen *)data;
00326     if (!screen->authDialog->bUpdate)
00327     {
00328         screen->authDialog->bUpdate = gTrue;
00329         return FALSE;
00330     }
00331     screen->authDialog->view->refreshDeviceScreen(dmQTyping);
00332     return FALSE;
00333 }
00334 
00335 gboolean GtkAuthDialog::focusOutCbk(GtkWidget *widget, 
00336         GdkEventFocus * event, gpointer data)
00337 {
00338     GtkPincodeScreen * screen = (GtkPincodeScreen *)data;
00339     if (!screen->authDialog->bUpdate)
00340     {
00341         return FALSE;
00342     }        
00343     screen->authDialog->view->refreshDeviceScreen(dmQTyping);
00344     return FALSE;
00345 }        
00346 
00347 gboolean GtkAuthDialog::focusCbk(GtkWidget * widget, 
00348         GtkDirectionType arg1, gpointer data)
00349 {
00350     GtkPincodeScreen * screen = (GtkPincodeScreen *)data;
00351     screen->authDialog->view->refreshDeviceScreen(dmQTyping);
00352     return FALSE;
00353 }
00354 
00355 void GtkAuthDialog::changedCbk(GtkEditable * widget, 
00356         gpointer data)
00357 {
00358     GtkPincodeScreen * screen = (GtkPincodeScreen *)data;
00359     screen->authDialog->view->refreshDeviceScreen(dmQTyping);
00360     return;
00361 }
00362 
00363 void GtkAuthDialog::moveCursorCbk(GtkEntry * widget, 
00364         GtkMovementStep arg1, gint arg2, gboolean arg3, gpointer data)
00365 {
00366     GtkPincodeScreen * screen = (GtkPincodeScreen *)data;
00367     screen->authDialog->view->refreshDeviceScreen(dmQTyping);
00368     return;
00369 }
00370 
00371 
00372 void GtkAuthDialog::buttonClickedCbk(GtkToggleButton * button, 
00373         gpointer user_data)
00374 {
00375     GtkPincodeScreen * screen = (GtkPincodeScreen *)user_data;
00376     screen->authDialog->view->ctrl->channels.busy_blink();
00377     screen->authDialog->bOk = gFalse;
00378     screen->authDialog->bUpdate = gFalse;
00379     if (GTK_BUTTON(button) == screen->okButton)
00380     {
00381         screen->authDialog->bOk = gTrue;
00382         memset(screen->authDialog->password, 0, MAX_PASSWORD_LENGTH);
00383         strncpy(screen->authDialog->password, gtk_entry_get_text(GTK_ENTRY(screen->inputWidget)), MAX_PASSWORD_LENGTH);
00384     }
00385     gtk_container_remove(GTK_CONTAINER(screen->authDialog->view->getWindow()), GTK_WIDGET(screen));
00386     gtk_main_quit();
00387     return;
00388 }        
00389 
00390 void GtkAuthDialog::buttonStateChangedCbk(GtkWidget * button, 
00391         GtkStateType state, gpointer data)
00392 {
00393    
00394     GtkStateType betterstate = GTK_STATE_NORMAL;
00395     GtkStyle *style = NULL;
00396     GtkWidget *button_label = NULL;
00397 
00398     g_return_if_fail(GTK_IS_TOGGLE_BUTTON(button));
00399 
00400     button_label = gtk_bin_get_child(GTK_BIN(button));
00401     style = gtk_widget_get_style(button_label);
00402 
00403     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)) || (state == GTK_STATE_ACTIVE))
00404     {
00405         betterstate = GTK_STATE_ACTIVE;
00406     }
00407     else
00408     {
00409         betterstate = GTK_STATE_NORMAL;
00410     }
00411 
00412     if (style->fg[GTK_STATE_PRELIGHT].red != style->fg[betterstate].red
00413         || style->fg[GTK_STATE_PRELIGHT].green != style->fg[betterstate].green
00414         || style->fg[GTK_STATE_PRELIGHT].blue != style->fg[betterstate].blue)
00415     {
00416         gtk_widget_modify_fg(button_label, GTK_STATE_PRELIGHT, &(style->fg[betterstate]));
00417     }
00418     
00419     GtkPincodeScreen * screen = (GtkPincodeScreen *)data;    
00420     screen->authDialog->view->refreshDeviceScreen(dmQTyping);
00421     return;
00422 }
00423 
00424 gboolean GtkAuthDialog::destroyCbk(GtkPincodeScreen * dialog, 
00425                                    GdkEvent * event, gpointer user_data)
00426 {
00427     return FALSE;
00428 }
00429 
00430 
00431