~midori/midori/per-site-preferences : revision 6509

82

83

gint last_window_width, last_window_height;

84

guint alloc_timeout;

85

gint last_tab_size;

86

85

guint panel_timeout;

87

86

88

87

MidoriWebSettings* settings;

202

201

midori_browser_add_speed_dial (MidoriBrowser* browser);

203

202

204

203

static void

205

midori_browser_notebook_size_allocate_cb (GtkWidget* notebook,

206

GdkRectangle* allocation,

207

MidoriBrowser* browser);

208

209

static void

210

204

midori_browser_step_history (MidoriBrowser* browser,

211

205

MidoriView* view);

212

206

220

214

gtk_toggle_action_set_active (GTK_TOGGLE_ACTION ( \

221

215

_action_by_name (brwsr, nme)), actv);

222

216

217

static void

218

midori_browser_disconnect_tab (MidoriBrowser* browser,

219

MidoriView* view);

220

223

221

static gboolean

224

222

midori_browser_is_fullscreen (MidoriBrowser* browser)

225

223

{

236

234

gboolean show_tabs = !midori_browser_is_fullscreen (browser) || ignore_fullscreen;

237

235

if (!browser->show_tabs)

238

236

show_tabs = FALSE;

239

#ifdef HAVE_GRANITE

240

granite_widgets_dynamic_notebook_set_show_tabs (

241

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), show_tabs);

242

#else

243

if (!(has_tabs || katze_object_get_boolean (browser->settings, "always-show-tabbar")))

244

show_tabs = FALSE;

245

gtk_notebook_set_show_tabs (GTK_NOTEBOOK (browser->notebook), show_tabs);

246

gtk_notebook_set_show_border (GTK_NOTEBOOK (browser->notebook), show_tabs);

247

#endif

237

midori_notebook_set_labels_visible (MIDORI_NOTEBOOK (browser->notebook), show_tabs);

248

238

return has_tabs;

249

239

}

250

240

451

441

"tooltip", _("Stop loading the current page"), NULL);

452

442

}

453

443

454

gtk_widget_set_sensitive (browser->throbber, loading);

455

katze_throbber_set_animated (KATZE_THROBBER (browser->throbber), loading);

444

g_object_set (browser->throbber, "active", loading, "visible", loading, NULL);

456

445

}

457

446

458

447

/**

782

771

}

783

772

784

773

static void

785

midori_view_notify_minimized_cb (GtkWidget* widget,

786

GParamSpec* pspec,

787

MidoriBrowser* browser)

788

{

789

if (katze_object_get_boolean (widget, "minimized"))

790

{

791

#ifndef HAVE_GRANITE

792

GtkNotebook* notebook = GTK_NOTEBOOK (browser->notebook);

793

GtkWidget* label = gtk_notebook_get_tab_label (notebook, widget);

794

gtk_widget_set_size_request (label, -1, -1);

795

#endif

796

}

797

else

798

midori_browser_notebook_size_allocate_cb (NULL, NULL, browser);

799

}

800

801

static void

802

774

midori_view_notify_zoom_level_cb (GtkWidget* view,

803

775

GParamSpec* pspec,

804

776

MidoriBrowser* browser)

1401

1373

}

1402

1374

1403

1375

static void

1376

midori_view_destroy_cb (GtkWidget* view,

1377

MidoriBrowser* browser)

1378

{

1379

if (browser->proxy_array)

1380

{

1381

KatzeItem* item = midori_view_get_proxy_item (MIDORI_VIEW (view));

1382

if (katze_array_get_item_index (browser->proxy_array, item) != -1

1383

&& !midori_tab_is_blank (MIDORI_TAB (view)))

1384

{

1385

if (browser->trash)

1386

katze_array_add_item (browser->trash, item);

1387

midori_browser_update_history (item, "website", "leave");

1388

}

1389

midori_browser_disconnect_tab (browser, MIDORI_VIEW (view));

1390

g_signal_emit (browser, signals[REMOVE_TAB], 0, view);

1391

}

1392

}

1393

1394

static void

1404

1395

midori_view_attach_inspector_cb (GtkWidget* view,

1405

1396

GtkWidget* inspector_view,

1406

1397

MidoriBrowser* browser)

1785

1776

gint

1786

1777

midori_browser_get_n_pages (MidoriBrowser* browser)

1787

1778

{

1788

#ifdef HAVE_GRANITE

1789

return granite_widgets_dynamic_notebook_get_n_tabs (

1790

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook));

1791

#else

1792

return gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook));

1793

#endif

1794

}

1795

1796

static void

1797

midori_browser_disconnect_tab (MidoriBrowser* browser,

1798

MidoriView* view);

1799

1800

static gboolean

1801

midori_browser_tab_connected (MidoriBrowser* browser,

1802

MidoriView* view)

1803

{

1804

return browser->proxy_array &&

1805

(katze_array_get_item_index (browser->proxy_array, midori_view_get_proxy_item (view)) != -1);

1779

return midori_notebook_get_count (MIDORI_NOTEBOOK (browser->notebook));

1806

1780

}

1807

1781

1808

1782

static void

1809

1783

_midori_browser_remove_tab (MidoriBrowser* browser,

1810

1784

GtkWidget* widget)

1811

1785

{

1812

MidoriView* view = MIDORI_VIEW (widget);

1813

#ifdef HAVE_GRANITE

1814

granite_widgets_dynamic_notebook_remove_tab (

1815

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), midori_view_get_tab (view));

1816

#else

1817

1786

gtk_widget_destroy (widget);

1818

#endif

1819

if (midori_browser_tab_connected (browser, view))

1820

midori_browser_disconnect_tab (browser, view);

1821

}

1822

1823

#ifndef HAVE_GRANITE

1824

static void

1825

midori_browser_notebook_resize (MidoriBrowser* browser,

1826

GdkRectangle* allocation)

1827

{

1828

gint new_size = 0;

1829

gint n = MAX (1, gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook)));

1830

const gint max_size = 150;

1831

gint min_size;

1832

gint icon_size = 16;

1833

GtkAllocation notebook_size;

1834

GList* children;

1835

1836

if (allocation != NULL)

1837

notebook_size.width = allocation->width;

1838

else

1839

gtk_widget_get_allocation (browser->notebook, &notebook_size);

1840

new_size = notebook_size.width / n;

1841

1842

gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (browser->notebook),

1843

GTK_ICON_SIZE_MENU, &icon_size, NULL);

1844

min_size = icon_size;

1845

if (katze_object_get_boolean (browser->settings, "close-buttons-on-tabs"))

1846

min_size += icon_size;

1847

if (new_size < min_size) new_size = min_size;

1848

if (new_size > max_size) new_size = max_size;

1849

1850

if (new_size > browser->last_tab_size - 3

1851

&& new_size < browser->last_tab_size + 3)

1852

return;

1853

browser->last_tab_size = new_size;

1854

1855

children = gtk_container_get_children (GTK_CONTAINER (browser->notebook));

1856

for (; children; children = g_list_next (children))

1857

{

1858

GtkWidget* view = children->data;

1859

GtkWidget* label;

1860

label = gtk_notebook_get_tab_label (GTK_NOTEBOOK(browser->notebook), view);

1861

/* Don't resize empty bin, which is used for thumbnail tabs */

