console_t *uimon_window_open(void)
{
GtkWidget *scrollbar, *horizontal_container;
if (fixed.window == NULL) {
fixed.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fixed.window), "VICE monitor");
gtk_window_set_position(GTK_WINDOW(fixed.window), GTK_WIN_POS_CENTER);
gtk_widget_set_app_paintable(fixed.window, TRUE);
gtk_window_set_deletable(GTK_WINDOW(fixed.window), TRUE);
fixed.term = vte_terminal_new();
vte_terminal_set_scrollback_lines (VTE_TERMINAL(fixed.term), 1000);
vte_terminal_set_scroll_on_output (VTE_TERMINAL(fixed.term), TRUE);
scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment (VTE_TERMINAL(fixed.term)));
horizontal_container = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(fixed.window), horizontal_container);
gtk_container_add(GTK_CONTAINER(horizontal_container), fixed.term);
gtk_container_add(GTK_CONTAINER(horizontal_container), scrollbar);
g_signal_connect(G_OBJECT(fixed.window), "delete-event",
G_CALLBACK(close_window), &fixed.input_buffer);
g_signal_connect(G_OBJECT(fixed.term), "key-press-event",
G_CALLBACK(key_press_event), &fixed.input_buffer);
g_signal_connect(G_OBJECT(fixed.term), "button-press-event",
G_CALLBACK(button_press_event), &fixed.input_buffer);
vte_console.console_xres = vte_terminal_get_column_count(VTE_TERMINAL(fixed.term));
vte_console.console_yres = vte_terminal_get_row_count(VTE_TERMINAL(fixed.term));
vte_console.console_can_stay_open = 1;
}
return uimon_window_resume();
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1deletable
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _setting
)
{
GtkWindow* self;
gboolean setting;
// convert parameter self
self = (GtkWindow*) _self;
// convert parameter setting
setting = (gboolean) _setting;
// call function
gtk_window_set_deletable(self, setting);
// cleanup parameter self
// cleanup parameter setting
}
int
ShowProgressUI()
{
if (!sEnableUI)
return -1;
// Only show the Progress UI if the process is taking a significant amount of
// time where a significant amount of time is defined as .5 seconds after
// ShowProgressUI is called sProgress is less than 70.
usleep(500000);
if (sQuit || sProgressVal > 70.0f)
return 0;
char ini_path[PATH_MAX];
snprintf(ini_path, sizeof(ini_path), "%s.ini", sProgramPath);
StringTable strings;
if (ReadStrings(ini_path, &strings) != OK)
return -1;
sWin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if (!sWin)
return -1;
static GdkPixbuf *pixbuf;
char icon_path[PATH_MAX];
snprintf(icon_path, sizeof(icon_path), "%s.png", sProgramPath);
g_signal_connect(G_OBJECT(sWin), "delete_event",
G_CALLBACK(OnDeleteEvent), NULL);
gtk_window_set_title(GTK_WINDOW(sWin), strings.title);
gtk_window_set_type_hint(GTK_WINDOW(sWin), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_position(GTK_WINDOW(sWin), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_resizable(GTK_WINDOW(sWin), FALSE);
gtk_window_set_decorated(GTK_WINDOW(sWin), TRUE);
gtk_window_set_deletable(GTK_WINDOW(sWin),FALSE);
pixbuf = gdk_pixbuf_new_from_file (icon_path, NULL);
gtk_window_set_icon(GTK_WINDOW(sWin), pixbuf);
g_object_unref(pixbuf);
GtkWidget *vbox = gtk_vbox_new(TRUE, 6);
sLabel = gtk_label_new(strings.info);
gtk_misc_set_alignment(GTK_MISC(sLabel), 0.0f, 0.0f);
sProgressBar = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), sLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), sProgressBar, TRUE, TRUE, 0);
sTimerID = g_timeout_add(TIMER_INTERVAL, UpdateDialog, NULL);
gtk_container_set_border_width(GTK_CONTAINER(sWin), 10);
gtk_container_add(GTK_CONTAINER(sWin), vbox);
gtk_widget_show_all(sWin);
gtk_main();
return 0;
}
void iceb_gdite(class iceb_gdite_data *data,int metka_bar,GtkWidget *wpredok)
{
data->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable(GTK_WINDOW(data->window),FALSE); /*запрет на изменение размеров окна*/
gtk_window_set_deletable(GTK_WINDOW(data->window),FALSE); /*Выключить кнопку close в рамке окна*/
if(wpredok != NULL)
{
// gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data->window),GTK_WINDOW(wpredok));
}
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data->window),TRUE);
/*Окно поверх всех окон*/
gtk_window_set_keep_above(GTK_WINDOW(data->window),TRUE);
char bros[312];
sprintf(bros,"%s %s",name_system,gettext("Ждите !"));
gtk_window_set_title (GTK_WINDOW (data->window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data->window), 5);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add (GTK_CONTAINER (data->window), vbox);
GtkWidget *label=gtk_label_new(gettext("Ждите !"));
GdkColor color;
gdk_color_parse("red",&color);
gtk_widget_modify_fg(label,GTK_STATE_NORMAL,&color);
gtk_widget_set_size_request(GTK_WIDGET(label),300,-1);
gtk_box_pack_start(GTK_BOX (vbox), label, TRUE, TRUE, 0);
if(metka_bar == 0)
{
data->bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data->bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data->bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data->bar, FALSE, FALSE, 2);
}
//gtk_window_set_default_size (GTK_WINDOW (data->window),300,-1);
gtk_window_set_position( GTK_WINDOW(data->window),ICEB_POS_CENTER);
gtk_widget_show_all(data->window);
gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
iceb_refresh();
}
bool VideoRenderer::Init()
{
#ifndef GOCAST_PLUGIN
if(NULL!=m_pWindow || NULL!=m_pRenderArea)
{
return false;
}
m_pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if(NULL == m_pWindow)
{
return false;
}
gtk_window_set_position(GTK_WINDOW(m_pWindow), GTK_WIN_POS_NONE);
gtk_window_set_default_size(GTK_WINDOW(m_pWindow), m_width, m_height);
gtk_window_set_resizable(GTK_WINDOW(m_pWindow), FALSE);
gtk_window_set_deletable(GTK_WINDOW(m_pWindow), FALSE);
gtk_window_set_title(GTK_WINDOW(m_pWindow), m_peerName.c_str());
gtk_container_set_border_width(GTK_CONTAINER(m_pWindow), 0);
m_pRenderArea = gtk_drawing_area_new();
if(NULL == m_pRenderArea)
{
return false;
}
gtk_widget_set_size_request(m_pRenderArea, m_width, m_height);
gtk_container_add(GTK_CONTAINER(m_pWindow), m_pRenderArea);
gtk_widget_show_all(m_pWindow);
#else
pthread_mutex_lock(&pluginWinMutex);
if(NULL != pThePluginWindow)
{
FB::PluginWindowX11* pThePluginWindowX11 =
reinterpret_cast<FB::PluginWindowX11*>(pThePluginWindow);
m_pRenderArea = pThePluginWindowX11->getWidget();
}
pthread_mutex_unlock(&pluginWinMutex);
if(NULL != s_pHead)
{
s_pHead->SetPrev(this);
}
m_rendererIndex = s_numRenderers;
s_pHead = this;
#endif
s_numRenderers++;
return true;
}
GtkWidget *
create_throbber_dialog (const gchar *title,
GtkWidget **label)
{
GtkWidget *dialog;
GtkWidget *status_label;
GtkWidget *hbox, *throbber;
GtkWidget *main_box, *main_alignment;
dialog = gtk_dialog_new_with_buttons (title,
NULL,
GTK_DIALOG_NO_SEPARATOR,
NULL);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 0);
gtk_window_set_deletable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "gtk-info");
/* Create the main alignment for the dialog */
main_alignment = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 0, 0, 6, 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0);
/* Create the main box for the dialog */
main_box = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (main_box), 12);
gtk_container_add (GTK_CONTAINER (main_alignment), main_box);
/* Top horizontal box for the throbber */
hbox= gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
gtk_container_add (GTK_CONTAINER (main_box), hbox);
/* Add the throbber */
throbber = katze_throbber_new ();
katze_throbber_set_animated (KATZE_THROBBER (throbber), TRUE);
gtk_box_pack_end (GTK_BOX (hbox), throbber, FALSE, FALSE, 0);
/* Status label*/
status_label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (status_label),
_("<span weight=\"bold\" stretch=\"semiexpanded\">"
"Status</span>"));
gtk_misc_set_alignment (GTK_MISC (status_label), 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), status_label, FALSE, FALSE, 0);
/* Information label */
*label = gtk_label_new ("");
gtk_container_add (GTK_CONTAINER (main_box), *label);
gtk_widget_show_all (GTK_DIALOG(dialog)->vbox);
return dialog;
}
//* Asklang is now a special plugin loaded before all others plugins *//
int ask_language()
{
void *handle;
void *(*infop) (void);
char *ptr = g_strdup_printf("%s/%s", PLUGINDIR, "asklang.so");
if ((handle = dlopen(ptr, RTLD_NOW)) == NULL)
{
fprintf(stderr, "%s", dlerror());
FREE(ptr);
return(1);
}
FREE(ptr);
if ((infop = dlsym(handle, "info")) == NULL)
{
fprintf(stderr, "%s", dlerror());
return(1);
}
plugin_t *pluginlang = infop();
pluginlang->handle = handle;
GtkWidget *pBoite = gtk_dialog_new_with_buttons("Language selection (default : en_US)",
NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_OK,GTK_RESPONSE_OK,
NULL);
gtk_widget_set_size_request (pBoite, 800, 600);
gtk_window_set_deletable ( GTK_WINDOW ( pBoite ), FALSE );
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file (g_strdup_printf("%s/headlogo.png", IMAGEDIR), NULL);
if(!pixbuf)
{
fprintf(stdout, "error message: can't load images/headlogo.png\n");
}
else
{
/* Set it as icon window */
gtk_window_set_icon(GTK_WINDOW (pBoite),pixbuf);
}
g_object_unref(pixbuf);
GtkWidget *langtab = pluginlang->load_gtk_widget();
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), langtab, TRUE, TRUE, 5);
gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox);
gtk_dialog_run(GTK_DIALOG(pBoite));
pluginlang->run(&config);
gtk_widget_destroy(pBoite);
return 0;
}
static GtkWindow *create_window()
{
GtkWindow *window;
GtkBox *vbox;
GtkButton *btn_abort;
GtkAlignment *align;
char buf[256];
window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_title(window, "File Sender");
/* padding */
gtk_container_border_width(GTK_CONTAINER(window), 10);
/* hide max/min button */
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DIALOG);
/* disable close button */
gtk_window_set_deletable(window, FALSE);
/* modal */
gtk_window_set_modal(window, TRUE);
vbox = GTK_BOX(gtk_vbox_new(FALSE, 10));
sprintf(buf, "Sending file %s...", filename);
lb_message = GTK_LABEL(gtk_label_new(buf));
gtk_box_pack_start(vbox, GTK_WIDGET(lb_message), FALSE, FALSE, 0);
lb_progress = GTK_LABEL(gtk_label_new("0 / 0"));
gtk_box_pack_start(vbox, GTK_WIDGET(lb_progress), FALSE, FALSE, 0);
lb_status = GTK_LABEL(gtk_label_new("INIT"));
gtk_box_pack_start(vbox, GTK_WIDGET(lb_status), FALSE, FALSE, 0);
btn_abort = GTK_BUTTON(gtk_button_new_with_label("Abort!"));
gtk_widget_set_size_request(GTK_WIDGET(btn_abort), 100, 40);
g_signal_connect(
GTK_OBJECT(btn_abort), "clicked",
GTK_SIGNAL_FUNC(cb_abort), NULL);
align = GTK_ALIGNMENT(gtk_alignment_new(0.5, 0.5, 0, 0));
gtk_container_add(GTK_CONTAINER(align), GTK_WIDGET(btn_abort));
gtk_box_pack_start(vbox, GTK_WIDGET(align), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(vbox));
gtk_widget_show_all(GTK_WIDGET(window));
return window;
}
int lassi_osd_init(LassiOsdInfo *osd) {
GtkWidget *hbox;
g_assert(osd);
memset(osd, 0, sizeof(*osd));
osd->window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_title(GTK_WINDOW(osd->window), "Mango Lassi OSD");
gtk_window_stick(GTK_WINDOW(osd->window));
gtk_window_set_keep_above(GTK_WINDOW(osd->window), TRUE);
gtk_window_set_decorated(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_deletable(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(osd->window), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(osd->window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(osd->window), TRUE);
gtk_window_set_accept_focus(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_focus_on_map(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_gravity(GTK_WINDOW(osd->window), GDK_GRAVITY_SOUTH_WEST);
gtk_widget_set_app_paintable(GTK_WIDGET(osd->window), TRUE);
g_signal_connect(osd->window, "draw", G_CALLBACK(draw_cb), NULL);
osd->label = gtk_label_new("Test");
gtk_misc_set_padding(GTK_MISC(osd->label), 16, 0);
/* gtk_label_set_line_wrap(GTK_LABEL(osd->label), TRUE); */
osd->left_icon = gtk_image_new();
osd->right_icon = gtk_image_new();
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
gtk_box_pack_start(GTK_BOX(hbox), osd->left_icon, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), osd->label, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), osd->right_icon, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(osd->window), hbox);
gtk_widget_show(hbox);
gtk_widget_show(osd->label);
gtk_widget_realize(GTK_WIDGET(osd->window));
/*g_debug("WINDOW=%p", osd->window);*/
return 0;
}
/* create and populate a dialog with a request to scan a finger plus a cancel
* button. hook onto the response signal in order to listen for cancellation. */
GtkWidget *create_scan_finger_dialog(void)
{
GtkWidget *dialog, *label, *progressbar;
GtkWidget *vbox;
dialog = gtk_dialog_new_with_buttons("Scan finger", GTK_WINDOW(mwin_window),
GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_deletable(GTK_WINDOW(dialog), FALSE);
vbox = GTK_DIALOG(dialog)->vbox;
label = gtk_label_new("Scan your finger now");
gtk_box_pack_start_defaults(GTK_BOX(vbox), label);
progressbar = gtk_progress_bar_new();
gtk_box_pack_end_defaults(GTK_BOX(vbox), progressbar);
g_object_set_data(G_OBJECT(dialog), "progressbar", progressbar);
return dialog;
}
/* [gtk thread] */
static gboolean create_native_text_log(gpointer data)
{
Msg *msg = data;
ALLEGRO_NATIVE_DIALOG *textlog = msg->dialog;
/* Create a new text log window. */
GtkWidget *top = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(top), 640, 480);
gtk_window_set_title(GTK_WINDOW(top), al_cstr(textlog->title));
if (textlog->flags & ALLEGRO_TEXTLOG_NO_CLOSE) {
gtk_window_set_deletable(GTK_WINDOW(top), false);
}
else {
g_signal_connect(G_OBJECT(top), "key-press-event", G_CALLBACK(textlog_key_press), textlog);
}
g_signal_connect(G_OBJECT(top), "delete-event", G_CALLBACK(textlog_delete), textlog);
g_signal_connect(G_OBJECT(top), "destroy", G_CALLBACK(dialog_destroy), textlog);
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(top), scroll);
GtkWidget *view = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(view), false);
if (textlog->flags & ALLEGRO_TEXTLOG_MONOSPACE) {
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string("Monospace");
gtk_widget_modify_font(view, font_desc);
pango_font_description_free(font_desc);
}
gtk_container_add(GTK_CONTAINER(scroll), view);
gtk_widget_show(view);
gtk_widget_show(scroll);
gtk_widget_show(top);
textlog->window = top;
textlog->tl_textview = view;
ASSERT(textlog->async_queue);
g_async_queue_push(textlog->async_queue, ACK_OPENED);
return FALSE;
}
extern "C" const char *Init( int *argc, char ***argv )
{
// Need to use external library to load this image. Native loader seems broken :/
const gchar *splash_image_path = "Data/splash.png";
GtkWidget *vbox;
gtk_disable_setlocale();
if( !gtk_init_check(argc,argv) )
return "Couldn't initialize gtk (cannot open display)";
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(window), GTK_WIN_POS_CENTER );
gtk_widget_set_size_request(window,468,-1);
gtk_window_set_deletable( GTK_WINDOW(window), FALSE );
gtk_window_set_resizable(GTK_WINDOW(window),FALSE);
gtk_window_set_role( GTK_WINDOW(window), "sm-startup" );
//gtk_window_set_icon( GTK_WINDOW(window), );
gtk_widget_realize(window);
splash = gtk_image_new_from_file(splash_image_path);
label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(label),GTK_JUSTIFY_CENTER);
gtk_label_set_ellipsize(GTK_LABEL(label),PANGO_ELLIPSIZE_END);
gtk_label_set_line_wrap(GTK_LABEL(label),FALSE);
progressBar = gtk_progress_bar_new();
gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(progressBar), 0.0 );
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window),vbox);
gtk_box_pack_start(GTK_BOX(vbox),splash,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(vbox),progressBar,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(vbox),label,TRUE,TRUE,0);
gtk_widget_show_all(window);
gtk_main_iteration_do(FALSE);
return NULL;
}
G_MODULE_EXPORT void initialise(void* inst) {
plugInstStruct* pl = (plugInstStruct*)inst;
pl->data = malloc(sizeof(simpleOutVars));
// the plugins GUI
simpleOutVars* vars = ((simpleOutVars*)pl->data);
vars->window = (GtkWindow*)gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_deletable (vars->window, FALSE);
vars->label = (GtkLabel*)gtk_label_new ("");
gchar* l = g_strdup_printf ("Port %s = 0x%02x",(const gchar *)&pl->name,0);
gtk_label_set_text (vars->label,l);
g_free(l);
gtk_container_add (GTK_CONTAINER (vars->window), (GtkWidget*)vars->label);
gtk_widget_show_all ( (GtkWidget*)vars->window );
}
static gboolean do_show_display_menu(gpointer data)
{
ARGS *args = lock_args(data);
if (!args->menu->extra1) {
GtkWidget *gtk_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
GtkWidget *menu_bar = gtk_menu_bar_new();
gtk_window_set_deletable(GTK_WINDOW(gtk_window), FALSE);
build_menu(menu_bar, args->menu);
gtk_container_add(GTK_CONTAINER(gtk_window), menu_bar);
gtk_widget_show(menu_bar);
gtk_window_set_default_size(GTK_WINDOW(gtk_window), 320, 32);
args->menu->extra1 = menu_bar;
}
gtk_widget_show(gtk_widget_get_parent(args->menu->extra1));
return release_args(args);
}
static GtkWidget *
mca_info_panel_host (GtkWidget *panel)
{
GtkWidget *window;
//host panel inside a normal window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(panel));
gtk_window_set_title(GTK_WINDOW (window), "Mkahawa Cyber Client");
gtk_widget_hide_on_delete(window);
//gtk_window_set_position(GTK_WINDOW (window), GTK_WIN_POS_NONE);
gtk_window_stick(GTK_WINDOW (window));
gtk_window_set_keep_above(GTK_WINDOW (window), TRUE);
//gtk_window_set_decorated(GTK_WINDOW (window), FALSE);
gtk_window_set_deletable(GTK_WINDOW (window), FALSE);
gtk_window_set_resizable(GTK_WINDOW (window), FALSE);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (ipnl_destroy),
G_OBJECT (window));
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (ipnl_delete_event),
NULL);
g_signal_connect (G_OBJECT (window), "window-state-event",
G_CALLBACK (ipnl_window_state_event),
ipnl->tray_icon);
ipnl->wnd_ipnl = window;
gtk_widget_show_all(window);
return window;
}
static void _copy_files_async_true(GFile *src,gpointer data)
{
g_debug("_copy_files_async_true start");
TDData* _data = (TDData*) data;
dest_pb = _data->dest_file;
_copy_cancellable = _data->cancellable;
GtkWidget *parent = NULL;
GtkWidget *progress_bar = NULL;
const char* basename = g_file_get_basename(src);
parent = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_deletable(GTK_WINDOW(parent),FALSE);
gtk_window_set_position(GTK_WINDOW(parent),GTK_WIN_POS_CENTER);
gtk_widget_set_size_request(parent, 400, 30);
gtk_window_set_title(GTK_WINDOW(parent),basename);
gtk_window_set_resizable(GTK_WINDOW(parent),FALSE);
g_signal_connect (G_OBJECT (parent), "delete_event", G_CALLBACK (progress_bar_delete_event), NULL);
gtk_widget_show(parent);
progress_bar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(parent),progress_bar);
gtk_widget_show(progress_bar);
#if DEBUG
char* src_uri = g_file_get_uri (src);
char* dest_uri = g_file_get_uri (dest_pb);
g_debug ("_copy_files_async: copy %s to %s", src_uri, dest_uri);
g_free (src_uri);
g_free (dest_uri);
#endif
g_file_copy_async(src, dest_pb, G_FILE_COPY_NOFOLLOW_SYMLINKS,
G_PRIORITY_DEFAULT, _copy_cancellable, g_file_copy_progress_handler,
progress_bar, g_file_copy_async_finish_handler, progress_bar);
}
void
show_countdown_dialog (PurplePlugin * plugin) {
GtkWidget *content_area;
GtkWidget *img;
GtkWidget *hbox, *vbox;
GtkWidget *progress_bar;
GtkWidget *gtkconv_window;
GtkWidget *blist_window;
GtkWidget *label = NULL;
g_assert (plugin != NULL && plugin->extra != NULL);
g_assert (PLUGIN (countdown_dialog) == NULL);
progress_bar = gtk_progress_bar_new ();
img =
gtk_image_new_from_stock (PIDGIN_STOCK_INFO,
gtk_icon_size_from_name
(PIDGIN_ICON_SIZE_TANGO_SMALL));
hbox = gtk_hbox_new (FALSE, PIDGIN_HIG_BOX_SPACE);
vbox = gtk_vbox_new (FALSE, PIDGIN_HIG_BOX_SPACE);
gtkconv_window = get_receiver_window (plugin);
blist_window = pidgin_blist_get_default_gtk_blist ()->window;
PLUGIN (countdown_dialog) =
gtk_dialog_new_with_buttons (PLUGIN_NAME,
GTK_WINDOW ((gtkconv_window) ?
gtkconv_window :
blist_window),
0, GTK_STOCK_EXECUTE,
GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT, NULL);
gtk_window_set_resizable (GTK_WINDOW (PLUGIN (countdown_dialog)), FALSE);
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progress_bar), 0.05);
g_object_set_data (G_OBJECT (PLUGIN (countdown_dialog)), "progress-bar",
progress_bar);
label = gtk_label_new (COUNTDOWN_MSG);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), 0);
#if GTK_CHECK_VERSION (2,14,0)
content_area =
gtk_dialog_get_content_area (GTK_DIALOG (PLUGIN (countdown_dialog)));
#else
content_area = (GTK_DIALOG (PLUGIN (countdown_dialog)))->vbox;
#endif
gtk_window_set_deletable (GTK_WINDOW (PLUGIN (countdown_dialog)), FALSE);
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
gtk_box_pack_start_defaults (GTK_BOX (vbox), hbox);
gtk_box_pack_start (GTK_BOX (hbox), img, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), progress_bar, FALSE, FALSE, 0);
gtk_widget_show_all (PLUGIN (countdown_dialog));
purple_timeout_add (250, (GSourceFunc) update_countdown, plugin);
g_signal_connect_swapped (G_OBJECT (PLUGIN (countdown_dialog)),
"response",
G_CALLBACK (on_countdown_dialog_response_cb),
plugin);
}
int gui_calls_manager_init(SphoneManager *manager)
{
g_calls_manager.manager=manager;
g_calls_manager.main_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(g_calls_manager.main_window),"Active Calls");
gtk_window_set_deletable(GTK_WINDOW(g_calls_manager.main_window),FALSE);
gtk_window_set_default_size(GTK_WINDOW(g_calls_manager.main_window),400,220);
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *s = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (s),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
g_calls_manager.dials_view = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(g_calls_manager.dials_view),FALSE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("Photo", renderer, "pixbuf", GUI_CALLS_COLUMN_PHOTO, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", GUI_CALLS_COLUMN_DESC, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", GUI_CALLS_COLUMN_STATUS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);
g_calls_manager.dials_store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING, SPHONE_TYPE_CALL, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gtk_tree_view_set_model(GTK_TREE_VIEW(g_calls_manager.dials_view), GTK_TREE_MODEL(g_calls_manager.dials_store));
GtkWidget *h1=gtk_hbox_new(FALSE, 0);
GtkWidget *h2=gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(s), g_calls_manager.dials_view);
gtk_container_add(GTK_CONTAINER(v1), s);
gtk_box_pack_start(GTK_BOX(v1), h1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(v1), h2, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(g_calls_manager.main_window), v1);
gtk_widget_show_all(v1);
g_calls_manager.answer_button=gtk_button_new_with_label("\nAnswer\n");
g_calls_manager.answer_waiting_button=gtk_button_new_with_label("\nAnswer\n");
g_calls_manager.activate_button=gtk_button_new_with_label("\nActivate\n");
g_calls_manager.hangup_button=gtk_button_new_with_label("\nHangup\n");
g_calls_manager.mute_button=gtk_button_new_with_label("\nMute ringing\n");
g_calls_manager.speaker_button=gtk_button_new_with_label("\nSpeaker\n");
g_calls_manager.handset_button=gtk_button_new_with_label("\nHandset\n");
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.activate_button);
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_button);
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_waiting_button);
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.hangup_button);
gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.mute_button);
gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.speaker_button);
gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.handset_button);
g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"cursor-changed", G_CALLBACK(gui_calls_select_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"row-activated", G_CALLBACK(gui_calls_double_click_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.activate_button),"clicked", G_CALLBACK(gui_calls_activate_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.answer_button),"clicked", G_CALLBACK(gui_calls_answer_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.answer_waiting_button),"clicked", G_CALLBACK(gui_calls_answer_waiting_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.hangup_button),"clicked", G_CALLBACK(gui_calls_hangup_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.mute_button),"clicked", G_CALLBACK(gui_calls_mute_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.speaker_button),"clicked", G_CALLBACK(gui_calls_speaker_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.handset_button),"clicked", G_CALLBACK(gui_calls_handset_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.main_window),"delete-event", G_CALLBACK(return_true),NULL);
g_signal_connect(G_OBJECT(manager),"call_added", G_CALLBACK(gui_calls_new_call_callback),NULL);
return 0;
}
void r_poiprov(class prov_poi_data *rekv_m_poiprov,GtkWidget *wpredok)
{
char strsql[512];
r_poiprov_data data;
data.rek_poi=rekv_m_poiprov;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
gtk_window_set_resizable(GTK_WINDOW(data.window),FALSE); /*запрет на изменение размеров окна*/
gtk_window_set_deletable(GTK_WINDOW(data.window),FALSE); /*Выключить кнопку close в рамке окна*/
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
sprintf(strsql,"%s %s",name_system,gettext("Распечатка проводок"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
//gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
GtkWidget *label=gtk_label_new(gettext("Ждите !!!"));
gtk_widget_set_size_request(GTK_WIDGET(label),300,-1);
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
label=gtk_label_new(gettext("Распечатка проводок"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
gtk_widget_show_all(data.window);
gtk_idle_add((GtkFunction)r_poiprov1,&data);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
iceb_rabfil(&data.imaf,&data.naim,"",0,wpredok);
}
void SetupHashWindow()
{
/* Setup window */
gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes");
gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340);
gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false);
gui.fixed.hash = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash);
/* Load hashes */
gui.entries.hash = gtk_entry_new();
gtk_widget_set_size_request(gui.entries.hash, 380, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8);
gui.cbox.hash = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain");
gtk_widget_set_size_request(gui.cbox.hash, 90, 32);
gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8);
gui.buttons.hash_load = gtk_button_new_with_label("Load");
gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8);
/* TreeView */
gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.hash.tree = gtk_tree_view_new();
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true);
gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store));
gui.hash.render = gtk_cell_renderer_text_new();
GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL);
gtk_tree_view_column_set_sort_column_id(col, 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL);
gtk_tree_view_column_set_sort_column_id(col, 2);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree);
gtk_widget_set_size_request(gui.hash.tree, 560, 240);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48);
/* Buttons */
gui.buttons.hash_delete = gtk_button_new_with_label("Remove");
gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300);
gui.buttons.hash_clear = gtk_button_new_with_label("Clear");
gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300);
gui.buttons.hash_ok = gtk_button_new_with_label("OK");
gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300);
g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL);
g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL);
g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL);
g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL);
return;
}
//login_window
int login_window()
{
GtkWidget *table;
GtkWidget *username;
GtkWidget *passwd;
GtkWidget *logo;
GtkWidget *submit,*quit;
GtkWidget *hbox;
//登陆窗口初始化
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (win, WIN_W, WIN_H);//设置主窗口默认打开大小
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_decorated (GTK_WINDOW(win), FALSE); //包含标题栏，右边界
//gtk_window_set_title (GTK_WINDOW(win), "login");
gtk_window_set_resizable ((GtkWindow *)win,FALSE); //固定窗口显示大小
gtk_container_set_border_width(GTK_CONTAINER(win),0);//窗口空白边界大小
gtk_window_set_deletable(GTK_WINDOW(win),FALSE); //禁止叉叉可以关闭
// g_signal_connect (G_OBJECT(win), "destroy",
// G_CALLBACK(gtk_main_quit), NULL);//X可关闭
//添加背景
update_widget_bg(win, LOGIN_WIN);
//创建table容器，并添加到窗口中
table = gtk_table_new(WIN_W,WIN_H,TRUE);
gtk_container_add(GTK_CONTAINER(win),table);
//创建文本框和登陆按钮
username = gtk_entry_new();
passwd = gtk_entry_new();
gtk_entry_set_visibility (GTK_ENTRY(passwd),FALSE); //密码文字不可见
submit = gtk_button_new_with_label("登陆");
quit = gtk_button_new_with_label("退出");
//将按钮放入vbox
hbox = gtk_hbox_new(TRUE,5);
gtk_box_pack_start(GTK_BOX(hbox),submit,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox),quit,TRUE,TRUE,0);
//构件大小设置
gtk_widget_set_size_request(username, 205, 30); //设置大小
gtk_widget_set_size_request(passwd, 205, 30); //设置大小
// gtk_widget_set_size_request(hbox, 145, 40); //设置大小
//添加构件到容器中
gtk_table_attach_defaults(GTK_TABLE(table),username,95,250, 140 ,177);
gtk_table_attach_defaults(GTK_TABLE(table),passwd,95,250, 180 ,217);
gtk_table_attach_defaults(GTK_TABLE(table),hbox,100,245, 240 ,280);
g_signal_connect(G_OBJECT(quit),"clicked",G_CALLBACK(hide_child_window),GTK_WINDOW(win));
g_signal_connect(G_OBJECT(submit),"clicked",G_CALLBACK(login_submit_callback),GTK_WINDOW(win));
//鼠标事件捕获
gtk_widget_set_events(win, // 设置窗体获取鼠标事件
GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
gtk_signal_connect(GTK_OBJECT(win), "button_press_event",
(GtkSignalFunc) button_press_event, win); // 加入事件回调
gtk_signal_connect(GTK_OBJECT(win), "motion_notify_event",
(GtkSignalFunc) motion_notify_event, win);
gtk_signal_connect(GTK_OBJECT(win), "button_release_event",
(GtkSignalFunc) button_release_event, win);
gtk_widget_show_all(win);
return 0;
}
console_t *uimon_window_open(void)
{
GtkWidget *scrollbar, *horizontal_container;
GdkGeometry hints;
if (fixed.window == NULL) {
fixed.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fixed.window), "VICE monitor");
gtk_window_set_position(GTK_WINDOW(fixed.window), GTK_WIN_POS_CENTER);
gtk_widget_set_app_paintable(fixed.window, TRUE);
gtk_window_set_deletable(GTK_WINDOW(fixed.window), TRUE);
fixed.term = vte_terminal_new();
vte_terminal_set_scrollback_lines (VTE_TERMINAL(fixed.term), 1000);
vte_terminal_set_scroll_on_output (VTE_TERMINAL(fixed.term), TRUE);
/* allowed window widths are base_width + width_inc * N
* allowed window heights are base_height + height_inc * N
*/
hints.width_inc = vte_terminal_get_char_width (VTE_TERMINAL(fixed.term));
hints.height_inc = vte_terminal_get_char_height (VTE_TERMINAL(fixed.term));
/* min size should be multiple of .._inc, else we get funky effects */
hints.min_width = hints.width_inc;
hints.min_height = hints.height_inc;
/* base size should be multiple of .._inc, else we get funky effects */
hints.base_width = hints.width_inc;
hints.base_height = hints.height_inc;
gtk_window_set_geometry_hints (GTK_WINDOW (fixed.window),
fixed.term,
&hints,
GDK_HINT_RESIZE_INC |
GDK_HINT_MIN_SIZE |
GDK_HINT_BASE_SIZE);
#if GTK_CHECK_VERSION (2, 91, 1)
{
glong width, height;
get_terminal_size_in_chars(VTE_TERMINAL(fixed.term), &width, &height);
gtk_window_resize_to_geometry (GTK_WINDOW (fixed.window), width, height);
}
#endif
scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment (VTE_TERMINAL(fixed.term)));
horizontal_container = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(fixed.window), horizontal_container);
gtk_container_add(GTK_CONTAINER(horizontal_container), fixed.term);
gtk_container_add(GTK_CONTAINER(horizontal_container), scrollbar);
g_signal_connect(G_OBJECT(fixed.window), "delete-event",
G_CALLBACK(close_window), &fixed.input_buffer);
g_signal_connect(G_OBJECT(fixed.term), "key-press-event",
G_CALLBACK(key_press_event), &fixed.input_buffer);
g_signal_connect(G_OBJECT(fixed.term), "button-press-event",
G_CALLBACK(button_press_event), &fixed.input_buffer);
g_signal_connect (fixed.term, "text-modified",
G_CALLBACK (screen_resize_window_cb), NULL);
vte_console.console_can_stay_open = 1;
}
return uimon_window_resume();
}
static void
gtk_vlc_player_init(GtkVlcPlayer *klass)
{
GtkWidget *drawing_area;
GdkColor color;
libvlc_event_manager_t *evman;
klass->priv = GTK_VLC_PLAYER_GET_PRIVATE(klass);
gtk_alignment_set(GTK_ALIGNMENT(klass), 0., 0., 1., 1.);
drawing_area = gtk_drawing_area_new();
gdk_color_parse("black", &color);
gtk_widget_modify_bg(drawing_area, GTK_STATE_NORMAL, &color);
g_signal_connect(G_OBJECT(drawing_area), "realize",
G_CALLBACK(widget_on_realize), klass);
gtk_widget_add_events(drawing_area, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(drawing_area), "button-press-event",
G_CALLBACK(widget_on_click), klass);
gtk_container_add(GTK_CONTAINER(klass), drawing_area);
gtk_widget_show(drawing_area);
/*
* drawing area will be destroyed automatically with the
* GtkContainer/GtkVlcPlayer
* (it is derived from GtkObject and has one reference after adding it
* to the container).
*/
klass->priv->time_adjustment = gtk_adjustment_new(0., 0., 0.,
GTK_VLC_PLAYER_TIME_ADJ_STEP,
GTK_VLC_PLAYER_TIME_ADJ_PAGE,
0.);
g_object_ref_sink(klass->priv->time_adjustment);
klass->priv->time_adj_on_value_changed_id =
g_signal_connect(G_OBJECT(klass->priv->time_adjustment),
"value-changed",
G_CALLBACK(time_adj_on_value_changed), klass);
klass->priv->time_adj_on_changed_id =
g_signal_connect(G_OBJECT(klass->priv->time_adjustment),
"changed",
G_CALLBACK(time_adj_on_changed), klass);
klass->priv->volume_adjustment = gtk_adjustment_new(1., 0., 1.,
GTK_VLC_PLAYER_VOL_ADJ_STEP,
GTK_VLC_PLAYER_VOL_ADJ_PAGE,
0.);
g_object_ref_sink(klass->priv->volume_adjustment);
klass->priv->vol_adj_on_value_changed_id =
g_signal_connect(G_OBJECT(klass->priv->volume_adjustment),
"value-changed",
G_CALLBACK(vol_adj_on_value_changed), klass);
klass->priv->vlc_inst = create_vlc_instance();
klass->priv->media_player = libvlc_media_player_new(klass->priv->vlc_inst);
/* sign up for time updates */
evman = libvlc_media_player_event_manager(klass->priv->media_player);
libvlc_event_attach(evman, libvlc_MediaPlayerTimeChanged,
vlc_time_changed, klass);
libvlc_event_attach(evman, libvlc_MediaPlayerLengthChanged,
vlc_length_changed, klass);
klass->priv->isFullscreen = FALSE;
klass->priv->fullscreen_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_object_ref_sink(klass->priv->fullscreen_window);
gtk_window_set_deletable(GTK_WINDOW(klass->priv->fullscreen_window),
FALSE);
gtk_window_set_decorated(GTK_WINDOW(klass->priv->fullscreen_window),
FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(klass->priv->fullscreen_window),
TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(klass->priv->fullscreen_window),
TRUE);
gtk_window_set_keep_above(GTK_WINDOW(klass->priv->fullscreen_window),
TRUE);
}
/*! \fn gboolean CDesktopAppChooser::m_InitLayoutUI(GtkWidget *pwGtkParent, int nPosX, int nPosY)
\brief Initialize Desktop App Chooser UI(widgets).
\param[in] pwGtkParent. The top-level window object.
\param[in] nPosX. The X-axis position of Desktop App Chooser window.
\param[in] nPosY. The Y-axis position of Desktop App Chooser window.
\return TRUE or FALSE
*/
gboolean CDesktopAppChooser::m_InitLayoutUI(GtkWidget *pwGtkParent, int nPosX, int nPosY)
{
GtkWidget *window = NULL, *scrollWin = NULL;
GtkWidget *buttonApply = NULL, *buttonClose = NULL;
GtkWidget *pFixedContainer = NULL;
GtkWidget *treeView = NULL;
gboolean bRet = TRUE;
/* To store the top-level GTK dialog window. */
if(pwGtkParent != NULL)
{
m_pwParent = pwGtkParent;
}
//-------------- Create a main window for the file add/remove dialog.
/* Create a new window object */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* Set the size of the new window. */
gtk_widget_set_size_request(window, 330, 400);
/* Set the title of the window. */
gtk_window_set_title(GTK_WINDOW(window), WINDOW_TITLE);
/* Set the window to be irresizable. */
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
/* If you set the deletable property to FALSE using this function,
GTK+ will do its best to convince the window manager not to show a close button. */
gtk_window_set_deletable(GTK_WINDOW(window), FALSE);
/* The event mask of the widget determines, what kind of event will a particular widget receive.
This set all bit-flags of the Desktop App Chooser window to receive all events. */
gtk_widget_add_events(window, GDK_ALL_EVENTS_MASK);
/* Set the position of the Desktop App Chooser window on the desktop. */
gtk_window_move(GTK_WINDOW(window), nPosX, nPosY);
/* Connect the "destroy" event to a signal handler.
This event occurs when we call gtk_widget_destroy() on the window,
or if we return 'FALSE' in the "delete_event" callback. */
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
/* Store the required widgets ... */
m_pWidgets[APPCHOOSER_GtkWindow_Main] = window;
//-------------- Create the gtk fixed container
/* The main fixed window in main window */
pFixedContainer = gtk_fixed_new();
/* Add the main fixed window into the main window */
gtk_container_add(GTK_CONTAINER (window), pFixedContainer);
//-------------- Create a scrolled window widget instance.
/* Create a scroll window object. */
scrollWin = gtk_scrolled_window_new(NULL, NULL);
/* Set the scroll showing policy. */
gtk_scrolled_window_set_policy((GtkScrolledWindow*)(scrollWin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Set the shadow type of the scrolling window. */
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollWin), GTK_SHADOW_ETCHED_IN);
//-------------- Create a TreeView widget instance with list-type model(e.g. data)
/* Create a tree view object. */
treeView = m_CreateTreeView();
/* Hide the header of the tree view. */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeView), FALSE);
/* Get the tree view selection object from the tree view object. */
m_TreeSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeView));
/* Add the tree view widget into scrolling window. */
gtk_container_add(GTK_CONTAINER(scrollWin), treeView);
/* Set the scrolling window's size. */
gtk_widget_set_size_request(scrollWin, 310, 340);
/* Put scrolling window to the fixed windows. */
gtk_fixed_put(GTK_FIXED(pFixedContainer), scrollWin, 10, 10);
/* Store the required widgets. */
m_pWidgets[APPCHOOSER_GtkTreeView] = treeView;
/* Get and store the tree view selection object. */
m_pWidgets[APPCHOOSER_GtkTreeSelection] = (GtkWidget*)gtk_tree_view_get_selection(GTK_TREE_VIEW(treeView));
//-------------- Create button widget instances
/* The button to confirm the user has chosen wanted application. */
/* Create a button instance. */
buttonApply = gtk_button_new_with_label(_("Apply")); /* gtk_button_new_from_stock(GTK_STOCK_APPLY); */ // If you want to use inbuilt button, use gtk_button_new_from_stock() instead.
/* Set the location in the fixed container. */
gtk_fixed_put(GTK_FIXED(pFixedContainer), buttonApply, 240, 365);
/* Set the widget's size. */
gtk_widget_set_size_request(buttonApply, 80, 30);
/* Set the signal connection for the "add" button */
g_signal_connect(GTK_OBJECT(buttonApply), "clicked", G_CALLBACK(on_file_apply), this);
/* The button to exit Desktop App Chooser. */
/* Create a button instance. */
buttonClose = gtk_button_new_from_stock(GTK_STOCK_CLOSE); /* gtk_button_new_with_label(_("Close")); */ // If you want to use multi-language, use button_new_with_label() instead.
/* Set the location of the button in the fixed container. */
gtk_fixed_put(GTK_FIXED(pFixedContainer), buttonClose, 150, 365);
/* Set the button's size. */
gtk_widget_set_size_request(buttonClose, 80, 30);
/* Set the signal connection for the "Cancel" button.
This will cause the window to be destroyed by
calling gtk_widget_destroy(window) when "clicked" event happens.
The destroy signal could come from here, or the window manager. */
g_signal_connect(GTK_OBJECT(buttonClose), "clicked", G_CALLBACK(on_close), this);
return bRet;
}