1862

if (GTK_IS_BIN (label) && gtk_bin_get_child (GTK_BIN (label))

1863

&& !katze_object_get_boolean (view, "minimized"))

1864

gtk_widget_set_size_request (label, new_size, -1);

1865

}

1866

}

1867

#endif

1868

1869

static void

1870

midori_browser_notebook_size_allocate_cb (GtkWidget* widget,

1871

GdkRectangle* allocation,

1872

MidoriBrowser* browser)

1873

{

1874

#ifndef HAVE_GRANITE

1875

if (!gtk_notebook_get_show_tabs (GTK_NOTEBOOK (browser->notebook)))

1876

return;

1877

1878

midori_browser_notebook_resize (browser, allocation);

1879

#endif

1880

1787

}

1881

1788

1882

1789

static void

1886

1793

KatzeItem* item = midori_view_get_proxy_item (MIDORI_VIEW (view));

1887

1794

katze_array_add_item (browser->proxy_array, item);

1888

1795

1889

gtk_widget_set_can_focus (view, TRUE);

1890

1796

g_object_connect (view,

1891

1797

"signal::notify::icon",

1892

1798

midori_view_notify_icon_cb, browser,

1898

1804

midori_view_notify_uri_cb, browser,

1899

1805

"signal::notify::title",

1900

1806

midori_view_notify_title_cb, browser,

1901

"signal::notify::minimized",

1902

midori_view_notify_minimized_cb, browser,

1903

1807

"signal::notify::zoom-level",

1904

1808

midori_view_notify_zoom_level_cb, browser,

1905

1809

"signal::notify::statusbar-text",

1920

1824

midori_view_search_text_cb, browser,

1921

1825

"signal::leave-notify-event",

1922

1826

midori_browser_tab_leave_notify_event_cb, browser,

1827

"signal::destroy",

1828

midori_view_destroy_cb, browser,

1923

1829

NULL);

1924

1830

}

1925

1831

1926

1832

static void

1927

midori_browser_add_tab_to_trash (MidoriBrowser* browser,

1928

MidoriView* view)

1929

{

1930

if (browser->proxy_array)

1931

{

1932

KatzeItem* item = midori_view_get_proxy_item (view);

1933

if (katze_array_get_item_index (browser->proxy_array, item) != -1)

1934

{

1935

if (!midori_view_is_blank (view))

1936

{

1937

if (browser->trash)

1938

katze_array_add_item (browser->trash, item);

1939

midori_browser_update_history (item, "website", "leave");

1940

}

1941

}

1942

}

1943

}

1944

1945

1946

static void

1947

1833

midori_browser_disconnect_tab (MidoriBrowser* browser,

1948

1834

MidoriView* view)

1949

1835

{

1974

1860

"any_signal",

1975

1861

midori_view_notify_title_cb, browser,

1976

1862

"any_signal",

1977

midori_view_notify_minimized_cb, browser,

1978

"any_signal",

1979

1863

midori_view_notify_zoom_level_cb, browser,

1980

1864

"any_signal",

1981

1865

midori_view_notify_statusbar_text_cb, browser,

2002

1886

_midori_browser_add_tab (MidoriBrowser* browser,

2003

1887

GtkWidget* view)

2004

1888

{

2005

GtkWidget* notebook = browser->notebook;

2006

1889

KatzeItem* item = midori_view_get_proxy_item (MIDORI_VIEW (view));

2007

#ifndef HAVE_GRANITE

2008

GtkWidget* tab_label;

2009

#endif

2010

1890

guint n;

2011

1891

2012

1892

midori_browser_connect_tab (browser, view);

2018

1898

katze_array_move_item (browser->proxy_array, item, n);

2019

1899

}

2020

1900

else

2021

n = midori_browser_get_n_pages (browser);

1901

n = -1;

2022

1902

katze_item_set_meta_integer (item, "append", -1);

2023

1903

2024

#ifdef HAVE_GRANITE

2025

granite_widgets_dynamic_notebook_insert_tab (

2026

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (notebook),

2027

midori_view_get_tab (MIDORI_VIEW (view)), n);

2028

#else

2029

tab_label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));

2030

/* Don't resize empty bin, which is used for thumbnail tabs */

2031

if (GTK_IS_BIN (tab_label) && gtk_bin_get_child (GTK_BIN (tab_label))

2032

&& !katze_object_get_boolean (view, "minimized"))

2033

gtk_widget_set_size_request (tab_label, browser->last_tab_size, -1);

2034

gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), view, tab_label, n);

2035

gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), view, TRUE);

2036

gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), view, TRUE);

2037

midori_browser_notebook_size_allocate_cb (browser->notebook, NULL, browser);

2038

#endif

1904

midori_notebook_insert (MIDORI_NOTEBOOK (browser->notebook), MIDORI_TAB (view), n);

2039

1905

2040

1906

_midori_browser_update_actions (browser);

2041

1907

}

3697

3563

gtk_widget_hide (browser->bookmarkbar);

3698

3564

gtk_widget_hide (browser->navigationbar);

3699

3565

gtk_widget_hide (browser->statusbar);

3700

#ifdef HAVE_GRANITE

3701

granite_widgets_dynamic_notebook_set_show_tabs (

3702

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), FALSE);

3703

#else

3704

gtk_notebook_set_show_tabs (GTK_NOTEBOOK (browser->notebook), FALSE);

3705

gtk_notebook_set_show_border (GTK_NOTEBOOK (browser->notebook), FALSE);

3706

#endif

3566

midori_notebook_set_labels_visible (MIDORI_NOTEBOOK (browser->notebook), FALSE);

3707

3567

3708

3568

gtk_window_fullscreen (GTK_WINDOW (browser));

3709

3569

}

4741

4601

else

4742

4602

g_assert_not_reached ();

4743

4603

4744

#ifdef HAVE_GRANITE

4745

granite_widgets_dynamic_notebook_set_tab_position (

4746

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook),

4747

midori_view_get_tab (MIDORI_VIEW (widget)), new_pos);

4748

#else

4749

gtk_notebook_reorder_child (GTK_NOTEBOOK (browser->notebook), widget, new_pos);

4750

#endif

4604

midori_notebook_move (MIDORI_NOTEBOOK (browser->notebook), MIDORI_TAB (widget), new_pos);

4751

4605

g_signal_emit (browser, signals[MOVE_TAB], 0, browser->notebook, cur_pos, new_pos);

4752

4606

}

4753

4607

4798

4652

_action_tab_duplicate_activate (GtkAction* action,

4799

4653

MidoriBrowser* browser)

4800

4654

{

4801

GtkWidget* view = midori_browser_get_current_tab (browser);

4655

GtkWidget* view = g_object_get_data (G_OBJECT (action), "tab");

4656

if (view == NULL)

4657

view = midori_browser_get_current_tab (browser);

4802

4658

midori_view_duplicate (MIDORI_VIEW (view));

4803

4659

}

4804

4660

5034

4890

}

5035

4891

5036

4892

static void

5037

midori_browser_switched_tab (MidoriBrowser* browser,

5038

GtkWidget* old_widget,

5039

MidoriView* new_view,

5040

gint new_page)

4893

midori_browser_switched_tab_cb (MidoriNotebook* notebook,

4894

GtkWidget* old_widget,

4895

MidoriView* new_view,

4896

MidoriBrowser* browser)

5041

4897

{

5042

4898

GtkAction* action;

5043

4899

const gchar* text;

5051

4907

g_strdup (text), g_free);

5052

4908

}

5053

4909

5054

if (new_view == NULL)

5055

{

5056

g_signal_emit (browser, signals[SWITCH_TAB], 0, old_widget, new_view);

5057

return;

5058

}

5059

5060

4910

g_return_if_fail (MIDORI_IS_VIEW (new_view));

4911

g_return_if_fail (new_view != MIDORI_VIEW (old_widget));

5061

4912

5062

4913

uri = g_object_get_data (G_OBJECT (new_view), "midori-browser-typed-text");

5063

4914

if (!uri)

5068

4919

if (midori_paths_get_runtime_mode () == MIDORI_RUNTIME_MODE_APP)

5069

4920

gtk_window_set_icon (GTK_WINDOW (browser), midori_view_get_icon (new_view));

5070

4921

5071

if (browser->proxy_array)

5072

katze_item_set_meta_integer (KATZE_ITEM (browser->proxy_array), "current", new_page);

4922

g_object_freeze_notify (G_OBJECT (browser));

4923

g_object_notify (G_OBJECT (browser), "uri");

5073

4924

g_object_notify (G_OBJECT (browser), "tab");

4925

g_object_thaw_notify (G_OBJECT (browser));

5074

4926

g_signal_emit (browser, signals[SWITCH_TAB], 0, old_widget, new_view);

5075

4927

5076

4928

_midori_browser_set_statusbar_text (browser, new_view, NULL);

5079

4931

}

5080

4932

5081

4933

static void

5082

midori_browser_notebook_page_reordered_cb (GtkWidget* notebook,

5083

MidoriView* view,

5084

guint page_num,

5085

MidoriBrowser* browser)

4934

midori_browser_tab_moved_cb (GtkWidget* notebook,

4935

MidoriView* view,

4936

guint page_num,

4937

MidoriBrowser* browser)

5086

4938

{

5087

4939

KatzeItem* item = midori_view_get_proxy_item (view);

5088

4940

katze_array_move_item (browser->proxy_array, item, page_num);

5089

4941

g_object_notify (G_OBJECT (browser), "tab");

5090

4942

}

5091

4943

5092

static GtkWidget*

4944

static void

5093

4945

midori_browser_notebook_create_window_cb (GtkWidget* notebook,

5094

4946

GtkWidget* view,

5095

4947

gint x,

5100

4952

g_signal_emit (browser, signals[NEW_WINDOW], 0, NULL, &new_browser);

5101

4953

if (new_browser)

5102

4954

{

5103

GtkWidget* new_notebook = new_browser->notebook;

5104

4955

gtk_window_move (GTK_WINDOW (new_browser), x, y);

5105

return new_notebook;

5106

}

5107

else /* No MidoriApp, so this is app or private mode */

5108

return NULL;

5109

}

5110

5111

#ifdef HAVE_GRANITE

5112

static void

5113

midori_browser_notebook_tab_added_cb (GtkWidget* notebook,

5114

GraniteWidgetsTab* tab,

5115

MidoriBrowser* browser)

5116

{

5117

gint n = granite_widgets_dynamic_notebook_get_tab_position (

5118

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (notebook), tab);

5119

midori_browser_set_current_page (browser, n);

5120

GtkWidget* view = midori_view_new_with_item (NULL, browser->settings);

5121

midori_view_set_tab (MIDORI_VIEW (view), tab);

5122

midori_browser_connect_tab (browser, view);

5123

midori_view_set_uri (MIDORI_VIEW (view), "about:new");

5124

/* FIXME: signal add-tab */

5125

_midori_browser_update_actions (browser);

5126

midori_browser_notebook_page_reordered_cb (GTK_WIDGET (notebook),

5127

MIDORI_VIEW (view), n, browser);

5128

}

5129

5130

static gboolean

5131

midori_browser_notebook_tab_removed_cb (GtkWidget* notebook,

5132

GraniteWidgetsTab* tab,

5133

MidoriBrowser* browser)

5134

{

5135

5136

MidoriView* view = MIDORI_VIEW (granite_widgets_tab_get_page (tab));

5137

if (midori_browser_tab_connected (browser, MIDORI_VIEW (view)))

5138

midori_browser_disconnect_tab (browser, MIDORI_VIEW (view));

5139

5140

return TRUE;

5141

}

5142

5143

static void

5144

midori_browser_move_tab_to_notebook (MidoriBrowser* browser,

5145

GtkWidget* view,

5146

GraniteWidgetsTab* tab,

5147

GtkWidget* new_notebook)

5148

{

5149

GraniteWidgetsTab* new_tab = granite_widgets_tab_new ("", NULL, NULL);

5150

g_object_ref (view);

5151

_midori_browser_remove_tab (browser, view);

5152

granite_widgets_dynamic_notebook_insert_tab (

5153

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (new_notebook), new_tab, 0);

5154

midori_view_set_tab (MIDORI_VIEW (view), new_tab);

5155

_midori_browser_update_actions (browser);

5156

midori_browser_connect_tab (midori_browser_get_for_widget (new_notebook), view);

5157

g_object_unref (view);

5158

}

5159

5160

static void

5161

midori_browser_notebook_tab_switched_cb (GraniteWidgetsDynamicNotebook* notebook,

5162

GraniteWidgetsTab* old_tab,

5163

GraniteWidgetsTab* new_tab,

5164

MidoriBrowser* browser)

5165

{

5166

gint new_pos = granite_widgets_dynamic_notebook_get_tab_position (notebook, new_tab);

5167

5168

midori_browser_switched_tab (browser,

5169

old_tab ? granite_widgets_tab_get_page (old_tab) : NULL,

5170

MIDORI_VIEW (granite_widgets_tab_get_page (new_tab)), new_pos);

5171

}

5172

5173

static void

5174

midori_browser_notebook_tab_moved_cb (GtkWidget* notebook,

5175

GraniteWidgetsTab* tab,

5176

gint old_pos,

5177

gboolean new_window,

5178

gint x,

5179

gint y,

5180

MidoriBrowser* browser)

5181

{

5182

GtkWidget* view = granite_widgets_tab_get_page (tab);

5183

if (new_window)

5184

{

5185

GtkWidget* notebook = midori_browser_notebook_create_window_cb (

5186

browser->notebook, view, x, y, browser);

5187

if (notebook != NULL)

5188

midori_browser_move_tab_to_notebook (browser, view, tab, notebook);

5189

}

5190

else

5191

{

5192

gint new_pos = granite_widgets_dynamic_notebook_get_tab_position (

5193

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (notebook), tab);

5194

midori_browser_notebook_page_reordered_cb (notebook,

5195

MIDORI_VIEW (view), new_pos, browser);

5196

}

5197

}

5198

5199

static void

5200

midori_browser_notebook_tab_duplicated_cb (GtkWidget* notebook,

5201

GraniteWidgetsTab* tab,

5202

MidoriBrowser* browser)

5203

{

5204

GtkWidget* view = granite_widgets_tab_get_page (tab);

5205

midori_view_duplicate (MIDORI_VIEW (view));

5206

}

5207

5208

#else

5209

static void

5210

midori_browser_notebook_page_added_cb (GtkNotebook* notebook,

5211

GtkWidget* child,

5212

guint page_num,

5213

MidoriBrowser* browser)

5214

{

5215

if (!midori_browser_tab_connected (browser, MIDORI_VIEW (child)))

5216

midori_browser_connect_tab (browser, child);

5217

midori_browser_notebook_page_reordered_cb (GTK_WIDGET (notebook),

5218

MIDORI_VIEW (child), page_num, browser);

5219

}

5220

5221

static void

5222

midori_browser_notebook_switch_page_cb (GtkWidget* notebook,

5223

gpointer page,

5224

guint page_num,

5225

MidoriBrowser* browser)

5226

{

5227

midori_browser_switched_tab (browser,

5228

midori_browser_get_current_tab (browser),

5229

MIDORI_VIEW (midori_browser_get_nth_tab (browser, page_num)), page_num);

5230

}

5231

5232

static void

5233

midori_browser_notebook_page_removed_cb (GtkWidget* notebook,

5234

GtkWidget* view,

5235

guint page_num,

5236

MidoriBrowser* browser)

5237

{

5238

if (midori_browser_tab_connected (browser, MIDORI_VIEW (view)))

5239

midori_browser_disconnect_tab (browser, MIDORI_VIEW (view));

5240

midori_browser_notebook_size_allocate_cb (browser->notebook, NULL, browser);

5241

}

5242

5243

static gboolean

5244

midori_browser_notebook_reorder_tab_cb (GtkNotebook* notebook,

5245

GtkDirectionType arg1,

5246

gboolean arg2,

5247

gpointer user_data)

5248

{

5249

g_signal_stop_emission_by_name (notebook, "reorder-tab");

5250

return TRUE;

5251

}

5252

5253

static void

5254

midori_browser_menu_item_switch_tab_cb (GtkWidget* menuitem,

5255

MidoriBrowser* browser)

5256

{

5257

gint page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuitem), "index"));

5258

midori_browser_set_current_page (browser, page);

5259

}

5260

5261

static gboolean

5262

midori_browser_notebook_button_press_event_after_cb (GtkNotebook* notebook,

5263

GdkEventButton* event,

5264

MidoriBrowser* browser)

5265

{

5266

#if !GTK_CHECK_VERSION(3,0,0) /* TODO */

5267

if (event->window != notebook->event_window)

5268

return FALSE;

5269

#endif

5270

5271

/* FIXME: Handle double click only when it wasn't handled by GtkNotebook */

5272

5273

/* Open a new tab on double click or middle mouse click */

5274

if (/*(event->type == GDK_2BUTTON_PRESS && event->button == 1)

5275

|| */(event->type == GDK_BUTTON_PRESS && MIDORI_EVENT_NEW_TAB (event)))

5276

{

5277

GtkWidget* view = midori_browser_add_uri (browser, "about:new");

5278

midori_browser_set_current_tab (browser, view);

5279

5280

return TRUE;

5281

}

5282

else if (event->type == GDK_BUTTON_PRESS && MIDORI_EVENT_CONTEXT_MENU (event))

5283

{

5284

MidoriContextAction* menu = midori_context_action_new ("NotebookContextMenu", NULL, NULL, NULL);

5285

midori_context_action_add_action_group (menu, browser->action_group);

5286

GList* tabs = midori_browser_get_tabs (browser);

5287

midori_context_action_add_by_name (menu, "TabNew");

5288

midori_context_action_add_by_name (menu, "UndoTabClose");

5289

midori_context_action_add (menu, NULL);

5290

gint i = 0;

5291

for (; tabs != NULL; tabs = g_list_next (tabs))

5292

{

5293

const gchar* title = midori_view_get_display_title (tabs->data);

5294

gchar* tab_option = g_strdup_printf ("Tab%u", i);

5295

GtkAction* action = gtk_action_new (tab_option, title, NULL, NULL);

5296

g_free (tab_option);

5297

gtk_action_set_gicon (GTK_ACTION (action), G_ICON (midori_view_get_icon (tabs->data)));

5298

g_object_set_data (G_OBJECT (action), "index", GINT_TO_POINTER (i));

5299

g_signal_connect (action, "activate",

5300

G_CALLBACK (midori_browser_menu_item_switch_tab_cb), browser);

5301

midori_context_action_add (menu, action);

5302

i++;

5303

}

5304

g_list_free (tabs);

5305

GtkMenu* context_menu = midori_context_action_create_menu (menu, NULL, FALSE);

5306

katze_widget_popup (GTK_WIDGET (notebook), context_menu, NULL,

5307

KATZE_MENU_POSITION_CURSOR);

5308

}

5309

5310

return FALSE;

5311

}

5312

#endif

4956

g_object_ref (view);

4957

midori_browser_disconnect_tab (browser, MIDORI_VIEW (view));

4958

midori_notebook_remove (MIDORI_NOTEBOOK (browser->notebook), MIDORI_TAB (view));

4959

midori_browser_add_tab (new_browser, view);

4960

g_object_unref (view);

4961

}

4962

}

4963

4964

static void

4965

midori_browser_notebook_new_tab_cb (GtkWidget* notebook,

4966

MidoriBrowser* browser)

4967

{

4968

GtkWidget* view = midori_browser_add_uri (browser, "about:new");

4969

midori_browser_set_current_tab (browser, view);

4970

}

4971

4972

static void

4973

midori_browser_notebook_context_menu_cb (MidoriNotebook* notebook,

4974

MidoriContextAction* menu,

4975

MidoriBrowser* browser)

4976

{

4977

midori_context_action_add_action_group (menu, browser->action_group);

4978

midori_context_action_add (menu, NULL);

4979

midori_context_action_add_by_name (menu, "TabNew");

4980

midori_context_action_add_by_name (menu, "UndoTabClose");

4981

}

4982

4983

static void

4984

midori_browser_notebook_tab_context_menu_cb (MidoriNotebook* notebook,

4985

MidoriTab* tab,

4986

MidoriContextAction* menu,

4987

MidoriBrowser* browser)

4988

{

4989

midori_context_action_add_action_group (menu, browser->action_group);

4990

midori_context_action_add (menu, NULL);

4991

midori_context_action_add_by_name (menu, "TabNew");

4992

midori_context_action_add_by_name (menu, "UndoTabClose");

4993

if (MIDORI_IS_VIEW (tab))

4994

{

4995

GtkAction* action = gtk_action_new ("TabDuplicate", _("_Duplicate Current Tab"), NULL, NULL);

4996

g_object_set_data (G_OBJECT (action), "tab", tab);

4997

g_signal_connect (action, "activate",

4998

G_CALLBACK (_action_tab_duplicate_activate), browser);

4999

midori_context_action_add (menu, action);

5000

}

5001

}

5313

5002

5314

5003

static void

5315

5004

_action_undo_tab_close_activate (GtkAction* action,

5760

5449

5761

5450

/* Destroy panel first, so panels don't need special care */

5762

5451

gtk_widget_destroy (browser->panel);

5763

#ifndef HAVE_GRANITE

5764

g_signal_handlers_disconnect_by_func (browser->notebook,

5765

midori_browser_notebook_reorder_tab_cb,

5766

NULL);

5767

g_signal_handlers_disconnect_by_func (browser->notebook,

5768

midori_browser_notebook_size_allocate_cb,

5769

browser);

5770

#endif

5771

5452

/* Destroy tabs second, so child widgets don't need special care */

5772

5453

gtk_container_foreach (GTK_CONTAINER (browser->notebook),

5773

5454

(GtkCallback) gtk_widget_destroy, NULL);

6288

5969

6289

5970

menuitem = gtk_menu_item_new ();

6290

5971

gtk_widget_show (menuitem);

6291

browser->throbber = katze_throbber_new ();

6292

gtk_widget_show (browser->throbber);

6293

gtk_container_add (GTK_CONTAINER (menuitem), browser->throbber);

6294

gtk_widget_set_sensitive (menuitem, FALSE);

5972

browser->throbber = gtk_spinner_new ();

5973

/* Wrap the spinner in an event box to retain its size when hidden */

5974

GtkWidget* throbber_box = gtk_event_box_new ();

5975

gtk_event_box_set_visible_window (GTK_EVENT_BOX (throbber_box), FALSE);

5976

gint icon_size = 16;

5977

gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (browser)),

5978

GTK_ICON_SIZE_MENU, &icon_size, NULL);

5979

gtk_widget_set_size_request (throbber_box, icon_size, icon_size);

5980

gtk_container_add (GTK_CONTAINER (throbber_box), browser->throbber);

5981

gtk_widget_show (throbber_box);

5982

gtk_container_add (GTK_CONTAINER (menuitem), throbber_box);

6295

5983

#if GTK_CHECK_VERSION (3, 2, 0)

6296

5984

/* FIXME: Doesn't work */

6297

5985

gtk_widget_set_hexpand (menuitem, TRUE);

6390

6078

vpaned = gtk_vpaned_new ();

6391

6079

gtk_paned_pack2 (GTK_PANED (hpaned), vpaned, TRUE, FALSE);

6392

6080

gtk_widget_show (vpaned);

6393

#ifdef HAVE_GRANITE

6394

/* FIXME: granite: should return GtkWidget* like GTK+ */

6395

browser->notebook = (GtkWidget*)granite_widgets_dynamic_notebook_new ();

6396

granite_widgets_dynamic_notebook_set_allow_new_window (

6397

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), TRUE);

6398

granite_widgets_dynamic_notebook_set_allow_duplication (

6399

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), TRUE);

6400

/* FIXME: work-around a bug */

6401

gtk_widget_show_all (browser->notebook);

6402

granite_widgets_dynamic_notebook_set_group_name (

6403

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), PACKAGE_NAME);

6404

#else

6405

browser->notebook = gtk_notebook_new ();

6406

gtk_notebook_set_scrollable (GTK_NOTEBOOK (browser->notebook), TRUE);

6407

#if GTK_CHECK_VERSION (3, 0, 0)

6408

gtk_notebook_set_group_name (GTK_NOTEBOOK (browser->notebook), PACKAGE_NAME);

6409

#else

6410

gtk_notebook_set_group_id (GTK_NOTEBOOK (browser->notebook), GPOINTER_TO_INT (PACKAGE_NAME));

6411

#endif

6412

#endif

6081

browser->notebook = midori_notebook_new ();

6413

6082

6414

#if !GTK_CHECK_VERSION (3, 0, 0)

6415

{

6416

/* Remove the inner border between scrollbars and the window border */

6417

GtkRcStyle* rcstyle = gtk_rc_style_new ();

6418

rcstyle->xthickness = 0;

6419

gtk_widget_modify_style (browser->notebook, rcstyle);

6420

g_object_unref (rcstyle);

6421

}

6422

#endif

6423

6083

gtk_paned_pack1 (GTK_PANED (vpaned), browser->notebook, FALSE, FALSE);

6424

#ifdef HAVE_GRANITE

6425

/* FIXME menu items */

6426

g_signal_connect (browser->notebook, "tab-added",

6427

G_CALLBACK (midori_browser_notebook_tab_added_cb),

6428

browser);

6429

g_signal_connect (browser->notebook, "tab-removed",

6430

G_CALLBACK (midori_browser_notebook_tab_removed_cb),

6431

browser);

6432

6084

g_signal_connect (browser->notebook, "tab-switched",

6433

G_CALLBACK (midori_browser_notebook_tab_switched_cb),

6085

G_CALLBACK (midori_browser_switched_tab_cb),

6434

6086

browser);

6435

6087

g_signal_connect (browser->notebook, "tab-moved",

6436

G_CALLBACK (midori_browser_notebook_tab_moved_cb),

6437

browser);

6438

g_signal_connect (browser->notebook, "tab-duplicated",

6439

G_CALLBACK (midori_browser_notebook_tab_duplicated_cb),

6440

browser);

6441

#else

6442

g_signal_connect (browser->notebook, "switch-page",

6443

G_CALLBACK (midori_browser_notebook_switch_page_cb),

6444

browser);

6445

g_signal_connect (browser->notebook, "page-reordered",

6446

G_CALLBACK (midori_browser_notebook_page_reordered_cb),

6447

browser);

6448

g_signal_connect (browser->notebook, "page-added",

6449

G_CALLBACK (midori_browser_notebook_page_added_cb),

6450

browser);

6451

g_signal_connect (browser->notebook, "page-removed",

6452

G_CALLBACK (midori_browser_notebook_page_removed_cb),

6453

browser);

6454

g_signal_connect (browser->notebook, "size-allocate",

6455

G_CALLBACK (midori_browser_notebook_size_allocate_cb),

6456

browser);

6457

g_signal_connect_after (browser->notebook, "button-press-event",

6458

G_CALLBACK (midori_browser_notebook_button_press_event_after_cb),

6459

browser);

6460

g_signal_connect (browser->notebook, "reorder-tab",

6461

G_CALLBACK (midori_browser_notebook_reorder_tab_cb), NULL);

6462

g_signal_connect (browser->notebook, "create-window",

6088

G_CALLBACK (midori_browser_tab_moved_cb),

6089

browser);

6090

g_signal_connect (browser->notebook, "context-menu",

6091

G_CALLBACK (midori_browser_notebook_context_menu_cb),

6092

browser);

6093

g_signal_connect (browser->notebook, "tab-context-menu",

6094

G_CALLBACK (midori_browser_notebook_tab_context_menu_cb), browser);

6095

g_signal_connect (browser->notebook, "tab-detached",

6463

6096

G_CALLBACK (midori_browser_notebook_create_window_cb), browser);

6464

#endif

6097

g_signal_connect (browser->notebook, "new-tab",

6098

G_CALLBACK (midori_browser_notebook_new_tab_cb), browser);

6465

6099

gtk_widget_show (browser->notebook);

6466

6100

6467

6101

/* Inspector container */

6768

6402

}

6769

6403

else if (token_current != token_dontcare && token_last == token_dontcare)

6770

6404

continue;

6771

#ifdef HAVE_GRANITE

6772

6405

/* A "new tab" button is already part of the notebook */

6773

6406

else if (!strcmp (gtk_action_get_name (action), "TabNew"))

6774

6407

continue;

6775

#endif

6776

6408

else

6777

6409

toolitem = gtk_action_create_tool_item (action);

6778

6410

6839

6471

gboolean show_panel;

6840

6472

MidoriToolbarStyle toolbar_style;

6841

6473

gchar* toolbar_items;

6842

gboolean close_buttons_on_tabs;

6474

gboolean close_buttons_left, close_buttons_on_tabs;

6843

6475

6844

6476

g_object_get (browser->settings,

6845

6477

"remember-last-window-size", &remember_last_window_size,

6859

6491

"show-statusbar", &browser->show_statusbar,

6860

6492

"toolbar-style", &toolbar_style,

6861

6493

"toolbar-items", &toolbar_items,

6494

"close-buttons-left", &close_buttons_left,

6862

6495

"close-buttons-on-tabs", &close_buttons_on_tabs,

6863

6496

"maximum-history-age", &browser->maximum_history_age,

6864

6497

NULL);

6865

6498

6866

#ifdef HAVE_GRANITE

6867

granite_widgets_dynamic_notebook_set_tabs_closable (

6868

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), close_buttons_on_tabs);

6869

#endif

6499

midori_notebook_set_close_buttons_visible (

6500

MIDORI_NOTEBOOK (browser->notebook), close_buttons_on_tabs);

6501

midori_notebook_set_close_buttons_left (

6502

MIDORI_NOTEBOOK (browser->notebook), close_buttons_left);

6870

6503

midori_findbar_set_close_button_left (MIDORI_FINDBAR (browser->find),

6871

katze_object_get_boolean (browser->settings, "close-buttons-left"));

6504

close_buttons_left);

6872

6505

if (browser->dial != NULL)

6873

midori_speed_dial_set_close_buttons_left (browser->dial,

6874

katze_object_get_boolean (browser->settings, "close-buttons-left"));

6506

midori_speed_dial_set_close_buttons_left (browser->dial, close_buttons_left);

6875

6507

6876

6508

midori_browser_set_inactivity_reset (browser, inactivity_reset);

6877

6509

6992

6624

}

6993

6625

else if (name == g_intern_string ("maximum-history-age"))

6994

6626

browser->maximum_history_age = g_value_get_int (&value);

6995

#ifdef HAVE_GRANITE

6996

6627

else if (name == g_intern_string ("close-buttons-on-tabs"))

6997

granite_widgets_dynamic_notebook_set_tabs_closable (

6998

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), g_value_get_boolean (&value));

6999

#endif

6628

midori_notebook_set_close_buttons_visible (

6629

MIDORI_NOTEBOOK (browser->notebook), g_value_get_boolean (&value));

7000

6630

else if (name == g_intern_string ("close-buttons-left"))

7001

6631

{

7002

6632

midori_findbar_set_close_button_left (MIDORI_FINDBAR (browser->find),

7003

6633

g_value_get_boolean (&value));

7004

6634

midori_speed_dial_set_close_buttons_left (browser->dial,

7005

katze_object_get_boolean (browser->settings, "close-buttons-left"));

6635

g_value_get_boolean (&value));

6636

midori_notebook_set_close_buttons_left (

6637

MIDORI_NOTEBOOK (browser->notebook), g_value_get_boolean (&value));

7006

6638

}

7007

6639

else if (name == g_intern_string ("inactivity-reset"))

7008

6640

midori_browser_set_inactivity_reset (browser, g_value_get_uint (&value));

7325

6957

g_value_set_object (value, browser->navigationbar);

7326

6958

break;

7327

6959

case PROP_NOTEBOOK:

7328

g_value_set_object (value, browser->notebook);

6960

g_value_set_object (value, MIDORI_NOTEBOOK (browser->notebook)->notebook);

7329

6961

break;

7330

6962

case PROP_PANEL:

7331

6963

g_value_set_object (value, browser->panel);

7446

7078

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), -1);

7447

7079

g_return_val_if_fail (MIDORI_IS_VIEW (view), -1);

7448

7080

7449

#ifdef HAVE_GRANITE

7450

return granite_widgets_dynamic_notebook_get_tab_position (

7451

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook),

7452

midori_view_get_tab (MIDORI_VIEW (view)));

7453

#else

7454

return gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), view);

7455

#endif

7081

return midori_notebook_get_tab_index (MIDORI_NOTEBOOK (browser->notebook), MIDORI_TAB (view));

7456

7082

}

7457

7083

7458

7084

7471

7097

g_return_if_fail (MIDORI_IS_BROWSER (browser));

7472

7098

g_return_if_fail (GTK_IS_WIDGET (view));

7473

7099

7474

midori_browser_add_tab_to_trash (browser, MIDORI_VIEW (view));

7475

7100

g_signal_emit (browser, signals[REMOVE_TAB], 0, view);

7476

7101

}

7477

7102

7697

7322

view = midori_browser_get_nth_tab (browser, n);

7698

7323

g_return_if_fail (view != NULL);

7699

7324

7700

#ifdef HAVE_GRANITE

7701

granite_widgets_dynamic_notebook_set_current (

7702

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook),

7703

midori_view_get_tab (MIDORI_VIEW (view)));

7704

#else

7705

gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);

7706

#endif

7707

if (midori_view_is_blank (MIDORI_VIEW (view)))

7708

midori_browser_activate_action (browser, "Location");

7709

else

7710

gtk_widget_grab_focus (view);

7711

7712

g_object_freeze_notify (G_OBJECT (browser));

7713

g_object_notify (G_OBJECT (browser), "uri");

7714

g_object_notify (G_OBJECT (browser), "tab");

7715

g_object_thaw_notify (G_OBJECT (browser));

7325

midori_browser_set_tab (browser, view);

7716

7326

}

7717

7327

7718

7328

/**

7730

7340

{

7731

7341

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), -1);

7732

7342

7733

#ifdef HAVE_GRANITE

7734

GraniteWidgetsTab* tab = granite_widgets_dynamic_notebook_get_current (

7735

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook));

7736

return tab ? granite_widgets_dynamic_notebook_get_tab_position (

7737

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), tab) : -1;

7738

#else

7739

return gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));

7740

#endif

7343

return midori_notebook_get_index (MIDORI_NOTEBOOK (browser->notebook));

7741

7344

}

7742

7345

7743

7346

/**

7783

7386

midori_browser_get_nth_tab (MidoriBrowser* browser,

7784

7387

gint page)

7785

7388

{

7786

#ifdef HAVE_GRANITE

7787

GraniteWidgetsTab* tab;

7788

7789

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);

7790

7791

tab = granite_widgets_dynamic_notebook_get_tab_by_index (

7792

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook), page);

7793

return tab != NULL ? granite_widgets_tab_get_page (tab) : NULL;

7794

#else

7795

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);

7796

7797

return gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), page);

7798

#endif

7389

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);

7390

7391

return (GtkWidget*)midori_notebook_get_nth_tab (MIDORI_NOTEBOOK (browser->notebook), page);

7799

7392

}

7800

7393

7801

7394

/**

7813

7406

midori_browser_set_current_tab (MidoriBrowser* browser,

7814

7407

GtkWidget* view)

7815

7408

{

7816

gint n;

7817

7818

7409

g_return_if_fail (MIDORI_IS_BROWSER (browser));

7819

7410

g_return_if_fail (GTK_IS_WIDGET (view));

7820

7411

7821

n = midori_browser_page_num (browser, view);

7822

midori_browser_set_current_page (browser, n);

7412

midori_notebook_set_tab (MIDORI_NOTEBOOK (browser->notebook), MIDORI_TAB (view));

7413

if (midori_tab_is_blank (MIDORI_TAB (view)))

7414

midori_browser_activate_action (browser, "Location");

7415

else

7416

gtk_widget_grab_focus (view);

7417

7418

g_object_freeze_notify (G_OBJECT (browser));

7419

g_object_notify (G_OBJECT (browser), "uri");

7420

g_object_notify (G_OBJECT (browser), "tab");

7421

g_object_thaw_notify (G_OBJECT (browser));

7823

7422

}

7824

7423

7825

7424

/**

7839

7438

GtkWidget*

7840

7439

midori_browser_get_current_tab (MidoriBrowser* browser)

7841

7440

{

7842

#if 0 // def HAVE_GRANITE

7843

GraniteWidgetsTab* tab;

7844

#else

7845

gint n;

7846

#endif

7847

7848

7441

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);

7849

7442

7850

#if 0 // FIXME: not reliable def HAVE_GRANITE

7851

tab = granite_widgets_dynamic_notebook_get_current (

7852

GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook));

7853

return tab ? granite_widgets_tab_get_page (tab) : NULL;

7854

#else

7855

n = midori_browser_get_current_page (browser);

7856

return (n >= 0) ? midori_browser_get_nth_tab (browser, n) : NULL;

7857

#endif

7443

return (GtkWidget*)midori_notebook_get_tab (MIDORI_NOTEBOOK (browser->notebook));

7858

7444

}

7859

7445

7860

7446

/**

7872

7458

{

7873

7459

g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);

7874

7460

7875

#ifdef HAVE_GRANITE

7876

/* FIXME: granite doesn't correctly implemented gtk.container */

7877

return granite_widgets_dynamic_notebook_get_children (GRANITE_WIDGETS_DYNAMIC_NOTEBOOK (browser->notebook));

7878

#else

7879

7461

return gtk_container_get_children (GTK_CONTAINER (browser->notebook));

7880

#endif

7881

7462

}

7882

7463

7883

7464

/**